src/third_party/skia/tests/ImageFilterTest.cpp

   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 "SkBitmap.h"
   9 #include "SkBitmapDevice.h"
  10 #include "SkBitmapSource.h"
  11 #include "SkBlurImageFilter.h"
  12 #include "SkCanvas.h"
  13 #include "SkColorFilterImageFilter.h"
  14 #include "SkColorMatrixFilter.h"
  15 #include "SkDeviceImageFilterProxy.h"
  16 #include "SkDisplacementMapEffect.h"
  17 #include "SkDropShadowImageFilter.h"
  18 #include "SkFlattenableSerialization.h"
  19 #include "SkGradientShader.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 "SkPerlinNoiseShader.h"
  27 #include "SkPicture.h"
  28 #include "SkPictureImageFilter.h"
  29 #include "SkPictureRecorder.h"
  30 #include "SkReadBuffer.h"
  31 #include "SkRect.h"
  32 #include "SkRectShaderImageFilter.h"
  33 #include "SkTileImageFilter.h"
  34 #include "SkXfermodeImageFilter.h"
  35 #include "Test.h"
  36
  37 #if SK_SUPPORT_GPU
  38 #include "GrContextFactory.h"
  39 #include "SkGpuDevice.h"
  40 #endif
  41
  42 static const int kBitmapSize = 4;
  43
  44 namespace {
  45
  46 class MatrixTestImageFilter : public SkImageFilter {
  47 public:
  48     MatrixTestImageFilter(skiatest::Reporter* reporter, const SkMatrix& expectedMatrix)
  49       : SkImageFilter(0, NULL), fReporter(reporter), fExpectedMatrix(expectedMatrix) {
  50     }
  51
  52     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context& ctx,
  53                                SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
  54         REPORTER_ASSERT(fReporter, ctx.ctm() == fExpectedMatrix);
  55         return true;
  56     }
  57
  58     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
  59
  60 protected:
  61 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
  62     explicit MatrixTestImageFilter(SkReadBuffer& buffer) : SkImageFilter(0, NULL) {
  63         fReporter = static_cast<skiatest::Reporter*>(buffer.readFunctionPtr());
  64         buffer.readMatrix(&fExpectedMatrix);
  65     }
  66 #endif
  67
  68     virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
  69         this->INHERITED::flatten(buffer);
  70         buffer.writeFunctionPtr(fReporter);
  71         buffer.writeMatrix(fExpectedMatrix);
  72     }
  73
  74 private:
  75     skiatest::Reporter* fReporter;
  76     SkMatrix fExpectedMatrix;
  77
  78     typedef SkImageFilter INHERITED;
  79 };
  80
  81 }
  82
  83 SkFlattenable* MatrixTestImageFilter::CreateProc(SkReadBuffer& buffer) {
  84     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
  85     skiatest::Reporter* reporter = (skiatest::Reporter*)buffer.readFunctionPtr();
  86     SkMatrix matrix;
  87     buffer.readMatrix(&matrix);
  88     return SkNEW_ARGS(MatrixTestImageFilter, (reporter, matrix));
  89 }
  90
  91 static void make_small_bitmap(SkBitmap& bitmap) {
  92     bitmap.allocN32Pixels(kBitmapSize, kBitmapSize);
  93     SkCanvas canvas(bitmap);
  94     canvas.clear(0x00000000);
  95     SkPaint darkPaint;
  96     darkPaint.setColor(0xFF804020);
  97     SkPaint lightPaint;
  98     lightPaint.setColor(0xFF244484);
  99     const int i = kBitmapSize / 4;
 100     for (int y = 0; y < kBitmapSize; y += i) {
 101         for (int x = 0; x < kBitmapSize; x += i) {
 102             canvas.save();
 103             canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
 104             canvas.drawRect(SkRect::MakeXYWH(0, 0,
 105                                              SkIntToScalar(i),
 106                                              SkIntToScalar(i)), darkPaint);
 107             canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
 108                                              0,
 109                                              SkIntToScalar(i),
 110                                              SkIntToScalar(i)), lightPaint);
 111             canvas.drawRect(SkRect::MakeXYWH(0,
 112                                              SkIntToScalar(i),
 113                                              SkIntToScalar(i),
 114                                              SkIntToScalar(i)), lightPaint);
 115             canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
 116                                              SkIntToScalar(i),
 117                                              SkIntToScalar(i),
 118                                              SkIntToScalar(i)), darkPaint);
 119             canvas.restore();
 120         }
 121     }
 122 }
 123
 124 static SkImageFilter* make_scale(float amount, SkImageFilter* input = NULL) {
 125     SkScalar s = amount;
 126     SkScalar matrix[20] = { s, 0, 0, 0, 0,
 127                             0, s, 0, 0, 0,
 128                             0, 0, s, 0, 0,
 129                             0, 0, 0, s, 0 };
 130     SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
 131     return SkColorFilterImageFilter::Create(filter, input);
 132 }
 133
 134 static SkImageFilter* make_grayscale(SkImageFilter* input = NULL, const SkImageFilter::CropRect* cropRect = NULL) {
 135     SkScalar matrix[20];
 136     memset(matrix, 0, 20 * sizeof(SkScalar));
 137     matrix[0] = matrix[5] = matrix[10] = 0.2126f;
 138     matrix[1] = matrix[6] = matrix[11] = 0.7152f;
 139     matrix[2] = matrix[7] = matrix[12] = 0.0722f;
 140     matrix[18] = 1.0f;
 141     SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
 142     return SkColorFilterImageFilter::Create(filter, input, cropRect);
 143 }
 144
 145 DEF_TEST(ImageFilter, reporter) {
 146     {
 147         // Check that two non-clipping color matrices concatenate into a single filter.
 148         SkAutoTUnref<SkImageFilter> halfBrightness(make_scale(0.5f));
 149         SkAutoTUnref<SkImageFilter> quarterBrightness(make_scale(0.5f, halfBrightness));
 150         REPORTER_ASSERT(reporter, NULL == quarterBrightness->getInput(0));
 151     }
 152
 153     {
 154         // Check that a clipping color matrix followed by a grayscale does not concatenate into a single filter.
 155         SkAutoTUnref<SkImageFilter> doubleBrightness(make_scale(2.0f));
 156         SkAutoTUnref<SkImageFilter> halfBrightness(make_scale(0.5f, doubleBrightness));
 157         REPORTER_ASSERT(reporter, halfBrightness->getInput(0));
 158     }
 159
 160     {
 161         // Check that a color filter image filter without a crop rect can be
 162         // expressed as a color filter.
 163         SkAutoTUnref<SkImageFilter> gray(make_grayscale());
 164         REPORTER_ASSERT(reporter, true == gray->asColorFilter(NULL));
 165     }
 166
 167     {
 168         // Check that a color filter image filter with a crop rect cannot
 169         // be expressed as a color filter.
 170         SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(0, 0, 100, 100));
 171         SkAutoTUnref<SkImageFilter> grayWithCrop(make_grayscale(NULL, &cropRect));
 172         REPORTER_ASSERT(reporter, false == grayWithCrop->asColorFilter(NULL));
 173     }
 174
 175     {
 176         // Check that two non-commutative matrices are concatenated in
 177         // the correct order.
 178         SkScalar blueToRedMatrix[20] = { 0 };
 179         blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
 180         SkScalar redToGreenMatrix[20] = { 0 };
 181         redToGreenMatrix[5] = redToGreenMatrix[18] = SK_Scalar1;
 182         SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
 183         SkAutoTUnref<SkImageFilter> filter1(SkColorFilterImageFilter::Create(blueToRed.get()));
 184         SkAutoTUnref<SkColorFilter> redToGreen(SkColorMatrixFilter::Create(redToGreenMatrix));
 185         SkAutoTUnref<SkImageFilter> filter2(SkColorFilterImageFilter::Create(redToGreen.get(), filter1.get()));
 186
 187         SkBitmap result;
 188         result.allocN32Pixels(kBitmapSize, kBitmapSize);
 189
 190         SkPaint paint;
 191         paint.setColor(SK_ColorBLUE);
 192         paint.setImageFilter(filter2.get());
 193         SkCanvas canvas(result);
 194         canvas.clear(0x0);
 195         SkRect rect = SkRect::Make(SkIRect::MakeWH(kBitmapSize, kBitmapSize));
 196         canvas.drawRect(rect, paint);
 197         uint32_t pixel = *result.getAddr32(0, 0);
 198         // The result here should be green, since we have effectively shifted blue to green.
 199         REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 200     }
 201
 202     {
 203         // Tests pass by not asserting
 204         SkBitmap bitmap, result;
 205         make_small_bitmap(bitmap);
 206         result.allocN32Pixels(kBitmapSize, kBitmapSize);
 207
 208         {
 209             // This tests for :
 210             // 1 ) location at (0,0,1)
 211             SkPoint3 location(0, 0, SK_Scalar1);
 212             // 2 ) location and target at same value
 213             SkPoint3 target(location.fX, location.fY, location.fZ);
 214             // 3 ) large negative specular exponent value
 215             SkScalar specularExponent = -1000;
 216
 217             SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
 218             SkPaint paint;
 219             paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
 220                     location, target, specularExponent, 180,
 221                     0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
 222                     bmSrc))->unref();
 223             SkCanvas canvas(result);
 224             SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
 225                                       SkIntToScalar(kBitmapSize));
 226             canvas.drawRect(r, paint);
 227         }
 228     }
 229 }
 230
 231 static void test_crop_rects(SkBaseDevice* device, skiatest::Reporter* reporter) {
 232     // Check that all filters offset to their absolute crop rect,
 233     // unaffected by the input crop rect.
 234     // Tests pass by not asserting.
 235     SkBitmap bitmap;
 236     bitmap.allocN32Pixels(100, 100);
 237     bitmap.eraseARGB(0, 0, 0, 0);
 238     SkDeviceImageFilterProxy proxy(device);
 239
 240     SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80));
 241     SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60));
 242     SkAutoTUnref<SkImageFilter> input(make_grayscale(NULL, &inputCropRect));
 243
 244     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
 245     SkPoint3 location(0, 0, SK_Scalar1);
 246     SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1);
 247     SkScalar kernel[9] = {
 248         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
 249         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
 250         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
 251     };
 252     SkISize kernelSize = SkISize::Make(3, 3);
 253     SkScalar gain = SK_Scalar1, bias = 0;
 254
 255     SkImageFilter* filters[] = {
 256         SkColorFilterImageFilter::Create(cf.get(), input.get(), &cropRect),
 257         SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
 258                                         SkDisplacementMapEffect::kB_ChannelSelectorType,
 259                                         40.0f, input.get(), input.get(), &cropRect),
 260         SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
 261         SkDropShadowImageFilter::Create(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1,
 262             SK_ColorGREEN, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
 263             input.get(), &cropRect, 0),
 264         SkLightingImageFilter::CreatePointLitDiffuse(location, SK_ColorGREEN, 0, 0, input.get(), &cropRect),
 265         SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0, input.get(), &cropRect),
 266         SkMatrixConvolutionImageFilter::Create(kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1), SkMatrixConvolutionImageFilter::kRepeat_TileMode, false, input.get(), &cropRect),
 267         SkMergeImageFilter::Create(input.get(), input.get(), SkXfermode::kSrcOver_Mode, &cropRect),
 268         SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
 269         SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
 270         SkDilateImageFilter::Create(3, 2, input.get(), &cropRect),
 271         SkErodeImageFilter::Create(2, 3, input.get(), &cropRect),
 272         SkTileImageFilter::Create(inputCropRect.rect(), cropRect.rect(), input.get()),
 273         SkXfermodeImageFilter::Create(SkXfermode::Create(SkXfermode::kSrcOver_Mode), input.get(), input.get(), &cropRect),
 274     };
 275
 276     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
 277         SkImageFilter* filter = filters[i];
 278         SkBitmap result;
 279         SkIPoint offset;
 280         SkString str;
 281         str.printf("filter %d", static_cast<int>(i));
 282         SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL);
 283         REPORTER_ASSERT_MESSAGE(reporter, filter->filterImage(&proxy, bitmap, ctx,
 284                                 &result, &offset), str.c_str());
 285         REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, str.c_str());
 286     }
 287
 288     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
 289         SkSafeUnref(filters[i]);
 290     }
 291 }
 292
 293 static SkBitmap make_gradient_circle(int width, int height) {
 294     SkBitmap bitmap;
 295     SkScalar x = SkIntToScalar(width / 2);
 296     SkScalar y = SkIntToScalar(height / 2);
 297     SkScalar radius = SkMinScalar(x, y) * 0.8f;
 298     bitmap.allocN32Pixels(width, height);
 299     SkCanvas canvas(bitmap);
 300     canvas.clear(0x00000000);
 301     SkColor colors[2];
 302     colors[0] = SK_ColorWHITE;
 303     colors[1] = SK_ColorBLACK;
 304     SkAutoTUnref<SkShader> shader(
 305         SkGradientShader::CreateRadial(SkPoint::Make(x, y), radius, colors, NULL, 2,
 306                                        SkShader::kClamp_TileMode)
 307     );
 308     SkPaint paint;
 309     paint.setShader(shader);
 310     canvas.drawCircle(x, y, radius, paint);
 311     return bitmap;
 312 }
 313
 314 static void test_negative_blur_sigma(SkBaseDevice* device, skiatest::Reporter* reporter) {
 315     // Check that SkBlurImageFilter will accept a negative sigma, either in
 316     // the given arguments or after CTM application.
 317     int width = 32, height = 32;
 318     SkDeviceImageFilterProxy proxy(device);
 319     SkScalar five = SkIntToScalar(5);
 320
 321     SkAutoTUnref<SkBlurImageFilter> positiveFilter(
 322         SkBlurImageFilter::Create(five, five)
 323     );
 324
 325     SkAutoTUnref<SkBlurImageFilter> negativeFilter(
 326         SkBlurImageFilter::Create(-five, five)
 327     );
 328
 329     SkBitmap gradient = make_gradient_circle(width, height);
 330     SkBitmap positiveResult1, negativeResult1;
 331     SkBitmap positiveResult2, negativeResult2;
 332     SkIPoint offset;
 333     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL);
 334     positiveFilter->filterImage(&proxy, gradient, ctx, &positiveResult1, &offset);
 335     negativeFilter->filterImage(&proxy, gradient, ctx, &negativeResult1, &offset);
 336     SkMatrix negativeScale;
 337     negativeScale.setScale(-SK_Scalar1, SK_Scalar1);
 338     SkImageFilter::Context negativeCTX(negativeScale, SkIRect::MakeLargest(), NULL);
 339     positiveFilter->filterImage(&proxy, gradient, negativeCTX, &negativeResult2, &offset);
 340     negativeFilter->filterImage(&proxy, gradient, negativeCTX, &positiveResult2, &offset);
 341     SkAutoLockPixels lockP1(positiveResult1);
 342     SkAutoLockPixels lockP2(positiveResult2);
 343     SkAutoLockPixels lockN1(negativeResult1);
 344     SkAutoLockPixels lockN2(negativeResult2);
 345     for (int y = 0; y < height; y++) {
 346         int diffs = memcmp(positiveResult1.getAddr32(0, y), negativeResult1.getAddr32(0, y), positiveResult1.rowBytes());
 347         REPORTER_ASSERT(reporter, !diffs);
 348         if (diffs) {
 349             break;
 350         }
 351         diffs = memcmp(positiveResult1.getAddr32(0, y), negativeResult2.getAddr32(0, y), positiveResult1.rowBytes());
 352         REPORTER_ASSERT(reporter, !diffs);
 353         if (diffs) {
 354             break;
 355         }
 356         diffs = memcmp(positiveResult1.getAddr32(0, y), positiveResult2.getAddr32(0, y), positiveResult1.rowBytes());
 357         REPORTER_ASSERT(reporter, !diffs);
 358         if (diffs) {
 359             break;
 360         }
 361     }
 362 }
 363
 364 DEF_TEST(TestNegativeBlurSigma, reporter) {
 365     SkBitmap temp;
 366     temp.allocN32Pixels(100, 100);
 367     SkBitmapDevice device(temp);
 368     test_negative_blur_sigma(&device, reporter);
 369 }
 370
 371 DEF_TEST(ImageFilterDrawTiled, reporter) {
 372     // Check that all filters when drawn tiled (with subsequent clip rects) exactly
 373     // match the same filters drawn with a single full-canvas bitmap draw.
 374     // Tests pass by not asserting.
 375
 376     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
 377     SkPoint3 location(0, 0, SK_Scalar1);
 378     SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1);
 379     SkScalar kernel[9] = {
 380         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
 381         SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
 382         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
 383     };
 384     SkISize kernelSize = SkISize::Make(3, 3);
 385     SkScalar gain = SK_Scalar1, bias = 0;
 386     SkScalar five = SkIntToScalar(5);
 387
 388     SkAutoTUnref<SkImageFilter> gradient_source(SkBitmapSource::Create(make_gradient_circle(64, 64)));
 389     SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(five, five));
 390     SkMatrix matrix;
 391
 392     matrix.setTranslate(SK_Scalar1, SK_Scalar1);
 393     matrix.postRotate(SkIntToScalar(45), SK_Scalar1, SK_Scalar1);
 394
 395     SkRTreeFactory factory;
 396     SkPictureRecorder recorder;
 397     SkCanvas* recordingCanvas = recorder.beginRecording(64, 64, &factory, 0);
 398
 399     SkPaint greenPaint;
 400     greenPaint.setColor(SK_ColorGREEN);
 401     recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeXYWH(10, 10, 30, 20)), greenPaint);
 402     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 403     SkAutoTUnref<SkImageFilter> pictureFilter(SkPictureImageFilter::Create(picture.get()));
 404     SkAutoTUnref<SkShader> shader(SkPerlinNoiseShader::CreateTurbulence(SK_Scalar1, SK_Scalar1, 1, 0));
 405
 406     SkAutoTUnref<SkImageFilter> rectShaderFilter(SkRectShaderImageFilter::Create(shader.get()));
 407
 408     struct {
 409         const char*    fName;
 410         SkImageFilter* fFilter;
 411     } filters[] = {
 412         { "color filter", SkColorFilterImageFilter::Create(cf.get()) },
 413         { "displacement map", SkDisplacementMapEffect::Create(
 414               SkDisplacementMapEffect::kR_ChannelSelectorType,
 415               SkDisplacementMapEffect::kB_ChannelSelectorType,
 416               20.0f, gradient_source.get()) },
 417         { "blur", SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1) },
 418         { "drop shadow", SkDropShadowImageFilter::Create(
 419               SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN,
 420               SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode) },
 421         { "diffuse lighting", SkLightingImageFilter::CreatePointLitDiffuse(
 422               location, SK_ColorGREEN, 0, 0) },
 423         { "specular lighting",
 424               SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0) },
 425         { "matrix convolution",
 426               SkMatrixConvolutionImageFilter::Create(
 427                   kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1),
 428                   SkMatrixConvolutionImageFilter::kRepeat_TileMode, false) },
 429         { "merge", SkMergeImageFilter::Create(NULL, NULL, SkXfermode::kSrcOver_Mode) },
 430         { "offset", SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1) },
 431         { "dilate", SkDilateImageFilter::Create(3, 2) },
 432         { "erode", SkErodeImageFilter::Create(2, 3) },
 433         { "tile", SkTileImageFilter::Create(SkRect::MakeXYWH(0, 0, 50, 50),
 434                                             SkRect::MakeXYWH(0, 0, 100, 100), NULL) },
 435         { "matrix", SkMatrixImageFilter::Create(matrix, SkPaint::kLow_FilterLevel) },
 436         { "blur and offset", SkOffsetImageFilter::Create(five, five, blur.get()) },
 437         { "picture and blur", SkBlurImageFilter::Create(five, five, pictureFilter.get()) },
 438         { "rect shader and blur", SkBlurImageFilter::Create(five, five, rectShaderFilter.get()) },
 439     };
 440
 441     SkBitmap untiledResult, tiledResult;
 442     int width = 64, height = 64;
 443     untiledResult.allocN32Pixels(width, height);
 444     tiledResult.allocN32Pixels(width, height);
 445     SkCanvas tiledCanvas(tiledResult);
 446     SkCanvas untiledCanvas(untiledResult);
 447     int tileSize = 8;
 448
 449     for (int scale = 1; scale <= 2; ++scale) {
 450         for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
 451             tiledCanvas.clear(0);
 452             untiledCanvas.clear(0);
 453             SkPaint paint;
 454             paint.setImageFilter(filters[i].fFilter);
 455             paint.setTextSize(SkIntToScalar(height));
 456             paint.setColor(SK_ColorWHITE);
 457             SkString str;
 458             const char* text = "ABC";
 459             SkScalar ypos = SkIntToScalar(height);
 460             untiledCanvas.save();
 461             untiledCanvas.scale(SkIntToScalar(scale), SkIntToScalar(scale));
 462             untiledCanvas.drawText(text, strlen(text), 0, ypos, paint);
 463             untiledCanvas.restore();
 464             for (int y = 0; y < height; y += tileSize) {
 465                 for (int x = 0; x < width; x += tileSize) {
 466                     tiledCanvas.save();
 467                     tiledCanvas.clipRect(SkRect::Make(SkIRect::MakeXYWH(x, y, tileSize, tileSize)));
 468                     tiledCanvas.scale(SkIntToScalar(scale), SkIntToScalar(scale));
 469                     tiledCanvas.drawText(text, strlen(text), 0, ypos, paint);
 470                     tiledCanvas.restore();
 471                 }
 472             }
 473             untiledCanvas.flush();
 474             tiledCanvas.flush();
 475             for (int y = 0; y < height; y++) {
 476                 int diffs = memcmp(untiledResult.getAddr32(0, y), tiledResult.getAddr32(0, y), untiledResult.rowBytes());
 477                 REPORTER_ASSERT_MESSAGE(reporter, !diffs, filters[i].fName);
 478                 if (diffs) {
 479                     break;
 480                 }
 481             }
 482         }
 483     }
 484
 485     for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
 486         SkSafeUnref(filters[i].fFilter);
 487     }
 488 }
 489
 490 static void draw_saveLayer_picture(int width, int height, int tileSize,
 491                                    SkBBHFactory* factory, SkBitmap* result) {
 492
 493     SkMatrix matrix;
 494     matrix.setTranslate(SkIntToScalar(50), 0);
 495
 496     SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorWHITE, SkXfermode::kSrc_Mode));
 497     SkAutoTUnref<SkImageFilter> cfif(SkColorFilterImageFilter::Create(cf.get()));
 498     SkAutoTUnref<SkImageFilter> imageFilter(SkMatrixImageFilter::Create(matrix, SkPaint::kNone_FilterLevel, cfif.get()));
 499
 500     SkPaint paint;
 501     paint.setImageFilter(imageFilter.get());
 502     SkPictureRecorder recorder;
 503     SkRect bounds = SkRect::Make(SkIRect::MakeXYWH(0, 0, 50, 50));
 504     SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(width),
 505                                                         SkIntToScalar(height),
 506                                                         factory, 0);
 507     recordingCanvas->translate(-55, 0);
 508     recordingCanvas->saveLayer(&bounds, &paint);
 509     recordingCanvas->restore();
 510     SkAutoTUnref<SkPicture> picture1(recorder.endRecording());
 511
 512     result->allocN32Pixels(width, height);
 513     SkCanvas canvas(*result);
 514     canvas.clear(0);
 515     canvas.clipRect(SkRect::Make(SkIRect::MakeWH(tileSize, tileSize)));
 516     canvas.drawPicture(picture1.get());
 517 }
 518
 519 DEF_TEST(ImageFilterDrawMatrixBBH, reporter) {
 520     // Check that matrix filter when drawn tiled with BBH exactly
 521     // matches the same thing drawn without BBH.
 522     // Tests pass by not asserting.
 523
 524     const int width = 200, height = 200;
 525     const int tileSize = 100;
 526     SkBitmap result1, result2;
 527     SkRTreeFactory factory;
 528
 529     draw_saveLayer_picture(width, height, tileSize, &factory, &result1);
 530     draw_saveLayer_picture(width, height, tileSize, NULL, &result2);
 531
 532     for (int y = 0; y < height; y++) {
 533         int diffs = memcmp(result1.getAddr32(0, y), result2.getAddr32(0, y), result1.rowBytes());
 534         REPORTER_ASSERT(reporter, !diffs);
 535         if (diffs) {
 536             break;
 537         }
 538     }
 539 }
 540
 541 static SkImageFilter* makeBlur(SkImageFilter* input = NULL) {
 542     return SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input);
 543 }
 544
 545 static SkImageFilter* makeDropShadow(SkImageFilter* input = NULL) {
 546     return SkDropShadowImageFilter::Create(
 547         SkIntToScalar(100), SkIntToScalar(100),
 548         SkIntToScalar(10), SkIntToScalar(10),
 549         SK_ColorBLUE, SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode,
 550         input, NULL, 0);
 551 }
 552
 553 DEF_TEST(ImageFilterBlurThenShadowBounds, reporter) {
 554     SkAutoTUnref<SkImageFilter> filter1(makeBlur());
 555     SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
 556
 557     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
 558     SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
 559     filter2->filterBounds(bounds, SkMatrix::I(), &bounds);
 560
 561     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 562 }
 563
 564 DEF_TEST(ImageFilterShadowThenBlurBounds, reporter) {
 565     SkAutoTUnref<SkImageFilter> filter1(makeDropShadow());
 566     SkAutoTUnref<SkImageFilter> filter2(makeBlur(filter1.get()));
 567
 568     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
 569     SkIRect expectedBounds = SkIRect::MakeXYWH(-133, -133, 236, 236);
 570     filter2->filterBounds(bounds, SkMatrix::I(), &bounds);
 571
 572     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 573 }
 574
 575 DEF_TEST(ImageFilterDilateThenBlurBounds, reporter) {
 576     SkAutoTUnref<SkImageFilter> filter1(SkDilateImageFilter::Create(2, 2));
 577     SkAutoTUnref<SkImageFilter> filter2(makeDropShadow(filter1.get()));
 578
 579     SkIRect bounds = SkIRect::MakeXYWH(0, 0, 100, 100);
 580     SkIRect expectedBounds = SkIRect::MakeXYWH(-132, -132, 234, 234);
 581     filter2->filterBounds(bounds, SkMatrix::I(), &bounds);
 582
 583     REPORTER_ASSERT(reporter, bounds == expectedBounds);
 584 }
 585
 586 static void draw_blurred_rect(SkCanvas* canvas) {
 587     SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(SkIntToScalar(8), 0));
 588     SkPaint filterPaint;
 589     filterPaint.setColor(SK_ColorWHITE);
 590     filterPaint.setImageFilter(filter);
 591     canvas->saveLayer(NULL, &filterPaint);
 592     SkPaint whitePaint;
 593     whitePaint.setColor(SK_ColorWHITE);
 594     canvas->drawRect(SkRect::Make(SkIRect::MakeWH(4, 4)), whitePaint);
 595     canvas->restore();
 596 }
 597
 598 static void draw_picture_clipped(SkCanvas* canvas, const SkRect& clipRect, const SkPicture* picture) {
 599     canvas->save();
 600     canvas->clipRect(clipRect);
 601     canvas->drawPicture(picture);
 602     canvas->restore();
 603 }
 604
 605 DEF_TEST(ImageFilterDrawTiledBlurRTree, reporter) {
 606     // Check that the blur filter when recorded with RTree acceleration,
 607     // and drawn tiled (with subsequent clip rects) exactly
 608     // matches the same filter drawn with without RTree acceleration.
 609     // This tests that the "bleed" from the blur into the otherwise-blank
 610     // tiles is correctly rendered.
 611     // Tests pass by not asserting.
 612
 613     int width = 16, height = 8;
 614     SkBitmap result1, result2;
 615     result1.allocN32Pixels(width, height);
 616     result2.allocN32Pixels(width, height);
 617     SkCanvas canvas1(result1);
 618     SkCanvas canvas2(result2);
 619     int tileSize = 8;
 620
 621     canvas1.clear(0);
 622     canvas2.clear(0);
 623
 624     SkRTreeFactory factory;
 625
 626     SkPictureRecorder recorder1, recorder2;
 627     // The only difference between these two pictures is that one has RTree aceleration.
 628     SkCanvas* recordingCanvas1 = recorder1.beginRecording(SkIntToScalar(width),
 629                                                           SkIntToScalar(height),
 630                                                           NULL, 0);
 631     SkCanvas* recordingCanvas2 = recorder2.beginRecording(SkIntToScalar(width),
 632                                                           SkIntToScalar(height),
 633                                                           &factory, 0);
 634     draw_blurred_rect(recordingCanvas1);
 635     draw_blurred_rect(recordingCanvas2);
 636     SkAutoTUnref<SkPicture> picture1(recorder1.endRecording());
 637     SkAutoTUnref<SkPicture> picture2(recorder2.endRecording());
 638     for (int y = 0; y < height; y += tileSize) {
 639         for (int x = 0; x < width; x += tileSize) {
 640             SkRect tileRect = SkRect::Make(SkIRect::MakeXYWH(x, y, tileSize, tileSize));
 641             draw_picture_clipped(&canvas1, tileRect, picture1);
 642             draw_picture_clipped(&canvas2, tileRect, picture2);
 643         }
 644     }
 645     for (int y = 0; y < height; y++) {
 646         int diffs = memcmp(result1.getAddr32(0, y), result2.getAddr32(0, y), result1.rowBytes());
 647         REPORTER_ASSERT(reporter, !diffs);
 648         if (diffs) {
 649             break;
 650         }
 651     }
 652 }
 653
 654 DEF_TEST(ImageFilterMatrixConvolution, reporter) {
 655     // Check that a 1x3 filter does not cause a spurious assert.
 656     SkScalar kernel[3] = {
 657         SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
 658     };
 659     SkISize kernelSize = SkISize::Make(1, 3);
 660     SkScalar gain = SK_Scalar1, bias = 0;
 661     SkIPoint kernelOffset = SkIPoint::Make(0, 0);
 662
 663     SkAutoTUnref<SkImageFilter> filter(
 664         SkMatrixConvolutionImageFilter::Create(
 665             kernelSize, kernel, gain, bias, kernelOffset,
 666             SkMatrixConvolutionImageFilter::kRepeat_TileMode, false));
 667
 668     SkBitmap result;
 669     int width = 16, height = 16;
 670     result.allocN32Pixels(width, height);
 671     SkCanvas canvas(result);
 672     canvas.clear(0);
 673
 674     SkPaint paint;
 675     paint.setImageFilter(filter);
 676     SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height));
 677     canvas.drawRect(rect, paint);
 678 }
 679
 680 DEF_TEST(ImageFilterMatrixConvolutionBorder, reporter) {
 681     // Check that a filter with borders outside the target bounds
 682     // does not crash.
 683     SkScalar kernel[3] = {
 684         0, 0, 0,
 685     };
 686     SkISize kernelSize = SkISize::Make(3, 1);
 687     SkScalar gain = SK_Scalar1, bias = 0;
 688     SkIPoint kernelOffset = SkIPoint::Make(2, 0);
 689
 690     SkAutoTUnref<SkImageFilter> filter(
 691         SkMatrixConvolutionImageFilter::Create(
 692             kernelSize, kernel, gain, bias, kernelOffset,
 693             SkMatrixConvolutionImageFilter::kClamp_TileMode, true));
 694
 695     SkBitmap result;
 696
 697     int width = 10, height = 10;
 698     result.allocN32Pixels(width, height);
 699     SkCanvas canvas(result);
 700     canvas.clear(0);
 701
 702     SkPaint filterPaint;
 703     filterPaint.setImageFilter(filter);
 704     SkRect bounds = SkRect::MakeWH(1, 10);
 705     SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height));
 706     SkPaint rectPaint;
 707     canvas.saveLayer(&bounds, &filterPaint);
 708     canvas.drawRect(rect, rectPaint);
 709     canvas.restore();
 710 }
 711
 712 DEF_TEST(ImageFilterCropRect, reporter) {
 713     SkBitmap temp;
 714     temp.allocN32Pixels(100, 100);
 715     SkBitmapDevice device(temp);
 716     test_crop_rects(&device, reporter);
 717 }
 718
 719 DEF_TEST(ImageFilterMatrix, reporter) {
 720     SkBitmap temp;
 721     temp.allocN32Pixels(100, 100);
 722     SkBitmapDevice device(temp);
 723     SkCanvas canvas(&device);
 724     canvas.scale(SkIntToScalar(2), SkIntToScalar(2));
 725
 726     SkMatrix expectedMatrix = canvas.getTotalMatrix();
 727
 728     SkRTreeFactory factory;
 729     SkPictureRecorder recorder;
 730     SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, &factory, 0);
 731
 732     SkPaint paint;
 733     SkAutoTUnref<MatrixTestImageFilter> imageFilter(
 734         new MatrixTestImageFilter(reporter, expectedMatrix));
 735     paint.setImageFilter(imageFilter.get());
 736     recordingCanvas->saveLayer(NULL, &paint);
 737     SkPaint solidPaint;
 738     solidPaint.setColor(0xFFFFFFFF);
 739     recordingCanvas->save();
 740     recordingCanvas->scale(SkIntToScalar(10), SkIntToScalar(10));
 741     recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(100, 100)), solidPaint);
 742     recordingCanvas->restore(); // scale
 743     recordingCanvas->restore(); // saveLayer
 744     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 745
 746     canvas.drawPicture(picture);
 747 }
 748
 749 DEF_TEST(ImageFilterCrossProcessPictureImageFilter, reporter) {
 750     SkRTreeFactory factory;
 751     SkPictureRecorder recorder;
 752     SkCanvas* recordingCanvas = recorder.beginRecording(1, 1, &factory, 0);
 753
 754     // Create an SkPicture which simply draws a green 1x1 rectangle.
 755     SkPaint greenPaint;
 756     greenPaint.setColor(SK_ColorGREEN);
 757     recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), greenPaint);
 758     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 759
 760     // Wrap that SkPicture in an SkPictureImageFilter.
 761     SkAutoTUnref<SkImageFilter> imageFilter(
 762         SkPictureImageFilter::Create(picture.get()));
 763
 764     // Check that SkPictureImageFilter successfully serializes its contained
 765     // SkPicture when not in cross-process mode.
 766     SkPaint paint;
 767     paint.setImageFilter(imageFilter.get());
 768     SkPictureRecorder outerRecorder;
 769     SkCanvas* outerCanvas = outerRecorder.beginRecording(1, 1, &factory, 0);
 770     SkPaint redPaintWithFilter;
 771     redPaintWithFilter.setColor(SK_ColorRED);
 772     redPaintWithFilter.setImageFilter(imageFilter.get());
 773     outerCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), redPaintWithFilter);
 774     SkAutoTUnref<SkPicture> outerPicture(outerRecorder.endRecording());
 775
 776     SkBitmap bitmap;
 777     bitmap.allocN32Pixels(1, 1);
 778     SkBitmapDevice device(bitmap);
 779     SkCanvas canvas(&device);
 780
 781     // The result here should be green, since the filter replaces the primitive's red interior.
 782     canvas.clear(0x0);
 783     canvas.drawPicture(outerPicture);
 784     uint32_t pixel = *bitmap.getAddr32(0, 0);
 785     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 786
 787     // Check that, for now, SkPictureImageFilter does not serialize or
 788     // deserialize its contained picture when the filter is serialized
 789     // cross-process. Do this by "laundering" it through SkValidatingReadBuffer.
 790     SkAutoTUnref<SkData> data(SkValidatingSerializeFlattenable(imageFilter.get()));
 791     SkAutoTUnref<SkFlattenable> flattenable(SkValidatingDeserializeFlattenable(
 792         data->data(), data->size(), SkImageFilter::GetFlattenableType()));
 793     SkImageFilter* unflattenedFilter = static_cast<SkImageFilter*>(flattenable.get());
 794
 795     redPaintWithFilter.setImageFilter(unflattenedFilter);
 796     SkPictureRecorder crossProcessRecorder;
 797     SkCanvas* crossProcessCanvas = crossProcessRecorder.beginRecording(1, 1, &factory, 0);
 798     crossProcessCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), redPaintWithFilter);
 799     SkAutoTUnref<SkPicture> crossProcessPicture(crossProcessRecorder.endRecording());
 800
 801     canvas.clear(0x0);
 802     canvas.drawPicture(crossProcessPicture);
 803     pixel = *bitmap.getAddr32(0, 0);
 804     // The result here should not be green, since the filter draws nothing.
 805     REPORTER_ASSERT(reporter, pixel != SK_ColorGREEN);
 806 }
 807
 808 DEF_TEST(ImageFilterClippedPictureImageFilter, reporter) {
 809     SkRTreeFactory factory;
 810     SkPictureRecorder recorder;
 811     SkCanvas* recordingCanvas = recorder.beginRecording(1, 1, &factory, 0);
 812
 813     // Create an SkPicture which simply draws a green 1x1 rectangle.
 814     SkPaint greenPaint;
 815     greenPaint.setColor(SK_ColorGREEN);
 816     recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), greenPaint);
 817     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 818
 819     SkAutoTUnref<SkImageFilter> imageFilter(
 820         SkPictureImageFilter::Create(picture.get()));
 821
 822     SkBitmap result;
 823     SkIPoint offset;
 824     SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(1, 1, 1, 1), NULL);
 825     SkBitmap bitmap;
 826     bitmap.allocN32Pixels(2, 2);
 827     SkBitmapDevice device(bitmap);
 828     SkDeviceImageFilterProxy proxy(&device);
 829     REPORTER_ASSERT(reporter, !imageFilter->filterImage(&proxy, bitmap, ctx, &result, &offset));
 830 }
 831
 832 DEF_TEST(ImageFilterEmptySaveLayer, reporter) {
 833     // Even when there's an empty saveLayer()/restore(), ensure that an image
 834     // filter or color filter which affects transparent black still draws.
 835
 836     SkBitmap bitmap;
 837     bitmap.allocN32Pixels(10, 10);
 838     SkBitmapDevice device(bitmap);
 839     SkCanvas canvas(&device);
 840
 841     SkRTreeFactory factory;
 842     SkPictureRecorder recorder;
 843
 844     SkAutoTUnref<SkColorFilter> green(
 845         SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode));
 846     SkAutoTUnref<SkColorFilterImageFilter> imageFilter(
 847         SkColorFilterImageFilter::Create(green.get()));
 848     SkPaint imageFilterPaint;
 849     imageFilterPaint.setImageFilter(imageFilter.get());
 850     SkPaint colorFilterPaint;
 851     colorFilterPaint.setColorFilter(green.get());
 852
 853     SkRect bounds = SkRect::MakeWH(10, 10);
 854
 855     SkCanvas* recordingCanvas = recorder.beginRecording(10, 10, &factory, 0);
 856     recordingCanvas->saveLayer(&bounds, &imageFilterPaint);
 857     recordingCanvas->restore();
 858     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 859
 860     canvas.clear(0);
 861     canvas.drawPicture(picture);
 862     uint32_t pixel = *bitmap.getAddr32(0, 0);
 863     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 864
 865     recordingCanvas = recorder.beginRecording(10, 10, &factory, 0);
 866     recordingCanvas->saveLayer(NULL, &imageFilterPaint);
 867     recordingCanvas->restore();
 868     SkAutoTUnref<SkPicture> picture2(recorder.endRecording());
 869
 870     canvas.clear(0);
 871     canvas.drawPicture(picture2);
 872     pixel = *bitmap.getAddr32(0, 0);
 873     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 874
 875     recordingCanvas = recorder.beginRecording(10, 10, &factory, 0);
 876     recordingCanvas->saveLayer(&bounds, &colorFilterPaint);
 877     recordingCanvas->restore();
 878     SkAutoTUnref<SkPicture> picture3(recorder.endRecording());
 879
 880     canvas.clear(0);
 881     canvas.drawPicture(picture3);
 882     pixel = *bitmap.getAddr32(0, 0);
 883     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 884 }
 885
 886 static void test_huge_blur(SkBaseDevice* device, skiatest::Reporter* reporter) {
 887     SkCanvas canvas(device);
 888
 889     SkBitmap bitmap;
 890     bitmap.allocN32Pixels(100, 100);
 891     bitmap.eraseARGB(0, 0, 0, 0);
 892
 893     // Check that a blur with an insane radius does not crash or assert.
 894     SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<30), SkIntToScalar(1<<30)));
 895
 896     SkPaint paint;
 897     paint.setImageFilter(blur);
 898     canvas.drawSprite(bitmap, 0, 0, &paint);
 899 }
 900
 901 DEF_TEST(HugeBlurImageFilter, reporter) {
 902     SkBitmap temp;
 903     temp.allocN32Pixels(100, 100);
 904     SkBitmapDevice device(temp);
 905     test_huge_blur(&device, reporter);
 906 }
 907
 908 DEF_TEST(MatrixConvolutionSanityTest, reporter) {
 909     SkScalar kernel[1] = { 0 };
 910     SkScalar gain = SK_Scalar1, bias = 0;
 911     SkIPoint kernelOffset = SkIPoint::Make(1, 1);
 912
 913     // Check that an enormous (non-allocatable) kernel gives a NULL filter.
 914     SkAutoTUnref<SkImageFilter> conv(SkMatrixConvolutionImageFilter::Create(
 915         SkISize::Make(1<<30, 1<<30),
 916         kernel,
 917         gain,
 918         bias,
 919         kernelOffset,
 920         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
 921         false));
 922
 923     REPORTER_ASSERT(reporter, NULL == conv.get());
 924
 925     // Check that a NULL kernel gives a NULL filter.
 926     conv.reset(SkMatrixConvolutionImageFilter::Create(
 927         SkISize::Make(1, 1),
 928         NULL,
 929         gain,
 930         bias,
 931         kernelOffset,
 932         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
 933         false));
 934
 935     REPORTER_ASSERT(reporter, NULL == conv.get());
 936
 937     // Check that a kernel width < 1 gives a NULL filter.
 938     conv.reset(SkMatrixConvolutionImageFilter::Create(
 939         SkISize::Make(0, 1),
 940         kernel,
 941         gain,
 942         bias,
 943         kernelOffset,
 944         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
 945         false));
 946
 947     REPORTER_ASSERT(reporter, NULL == conv.get());
 948
 949     // Check that kernel height < 1 gives a NULL filter.
 950     conv.reset(SkMatrixConvolutionImageFilter::Create(
 951         SkISize::Make(1, -1),
 952         kernel,
 953         gain,
 954         bias,
 955         kernelOffset,
 956         SkMatrixConvolutionImageFilter::kRepeat_TileMode,
 957         false));
 958
 959     REPORTER_ASSERT(reporter, NULL == conv.get());
 960 }
 961
 962 static void test_xfermode_cropped_input(SkBaseDevice* device, skiatest::Reporter* reporter) {
 963     SkCanvas canvas(device);
 964     canvas.clear(0);
 965
 966     SkBitmap bitmap;
 967     bitmap.allocN32Pixels(1, 1);
 968     bitmap.eraseARGB(255, 255, 255, 255);
 969
 970     SkAutoTUnref<SkColorFilter> green(
 971         SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode));
 972     SkAutoTUnref<SkColorFilterImageFilter> greenFilter(
 973         SkColorFilterImageFilter::Create(green.get()));
 974     SkImageFilter::CropRect cropRect(SkRect::MakeEmpty());
 975     SkAutoTUnref<SkColorFilterImageFilter> croppedOut(
 976         SkColorFilterImageFilter::Create(green.get(), NULL, &cropRect));
 977
 978     // Check that an xfermode image filter whose input has been cropped out still draws the other
 979     // input. Also check that drawing with both inputs cropped out doesn't cause a GPU warning.
 980     SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrcOver_Mode);
 981     SkAutoTUnref<SkImageFilter> xfermodeNoFg(
 982         SkXfermodeImageFilter::Create(mode, greenFilter, croppedOut));
 983     SkAutoTUnref<SkImageFilter> xfermodeNoBg(
 984         SkXfermodeImageFilter::Create(mode, croppedOut, greenFilter));
 985     SkAutoTUnref<SkImageFilter> xfermodeNoFgNoBg(
 986         SkXfermodeImageFilter::Create(mode, croppedOut, croppedOut));
 987
 988     SkPaint paint;
 989     paint.setImageFilter(xfermodeNoFg);
 990     canvas.drawSprite(bitmap, 0, 0, &paint);
 991
 992     uint32_t pixel;
 993     SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
 994     canvas.readPixels(info, &pixel, 4, 0, 0);
 995     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
 996
 997     paint.setImageFilter(xfermodeNoBg);
 998     canvas.drawSprite(bitmap, 0, 0, &paint);
 999     canvas.readPixels(info, &pixel, 4, 0, 0);
1000     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
1001
1002     paint.setImageFilter(xfermodeNoFgNoBg);
1003     canvas.drawSprite(bitmap, 0, 0, &paint);
1004     canvas.readPixels(info, &pixel, 4, 0, 0);
1005     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
1006 }
1007
1008 DEF_TEST(ImageFilterNestedSaveLayer, reporter) {
1009     SkBitmap temp;
1010     temp.allocN32Pixels(50, 50);
1011     SkBitmapDevice device(temp);
1012     SkCanvas canvas(&device);
1013     canvas.clear(0x0);
1014
1015     SkBitmap bitmap;
1016     bitmap.allocN32Pixels(10, 10);
1017     bitmap.eraseColor(SK_ColorGREEN);
1018
1019     SkMatrix matrix;
1020     matrix.setScale(SkIntToScalar(2), SkIntToScalar(2));
1021     matrix.postTranslate(SkIntToScalar(-20), SkIntToScalar(-20));
1022     SkAutoTUnref<SkImageFilter> matrixFilter(
1023         SkMatrixImageFilter::Create(matrix, SkPaint::kLow_FilterLevel));
1024
1025     // Test that saveLayer() with a filter nested inside another saveLayer() applies the
1026     // correct offset to the filter matrix.
1027     SkRect bounds1 = SkRect::MakeXYWH(10, 10, 30, 30);
1028     canvas.saveLayer(&bounds1, NULL);
1029     SkPaint filterPaint;
1030     filterPaint.setImageFilter(matrixFilter);
1031     SkRect bounds2 = SkRect::MakeXYWH(20, 20, 10, 10);
1032     canvas.saveLayer(&bounds2, &filterPaint);
1033     SkPaint greenPaint;
1034     greenPaint.setColor(SK_ColorGREEN);
1035     canvas.drawRect(bounds2, greenPaint);
1036     canvas.restore();
1037     canvas.restore();
1038     SkPaint strokePaint;
1039     strokePaint.setStyle(SkPaint::kStroke_Style);
1040     strokePaint.setColor(SK_ColorRED);
1041
1042     SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
1043     uint32_t pixel;
1044     canvas.readPixels(info, &pixel, 4, 25, 25);
1045     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
1046
1047     // Test that drawSprite() with a filter nested inside a saveLayer() applies the
1048     // correct offset to the filter matrix.
1049     canvas.clear(0x0);
1050     canvas.readPixels(info, &pixel, 4, 25, 25);
1051     canvas.saveLayer(&bounds1, NULL);
1052     canvas.drawSprite(bitmap, 20, 20, &filterPaint);
1053     canvas.restore();
1054
1055     canvas.readPixels(info, &pixel, 4, 25, 25);
1056     REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
1057 }
1058
1059 DEF_TEST(XfermodeImageFilterCroppedInput, reporter) {
1060     SkBitmap temp;
1061     temp.allocN32Pixels(100, 100);
1062     SkBitmapDevice device(temp);
1063     test_xfermode_cropped_input(&device, reporter);
1064 }
1065
1066 #if SK_SUPPORT_GPU
1067 const SkSurfaceProps gProps = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
1068
1069 DEF_GPUTEST(ImageFilterCropRectGPU, reporter, factory) {
1070     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
1071     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
1072                                                          SkImageInfo::MakeN32Premul(100, 100),
1073                                                          gProps,
1074                                                          0));
1075     test_crop_rects(device, reporter);
1076 }
1077
1078 DEF_GPUTEST(HugeBlurImageFilterGPU, reporter, factory) {
1079     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
1080     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
1081                                                          SkImageInfo::MakeN32Premul(100, 100),
1082                                                          gProps,
1083                                                          0));
1084     test_huge_blur(device, reporter);
1085 }
1086
1087 DEF_GPUTEST(XfermodeImageFilterCroppedInputGPU, reporter, factory) {
1088     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
1089     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
1090                                                          SkImageInfo::MakeN32Premul(1, 1),
1091                                                          gProps,
1092                                                          0));
1093     test_xfermode_cropped_input(device, reporter);
1094 }
1095
1096 DEF_GPUTEST(TestNegativeBlurSigmaGPU, reporter, factory) {
1097     GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
1098     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
1099                                                          SkImageInfo::MakeN32Premul(1, 1),
1100                                                          gProps,
1101                                                          0));
1102     test_negative_blur_sigma(device, reporter);
1103 }
1104 #endif