gm/drawbitmaprect.cpp

   1 /*
   2  * Copyright 2011 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 "sk_tool_utils.h"
  10 #include "SkBlurMask.h"
  11 #include "SkBlurMaskFilter.h"
  12 #include "SkColorPriv.h"
  13 #include "SkGradientShader.h"
  14 #include "SkImage.h"
  15 #include "SkImage_Base.h"
  16 #include "SkMathPriv.h"
  17 #include "SkShader.h"
  18 #include "SkSurface.h"
  19
  20
  21 static SkBitmap make_chessbm(int w, int h) {
  22     SkBitmap bm;
  23     bm.allocN32Pixels(w, h);
  24
  25     for (int y = 0; y < bm.height(); y++) {
  26         uint32_t* p = bm.getAddr32(0, y);
  27         for (int x = 0; x < bm.width(); x++) {
  28             p[x] = ((x + y) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
  29         }
  30     }
  31     return bm;
  32 }
  33
  34 // Creates a bitmap and a matching image.
  35 static sk_sp<SkImage> makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) {
  36     SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
  37
  38     auto surface(origCanvas->makeSurface(info));
  39     if (nullptr == surface) {
  40         // picture canvas will return null, so fall-back to raster
  41         surface = SkSurface::MakeRaster(info);
  42     }
  43
  44     SkCanvas* canvas = surface->getCanvas();
  45
  46     canvas->clear(SK_ColorTRANSPARENT);
  47
  48     SkScalar wScalar = SkIntToScalar(w);
  49     SkScalar hScalar = SkIntToScalar(h);
  50
  51     SkPoint     pt = { wScalar / 2, hScalar / 2 };
  52
  53     SkScalar    radius = 4 * SkMaxScalar(wScalar, hScalar);
  54
  55     SkColor     colors[] = { SK_ColorRED, SK_ColorYELLOW,
  56                              SK_ColorGREEN, SK_ColorMAGENTA,
  57                              SK_ColorBLUE, SK_ColorCYAN,
  58                              SK_ColorRED};
  59
  60     SkScalar    pos[] = {0,
  61                          SK_Scalar1 / 6,
  62                          2 * SK_Scalar1 / 6,
  63                          3 * SK_Scalar1 / 6,
  64                          4 * SK_Scalar1 / 6,
  65                          5 * SK_Scalar1 / 6,
  66                          SK_Scalar1};
  67
  68     SkPaint     paint;
  69     SkRect rect = SkRect::MakeWH(wScalar, hScalar);
  70     SkMatrix mat = SkMatrix::I();
  71     for (int i = 0; i < 4; ++i) {
  72         paint.setShader(SkGradientShader::MakeRadial(
  73                         pt, radius,
  74                         colors, pos,
  75                         SK_ARRAY_COUNT(colors),
  76                         SkShader::kRepeat_TileMode,
  77                         0, &mat));
  78         canvas->drawRect(rect, paint);
  79         rect.inset(wScalar / 8, hScalar / 8);
  80         mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
  81     }
  82
  83     auto image = surface->makeImageSnapshot();
  84
  85     SkBitmap tempBM;
  86
  87     image->asLegacyBitmap(&tempBM, SkImage::kRO_LegacyBitmapMode);
  88
  89     // Let backends know we won't change this, so they don't have to deep copy it defensively.
  90     tempBM.setImmutable();
  91     *resultBM = tempBM;
  92
  93     return image;
  94 }
  95
  96 static void bitmapproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
  97                        const SkRect& dstR, const SkPaint* paint) {
  98     canvas->drawBitmapRect(bm, srcR, dstR, paint);
  99 }
 100
 101 static void bitmapsubsetproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
 102                              const SkRect& dstR, const SkPaint* paint) {
 103     if (!bm.bounds().contains(srcR)) {
 104         bitmapproc(canvas, nullptr, bm, srcR, dstR, paint);
 105         return;
 106     }
 107
 108     SkBitmap subset;
 109     if (bm.extractSubset(&subset, srcR)) {
 110         canvas->drawBitmapRect(subset, dstR, paint);
 111     }
 112 }
 113
 114 static void imageproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect& srcR,
 115                       const SkRect& dstR, const SkPaint* paint) {
 116     canvas->drawImageRect(image, srcR, dstR, paint);
 117 }
 118
 119 static void imagesubsetproc(SkCanvas* canvas, SkImage* image, const SkBitmap& bm,
 120                             const SkIRect& srcR, const SkRect& dstR, const SkPaint* paint) {
 121     if (!image->bounds().contains(srcR)) {
 122         imageproc(canvas, image, bm, srcR, dstR, paint);
 123         return;
 124     }
 125
 126     if (sk_sp<SkImage> subset = image->makeSubset(srcR)) {
 127         canvas->drawImageRect(subset, dstR, paint);
 128     }
 129 }
 130
 131 typedef void DrawRectRectProc(SkCanvas*, SkImage*, const SkBitmap&, const SkIRect&, const SkRect&,
 132                               const SkPaint*);
 133
 134 constexpr int gSize = 1024;
 135 constexpr int gBmpSize = 2048;
 136
 137 class DrawBitmapRectGM : public skiagm::GM {
 138 public:
 139     DrawBitmapRectGM(DrawRectRectProc proc, const char suffix[]) : fProc(proc) {
 140         fName.set("drawbitmaprect");
 141         if (suffix) {
 142             fName.append(suffix);
 143         }
 144     }
 145
 146     DrawRectRectProc*   fProc;
 147     SkBitmap            fLargeBitmap;
 148     sk_sp<SkImage>      fImage;
 149     SkString            fName;
 150
 151 protected:
 152     SkString onShortName() override { return fName; }
 153
 154     SkISize onISize() override { return SkISize::Make(gSize, gSize); }
 155
 156     void setupImage(SkCanvas* canvas) {
 157         fImage = makebm(canvas, &fLargeBitmap, gBmpSize, gBmpSize);
 158     }
 159
 160     void onDraw(SkCanvas* canvas) override {
 161         if (!fImage) {
 162             this->setupImage(canvas);
 163         }
 164
 165         SkRect dstRect = { 0, 0, SkIntToScalar(64), SkIntToScalar(64)};
 166         const int kMaxSrcRectSize = 1 << (SkNextLog2(gBmpSize) + 2);
 167
 168         const int kPadX = 30;
 169         const int kPadY = 40;
 170         SkPaint paint;
 171         paint.setAlpha(0x20);
 172         canvas->drawImageRect(fImage, SkRect::MakeIWH(gSize, gSize), &paint);
 173         canvas->translate(SK_Scalar1 * kPadX / 2,
 174                           SK_Scalar1 * kPadY / 2);
 175         SkPaint blackPaint;
 176         SkScalar titleHeight = SK_Scalar1 * 24;
 177         blackPaint.setColor(SK_ColorBLACK);
 178         blackPaint.setTextSize(titleHeight);
 179         blackPaint.setAntiAlias(true);
 180         sk_tool_utils::set_portable_typeface(&blackPaint);
 181         SkString title;
 182         title.printf("Bitmap size: %d x %d", gBmpSize, gBmpSize);
 183         canvas->drawString(title, 0,
 184                          titleHeight, blackPaint);
 185
 186         canvas->translate(0, SK_Scalar1 * kPadY / 2  + titleHeight);
 187         int rowCount = 0;
 188         canvas->save();
 189         for (int w = 1; w <= kMaxSrcRectSize; w *= 4) {
 190             for (int h = 1; h <= kMaxSrcRectSize; h *= 4) {
 191
 192                 SkIRect srcRect = SkIRect::MakeXYWH((gBmpSize - w) / 2, (gBmpSize - h) / 2, w, h);
 193                 fProc(canvas, fImage.get(), fLargeBitmap, srcRect, dstRect, nullptr);
 194
 195                 SkString label;
 196                 label.appendf("%d x %d", w, h);
 197                 blackPaint.setAntiAlias(true);
 198                 blackPaint.setStyle(SkPaint::kFill_Style);
 199                 blackPaint.setTextSize(SK_Scalar1 * 10);
 200                 SkScalar baseline = dstRect.height() +
 201                                     blackPaint.getTextSize() + SK_Scalar1 * 3;
 202                 canvas->drawString(label,
 203                                     0, baseline,
 204                                     blackPaint);
 205                 blackPaint.setStyle(SkPaint::kStroke_Style);
 206                 blackPaint.setStrokeWidth(SK_Scalar1);
 207                 blackPaint.setAntiAlias(false);
 208                 canvas->drawRect(dstRect, blackPaint);
 209
 210                 canvas->translate(dstRect.width() + SK_Scalar1 * kPadX, 0);
 211                 ++rowCount;
 212                 if ((dstRect.width() + kPadX) * rowCount > gSize) {
 213                     canvas->restore();
 214                     canvas->translate(0, dstRect.height() + SK_Scalar1 * kPadY);
 215                     canvas->save();
 216                     rowCount = 0;
 217                 }
 218             }
 219         }
 220
 221         {
 222             // test the following code path:
 223             // SkGpuDevice::drawPath() -> SkGpuDevice::drawWithMaskFilter()
 224             SkIRect srcRect;
 225             SkPaint paint;
 226             SkBitmap bm;
 227
 228             bm = make_chessbm(5, 5);
 229             paint.setFilterQuality(kLow_SkFilterQuality);
 230
 231             srcRect.setXYWH(1, 1, 3, 3);
 232             paint.setMaskFilter(SkBlurMaskFilter::Make(
 233                 kNormal_SkBlurStyle,
 234                 SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
 235                 SkBlurMaskFilter::kHighQuality_BlurFlag));
 236
 237             sk_sp<SkImage> image(SkImage::MakeFromBitmap(bm));
 238             fProc(canvas, image.get(), bm, srcRect, dstRect, &paint);
 239         }
 240     }
 241
 242 private:
 243     typedef skiagm::GM INHERITED;
 244 };
 245
 246 DEF_GM( return new DrawBitmapRectGM(bitmapproc      , nullptr); )
 247 DEF_GM( return new DrawBitmapRectGM(bitmapsubsetproc, "-subset"); )
 248 DEF_GM( return new DrawBitmapRectGM(imageproc       , "-imagerect"); )
 249 DEF_GM( return new DrawBitmapRectGM(imagesubsetproc , "-imagerect-subset"); )