gm/bleed.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 "gm.h"
   9 #include "SkBlurMask.h"
  10 #include "SkBlurMaskFilter.h"
  11 #include "SkCanvas.h"
  12 #include "SkGradientShader.h"
  13 #include "SkImage.h"
  14 #include "SkTDArray.h"
  15 #include "SkUtils.h"
  16
  17 #if SK_SUPPORT_GPU
  18 #include "GrContext.h"
  19 #include "GrContextOptions.h"
  20 #include "SkGr.h"
  21 #endif
  22
  23 /** Holds either a bitmap or image to be rendered and a rect that indicates what part of the bitmap
  24     or image should be tested by the GM. The area outside of the rect is present to check
  25     for bleed due to filtering/blurring. */
  26 struct TestPixels {
  27     enum Type {
  28         kBitmap,
  29         kImage
  30     };
  31     Type            fType;
  32     SkBitmap        fBitmap;
  33     sk_sp<SkImage>  fImage;
  34     SkIRect         fRect;  // The region of the bitmap/image that should be rendered.
  35 };
  36
  37 /** Creates a bitmap with two one-pixel rings around a checkerboard. The checkerboard is 2x2
  38     logically where each check has as many pixels as is necessary to fill the interior. The rect
  39     to draw is set to the checkerboard portion. */
  40 template<typename PIXEL_TYPE>
  41 bool make_ringed_bitmap(TestPixels* result, int width, int height,
  42                         SkColorType ct, SkAlphaType at,
  43                         PIXEL_TYPE outerRingColor, PIXEL_TYPE innerRingColor,
  44                         PIXEL_TYPE checkColor1, PIXEL_TYPE checkColor2) {
  45     SkASSERT(0 == width % 2 && 0 == height % 2);
  46     SkASSERT(width >= 6 && height >= 6);
  47
  48     result->fType = TestPixels::kBitmap;
  49     SkImageInfo info = SkImageInfo::Make(width, height, ct, at);
  50     size_t rowBytes = SkAlign4(info.minRowBytes());
  51     result->fBitmap.allocPixels(info, rowBytes);
  52
  53     PIXEL_TYPE* scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, 0);
  54     for (int x = 0; x < width; ++x) {
  55         scanline[x] = outerRingColor;
  56     }
  57     scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, 1);
  58     scanline[0] = outerRingColor;
  59     for (int x = 1; x < width - 1; ++x) {
  60         scanline[x] = innerRingColor;
  61     }
  62     scanline[width - 1] = outerRingColor;
  63
  64     for (int y = 2; y < height / 2; ++y) {
  65         scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, y);
  66         scanline[0] = outerRingColor;
  67         scanline[1] = innerRingColor;
  68         for (int x = 2; x < width / 2; ++x) {
  69             scanline[x] = checkColor1;
  70         }
  71         for (int x = width / 2; x < width - 2; ++x) {
  72             scanline[x] = checkColor2;
  73         }
  74         scanline[width - 2] = innerRingColor;
  75         scanline[width - 1] = outerRingColor;
  76     }
  77
  78     for (int y = height / 2; y < height - 2; ++y) {
  79         scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, y);
  80         scanline[0] = outerRingColor;
  81         scanline[1] = innerRingColor;
  82         for (int x = 2; x < width / 2; ++x) {
  83             scanline[x] = checkColor2;
  84         }
  85         for (int x = width / 2; x < width - 2; ++x) {
  86             scanline[x] = checkColor1;
  87         }
  88         scanline[width - 2] = innerRingColor;
  89         scanline[width - 1] = outerRingColor;
  90     }
  91
  92     scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, height - 2);
  93     scanline[0] = outerRingColor;
  94     for (int x = 1; x < width - 1; ++x) {
  95         scanline[x] = innerRingColor;
  96     }
  97     scanline[width - 1] = outerRingColor;
  98
  99     scanline = (PIXEL_TYPE*)result->fBitmap.getAddr(0, height - 1);
 100     for (int x = 0; x < width; ++x) {
 101         scanline[x] = outerRingColor;
 102     }
 103     result->fBitmap.setImmutable();
 104     result->fRect.set(2, 2, width - 2, height - 2);
 105     return true;
 106 }
 107
 108 /** Create a black and white checked bitmap with 2 1-pixel rings around the outside edge.
 109     The inner ring is red and the outer ring is blue. */
 110 static bool make_ringed_color_bitmap(TestPixels* result, int width, int height) {
 111     const SkPMColor kBlue  = SkPreMultiplyColor(SK_ColorBLUE);
 112     const SkPMColor kRed   = SkPreMultiplyColor(SK_ColorRED);
 113     const SkPMColor kBlack = SkPreMultiplyColor(SK_ColorBLACK);
 114     const SkPMColor kWhite = SkPreMultiplyColor(SK_ColorWHITE);
 115     return make_ringed_bitmap<SkPMColor>(result, width, height, kN32_SkColorType,
 116                                          kPremul_SkAlphaType, kBlue, kRed, kBlack, kWhite);
 117 }
 118
 119 /** Makes a alpha bitmap with 1 wide rect/ring of 0s, an inset of 1s, and the interior is a 2x2
 120     checker board of 3/4 and 1/2. The inner checkers are large enough to fill the interior with
 121     the 2x2 checker grid. */
 122 static bool make_ringed_alpha_bitmap(TestPixels* result, int width, int height) {
 123     constexpr uint8_t kZero = 0x00;
 124     constexpr uint8_t kHalf = 0x80;
 125     constexpr uint8_t k3Q   = 0xC0;
 126     constexpr uint8_t kOne  = 0xFF;
 127     return make_ringed_bitmap<uint8_t>(result, width, height, kAlpha_8_SkColorType,
 128                                        kPremul_SkAlphaType, kZero, kOne, k3Q, kHalf);
 129 }
 130
 131 /** Helper to reuse above functions to produce images rather than bmps */
 132 static void bmp_to_image(TestPixels* result) {
 133     SkASSERT(TestPixels::kBitmap == result->fType);
 134     result->fImage = SkImage::MakeFromBitmap(result->fBitmap);
 135     SkASSERT(result->fImage);
 136     result->fType = TestPixels::kImage;
 137     result->fBitmap.reset();
 138 }
 139
 140 /** Color image case. */
 141 bool make_ringed_color_image(TestPixels* result, int width, int height) {
 142     if (make_ringed_color_bitmap(result, width, height)) {
 143         bmp_to_image(result);
 144         return true;
 145     }
 146     return false;
 147 }
 148
 149 /** Alpha image case. */
 150 bool make_ringed_alpha_image(TestPixels* result, int width, int height) {
 151     if (make_ringed_alpha_bitmap(result, width, height)) {
 152         bmp_to_image(result);
 153         return true;
 154     }
 155     return false;
 156 }
 157
 158 static sk_sp<SkShader> make_shader() {
 159     constexpr SkPoint pts[] = { {0, 0}, {20, 20} };
 160     constexpr SkColor colors[] = { SK_ColorGREEN, SK_ColorYELLOW };
 161     return SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kMirror_TileMode);
 162 }
 163
 164 static sk_sp<SkShader> make_null_shader() { return nullptr; }
 165
 166 enum BleedTest {
 167     kUseBitmap_BleedTest,
 168     kUseImage_BleedTest,
 169     kUseAlphaBitmap_BleedTest,
 170     kUseAlphaImage_BleedTest,
 171     kUseAlphaBitmapShader_BleedTest,
 172     kUseAlphaImageShader_BleedTest,
 173 };
 174
 175 const struct {
 176     const char* fName;
 177     bool (*fPixelMaker)(TestPixels* result, int width, int height);
 178     sk_sp<SkShader> (*fShaderMaker)();
 179 } gBleedRec[] = {
 180     { "bleed",                          make_ringed_color_bitmap,                   make_null_shader },
 181     { "bleed_image",                    make_ringed_color_image,                    make_null_shader },
 182     { "bleed_alpha_bmp",                make_ringed_alpha_bitmap,                   make_null_shader },
 183     { "bleed_alpha_image",              make_ringed_alpha_image,                    make_null_shader },
 184     { "bleed_alpha_bmp_shader",         make_ringed_alpha_bitmap,                   make_shader      },
 185     { "bleed_alpha_image_shader",       make_ringed_alpha_image,                    make_shader      },
 186 };
 187
 188 /** This GM exercises the behavior of the drawBitmapRect & drawImageRect calls. Specifically their
 189     handling of :
 190      - SrcRectConstraint(bleed vs.no - bleed)
 191      - handling of the sub - region feature(area - of - interest) of drawBitmap*
 192      - handling of 8888 vs. A8 (including presence of a shader in the A8 case).
 193     In particular, we should never see the padding outside of an SkBitmap's sub - region (green for
 194     8888, 1/4 for alpha). In some instances we can see the two outer rings outside of the area o
 195     interest (i.e., the inner four checks) due to AA or filtering if allowed by the
 196     SrcRectConstraint.
 197 */
 198 class BleedGM : public skiagm::GM {
 199 public:
 200     BleedGM(BleedTest bt) : fBT(bt){}
 201
 202 protected:
 203
 204     SkString onShortName() override {
 205         return SkString(gBleedRec[fBT].fName);
 206     }
 207
 208     SkISize onISize() override {
 209         return SkISize::Make(1200, 1080);
 210     }
 211
 212     void drawPixels(SkCanvas* canvas, const TestPixels& pixels, const SkRect& src,
 213                     const SkRect& dst, const SkPaint* paint,
 214                     SkCanvas::SrcRectConstraint constraint) {
 215         if (TestPixels::kBitmap == pixels.fType) {
 216             canvas->drawBitmapRect(pixels.fBitmap, src, dst, paint, constraint);
 217         } else {
 218             canvas->drawImageRect(pixels.fImage.get(), src, dst, paint, constraint);
 219         }
 220     }
 221
 222     // Draw the area of interest of the small image
 223     void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa,
 224                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
 225
 226         SkRect src = SkRect::Make(fSmallTestPixels.fRect);
 227         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
 228                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 229
 230         SkPaint paint;
 231         paint.setFilterQuality(filter);
 232         paint.setShader(fShader);
 233         paint.setColor(SK_ColorBLUE);
 234         paint.setAntiAlias(aa);
 235
 236         this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint);
 237     }
 238
 239     // Draw the area of interest of the large image
 240     void drawCase2(SkCanvas* canvas, int transX, int transY, bool aa,
 241                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
 242         SkRect src = SkRect::Make(fBigTestPixels.fRect);
 243         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
 244                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 245
 246         SkPaint paint;
 247         paint.setFilterQuality(filter);
 248         paint.setShader(fShader);
 249         paint.setColor(SK_ColorBLUE);
 250         paint.setAntiAlias(aa);
 251
 252         this->drawPixels(canvas, fBigTestPixels, src, dst, &paint, constraint);
 253     }
 254
 255     // Draw upper-left 1/4 of the area of interest of the large image
 256     void drawCase3(SkCanvas* canvas, int transX, int transY, bool aa,
 257                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
 258         SkRect src = SkRect::MakeXYWH(SkIntToScalar(fBigTestPixels.fRect.fLeft),
 259                                       SkIntToScalar(fBigTestPixels.fRect.fTop),
 260                                       fBigTestPixels.fRect.width()/2.f,
 261                                       fBigTestPixels.fRect.height()/2.f);
 262         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
 263                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 264
 265         SkPaint paint;
 266         paint.setFilterQuality(filter);
 267         paint.setShader(fShader);
 268         paint.setColor(SK_ColorBLUE);
 269         paint.setAntiAlias(aa);
 270
 271         this->drawPixels(canvas, fBigTestPixels, src, dst, &paint, constraint);
 272     }
 273
 274     // Draw the area of interest of the small image with a normal blur
 275     void drawCase4(SkCanvas* canvas, int transX, int transY, bool aa,
 276                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
 277         SkRect src = SkRect::Make(fSmallTestPixels.fRect);
 278         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
 279                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 280
 281         SkPaint paint;
 282         paint.setFilterQuality(filter);
 283         paint.setMaskFilter(SkBlurMaskFilter::Make(kNormal_SkBlurStyle,
 284                                                    SkBlurMask::ConvertRadiusToSigma(3)));
 285         paint.setShader(fShader);
 286         paint.setColor(SK_ColorBLUE);
 287         paint.setAntiAlias(aa);
 288
 289         this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint);
 290     }
 291
 292     // Draw the area of interest of the small image with a outer blur
 293     void drawCase5(SkCanvas* canvas, int transX, int transY, bool aa,
 294                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
 295         SkRect src = SkRect::Make(fSmallTestPixels.fRect);
 296         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
 297                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 298
 299         SkPaint paint;
 300         paint.setFilterQuality(filter);
 301         paint.setMaskFilter(SkBlurMaskFilter::Make(kOuter_SkBlurStyle,
 302                                                    SkBlurMask::ConvertRadiusToSigma(7)));
 303         paint.setShader(fShader);
 304         paint.setColor(SK_ColorBLUE);
 305         paint.setAntiAlias(aa);
 306
 307         this->drawPixels(canvas, fSmallTestPixels, src, dst, &paint, constraint);
 308     }
 309
 310     void onOnceBeforeDraw() override {
 311         SkAssertResult(gBleedRec[fBT].fPixelMaker(&fSmallTestPixels, kSmallSize, kSmallSize));
 312         SkAssertResult(gBleedRec[fBT].fPixelMaker(&fBigTestPixels, 2 * kMaxTileSize,
 313                                                  2 * kMaxTileSize));
 314     }
 315
 316     void onDraw(SkCanvas* canvas) override {
 317         fShader = gBleedRec[fBT].fShaderMaker();
 318
 319         canvas->clear(SK_ColorGRAY);
 320         SkTDArray<SkMatrix> matrices;
 321         // Draw with identity
 322         *matrices.append() = SkMatrix::I();
 323
 324         // Draw with rotation and scale down in x, up in y.
 325         SkMatrix m;
 326         constexpr SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
 327         m.setTranslate(0, kBottom);
 328         m.preRotate(15.f, 0, kBottom + kBlockSpacing);
 329         m.preScale(0.71f, 1.22f);
 330         *matrices.append() = m;
 331
 332         // Align the next set with the middle of the previous in y, translated to the right in x.
 333         SkPoint corners[] = {{0, 0}, { 0, kBottom }, { kWidth, kBottom }, {kWidth, 0} };
 334         matrices[matrices.count()-1].mapPoints(corners, 4);
 335         SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4;
 336         SkScalar x = SkTMax(SkTMax(corners[0].fX, corners[1].fX),
 337                             SkTMax(corners[2].fX, corners[3].fX));
 338         m.setTranslate(x, y);
 339         m.preScale(0.2f, 0.2f);
 340         *matrices.append() = m;
 341
 342         SkScalar maxX = 0;
 343         for (int antiAlias = 0; antiAlias < 2; ++antiAlias) {
 344             canvas->save();
 345             canvas->translate(maxX, 0);
 346             for (int m = 0; m < matrices.count(); ++m) {
 347                 canvas->save();
 348                 canvas->concat(matrices[m]);
 349                 bool aa = SkToBool(antiAlias);
 350
 351                 // First draw a column with no bleeding and no filtering
 352                 this->drawCase1(canvas, kCol0X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
 353                 this->drawCase2(canvas, kCol0X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
 354                 this->drawCase3(canvas, kCol0X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
 355                 this->drawCase4(canvas, kCol0X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
 356                 this->drawCase5(canvas, kCol0X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kNone_SkFilterQuality);
 357
 358                 // Then draw a column with no bleeding and low filtering
 359                 this->drawCase1(canvas, kCol1X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
 360                 this->drawCase2(canvas, kCol1X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
 361                 this->drawCase3(canvas, kCol1X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
 362                 this->drawCase4(canvas, kCol1X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
 363                 this->drawCase5(canvas, kCol1X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kLow_SkFilterQuality);
 364
 365                 // Then draw a column with no bleeding and high filtering
 366                 this->drawCase1(canvas, kCol2X, kRow0Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
 367                 this->drawCase2(canvas, kCol2X, kRow1Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
 368                 this->drawCase3(canvas, kCol2X, kRow2Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
 369                 this->drawCase4(canvas, kCol2X, kRow3Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
 370                 this->drawCase5(canvas, kCol2X, kRow4Y, aa, SkCanvas::kStrict_SrcRectConstraint, kHigh_SkFilterQuality);
 371
 372                 // Then draw a column with bleeding and no filtering (bleed should have no effect w/out blur)
 373                 this->drawCase1(canvas, kCol3X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
 374                 this->drawCase2(canvas, kCol3X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
 375                 this->drawCase3(canvas, kCol3X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
 376                 this->drawCase4(canvas, kCol3X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
 377                 this->drawCase5(canvas, kCol3X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kNone_SkFilterQuality);
 378
 379                 // Then draw a column with bleeding and low filtering
 380                 this->drawCase1(canvas, kCol4X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
 381                 this->drawCase2(canvas, kCol4X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
 382                 this->drawCase3(canvas, kCol4X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
 383                 this->drawCase4(canvas, kCol4X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
 384                 this->drawCase5(canvas, kCol4X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kLow_SkFilterQuality);
 385
 386                 // Finally draw a column with bleeding and high filtering
 387                 this->drawCase1(canvas, kCol5X, kRow0Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
 388                 this->drawCase2(canvas, kCol5X, kRow1Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
 389                 this->drawCase3(canvas, kCol5X, kRow2Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
 390                 this->drawCase4(canvas, kCol5X, kRow3Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
 391                 this->drawCase5(canvas, kCol5X, kRow4Y, aa, SkCanvas::kFast_SrcRectConstraint, kHigh_SkFilterQuality);
 392
 393                 SkPoint corners[] = { { 0, 0 },{ 0, kBottom },{ kWidth, kBottom },{ kWidth, 0 } };
 394                 matrices[m].mapPoints(corners, 4);
 395                 SkScalar x = kBlockSize + SkTMax(SkTMax(corners[0].fX, corners[1].fX),
 396                                                  SkTMax(corners[2].fX, corners[3].fX));
 397                 maxX = SkTMax(maxX, x);
 398                 canvas->restore();
 399             }
 400             canvas->restore();
 401         }
 402     }
 403
 404 #if SK_SUPPORT_GPU
 405     void modifyGrContextOptions(GrContextOptions* options) override {
 406         options->fMaxTileSizeOverride = kMaxTileSize;
 407     }
 408 #endif
 409
 410 private:
 411     static constexpr int kBlockSize = 70;
 412     static constexpr int kBlockSpacing = 12;
 413
 414     static constexpr int kCol0X = kBlockSpacing;
 415     static constexpr int kCol1X = 2*kBlockSpacing + kBlockSize;
 416     static constexpr int kCol2X = 3*kBlockSpacing + 2*kBlockSize;
 417     static constexpr int kCol3X = 4*kBlockSpacing + 3*kBlockSize;
 418     static constexpr int kCol4X = 5*kBlockSpacing + 4*kBlockSize;
 419     static constexpr int kCol5X = 6*kBlockSpacing + 5*kBlockSize;
 420     static constexpr int kWidth = 7*kBlockSpacing + 6*kBlockSize;
 421
 422     static constexpr int kRow0Y = kBlockSpacing;
 423     static constexpr int kRow1Y = 2*kBlockSpacing + kBlockSize;
 424     static constexpr int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
 425     static constexpr int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
 426     static constexpr int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
 427
 428     static constexpr int kSmallSize = 6;
 429     static constexpr int kMaxTileSize = 32;
 430
 431     TestPixels      fBigTestPixels;
 432     TestPixels      fSmallTestPixels;
 433
 434     sk_sp<SkShader> fShader;
 435
 436     const BleedTest fBT;
 437
 438     typedef GM INHERITED;
 439 };
 440
 441
 442 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
 443 DEF_GM( return new BleedGM(kUseImage_BleedTest); )
 444 DEF_GM( return new BleedGM(kUseAlphaBitmap_BleedTest); )
 445 DEF_GM( return new BleedGM(kUseAlphaImage_BleedTest); )
 446 DEF_GM( return new BleedGM(kUseAlphaBitmapShader_BleedTest); )
 447 DEF_GM( return new BleedGM(kUseAlphaImageShader_BleedTest); )
 448
 449 ///////////////////////////////////////////////////////////////////////////////////////////////////
 450 #include "SkSurface.h"
 451
 452 sk_sp<SkSurface> make_surface(SkCanvas* canvas, const SkImageInfo& info) {
 453     auto surface = canvas->makeSurface(info);
 454     if (!surface) {
 455         surface = SkSurface::MakeRaster(info);
 456     }
 457     return surface;
 458 }
 459
 460 // Construct an image and return the inner "src" rect. Build the image such that the interior is
 461 // blue, with a margin of blue (2px) but then an outer margin of red.
 462 //
 463 // Show that kFast_SrcRectConstraint sees even the red margin (due to mipmapping) when the image
 464 // is scaled down far enough.
 465 //
 466 static sk_sp<SkImage> make_image(SkCanvas* canvas, SkRect* srcR) {
 467     // Intentially making the size a power of 2 to avoid the noise from how different GPUs will
 468     // produce different mipmap filtering when we have an odd sized texture.
 469     const int N = 10 + 2 + 8 + 2 + 10;
 470     SkImageInfo info = SkImageInfo::MakeN32Premul(N, N);
 471     auto surface = make_surface(canvas, info);
 472     SkCanvas* c = surface->getCanvas();
 473     SkRect r = SkRect::MakeIWH(info.width(), info.height());
 474     SkPaint paint;
 475
 476     paint.setColor(SK_ColorRED);
 477     c->drawRect(r, paint);
 478     r.inset(10, 10);
 479     paint.setColor(SK_ColorBLUE);
 480     c->drawRect(r, paint);
 481
 482     *srcR = r.makeInset(2, 2);
 483     return surface->makeImageSnapshot();
 484 }
 485
 486 DEF_SIMPLE_GM(bleed_downscale, canvas, 360, 240) {
 487     SkRect src;
 488     sk_sp<SkImage> img = make_image(canvas, &src);
 489     SkPaint paint;
 490
 491     canvas->translate(10, 10);
 492
 493     const SkCanvas::SrcRectConstraint constraints[] = {
 494         SkCanvas::kStrict_SrcRectConstraint, SkCanvas::kFast_SrcRectConstraint
 495     };
 496     const SkFilterQuality qualities[] = {
 497         kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality
 498     };
 499     for (auto constraint : constraints) {
 500         canvas->save();
 501         for (auto quality : qualities) {
 502             paint.setFilterQuality(quality);
 503             auto surf = make_surface(canvas, SkImageInfo::MakeN32Premul(1, 1));
 504             surf->getCanvas()->drawImageRect(img, src, SkRect::MakeWH(1, 1), &paint, constraint);
 505             // now blow up the 1 pixel result
 506             canvas->drawImageRect(surf->makeImageSnapshot(), SkRect::MakeWH(100, 100), nullptr);
 507             canvas->translate(120, 0);
 508         }
 509         canvas->restore();
 510         canvas->translate(0, 120);
 511     }
 512 }
 513
 514