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/gm.h"
9 #include "include/core/SkBitmap.h"
10 #include "include/core/SkBlurTypes.h"
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkFilterQuality.h"
14 #include "include/core/SkImage.h"
15 #include "include/core/SkImageInfo.h"
16 #include "include/core/SkMaskFilter.h"
17 #include "include/core/SkMatrix.h"
18 #include "include/core/SkPaint.h"
19 #include "include/core/SkPoint.h"
20 #include "include/core/SkRect.h"
21 #include "include/core/SkRefCnt.h"
22 #include "include/core/SkScalar.h"
23 #include "include/core/SkShader.h"
24 #include "include/core/SkSize.h"
25 #include "include/core/SkString.h"
26 #include "include/core/SkSurface.h"
27 #include "include/core/SkTileMode.h"
28 #include "include/core/SkTypes.h"
29 #include "include/gpu/GrContextOptions.h"
30 #include "include/private/SkTDArray.h"
31 #include "src/core/SkBlurMask.h"
32 #include "tools/ToolUtils.h"
33
34 /** Creates an image with two one-pixel wide borders around a checkerboard. The checkerboard is 2x2
35 checks where each check has as many pixels as is necessary to fill the interior. It returns
36 the image and a src rect that bounds the checkerboard portion. */
make_ringed_image(int width,int height)37 std::tuple<sk_sp<SkImage>, SkIRect> make_ringed_image(int width, int height) {
38
39 // These are kRGBA_8888_SkColorType values.
40 static constexpr uint32_t kOuterRingColor = 0xFFFF0000,
41 kInnerRingColor = 0xFF0000FF,
42 kCheckColor1 = 0xFF000000,
43 kCheckColor2 = 0xFFFFFFFF;
44
45 SkASSERT(0 == width % 2 && 0 == height % 2);
46 SkASSERT(width >= 6 && height >= 6);
47
48 SkImageInfo info = SkImageInfo::Make(width, height, kRGBA_8888_SkColorType,
49 kPremul_SkAlphaType);
50 size_t rowBytes = SkAlign4(info.minRowBytes());
51 SkBitmap bitmap;
52 bitmap.allocPixels(info, rowBytes);
53
54 uint32_t* scanline = bitmap.getAddr32(0, 0);
55 for (int x = 0; x < width; ++x) {
56 scanline[x] = kOuterRingColor;
57 }
58 scanline = bitmap.getAddr32(0, 1);
59 scanline[0] = kOuterRingColor;
60 for (int x = 1; x < width - 1; ++x) {
61 scanline[x] = kInnerRingColor;
62 }
63 scanline[width - 1] = kOuterRingColor;
64
65 for (int y = 2; y < height / 2; ++y) {
66 scanline = bitmap.getAddr32(0, y);
67 scanline[0] = kOuterRingColor;
68 scanline[1] = kInnerRingColor;
69 for (int x = 2; x < width / 2; ++x) {
70 scanline[x] = kCheckColor1;
71 }
72 for (int x = width / 2; x < width - 2; ++x) {
73 scanline[x] = kCheckColor2;
74 }
75 scanline[width - 2] = kInnerRingColor;
76 scanline[width - 1] = kOuterRingColor;
77 }
78
79 for (int y = height / 2; y < height - 2; ++y) {
80 scanline = bitmap.getAddr32(0, y);
81 scanline[0] = kOuterRingColor;
82 scanline[1] = kInnerRingColor;
83 for (int x = 2; x < width / 2; ++x) {
84 scanline[x] = kCheckColor2;
85 }
86 for (int x = width / 2; x < width - 2; ++x) {
87 scanline[x] = kCheckColor1;
88 }
89 scanline[width - 2] = kInnerRingColor;
90 scanline[width - 1] = kOuterRingColor;
91 }
92
93 scanline = bitmap.getAddr32(0, height - 2);
94 scanline[0] = kOuterRingColor;
95 for (int x = 1; x < width - 1; ++x) {
96 scanline[x] = kInnerRingColor;
97 }
98 scanline[width - 1] = kOuterRingColor;
99
100 scanline = bitmap.getAddr32(0, height - 1);
101 for (int x = 0; x < width; ++x) {
102 scanline[x] = kOuterRingColor;
103 }
104 bitmap.setImmutable();
105 return {SkImage::MakeFromBitmap(bitmap), {2, 2, width - 2, height - 2}};
106 }
107
108 /**
109 * These GMs exercise the behavior of the drawImageRect and its SrcRectConstraint parameter. They
110 * tests various matrices, filter qualities, and interaction with mask filters. They also exercise
111 * the tiling image draws of SkGpuDevice by overriding the maximum texture size of the GrContext.
112 */
113 class SrcRectConstraintGM : public skiagm::GM {
114 public:
SrcRectConstraintGM(const char * shortName,SkCanvas::SrcRectConstraint constraint,bool batch)115 SrcRectConstraintGM(const char* shortName, SkCanvas::SrcRectConstraint constraint, bool batch)
116 : fShortName(shortName)
117 , fConstraint(constraint)
118 , fBatch(batch) {}
119
120 protected:
onShortName()121 SkString onShortName() override { return fShortName; }
onISize()122 SkISize onISize() override { return SkISize::Make(800, 1000); }
123
drawImage(SkCanvas * canvas,sk_sp<SkImage> image,SkIRect srcRect,SkRect dstRect,SkPaint * paint)124 void drawImage(SkCanvas* canvas, sk_sp<SkImage> image,
125 SkIRect srcRect, SkRect dstRect, SkPaint* paint) {
126 if (fBatch) {
127 SkCanvas::ImageSetEntry imageSetEntry[1];
128 imageSetEntry[0].fImage = image;
129 imageSetEntry[0].fSrcRect = SkRect::Make(srcRect);
130 imageSetEntry[0].fDstRect = dstRect;
131 imageSetEntry[0].fAAFlags = paint->isAntiAlias() ? SkCanvas::kAll_QuadAAFlags
132 : SkCanvas::kNone_QuadAAFlags;
133 canvas->experimental_DrawEdgeAAImageSet(imageSetEntry, SK_ARRAY_COUNT(imageSetEntry),
134 /*dstClips=*/nullptr,
135 /*preViewMatrices=*/nullptr,
136 paint, fConstraint);
137 } else {
138 canvas->drawImageRect(image.get(), srcRect, dstRect, paint, fConstraint);
139 }
140 }
141
142 // Draw the area of interest of the small image
drawCase1(SkCanvas * canvas,int transX,int transY,bool aa,SkFilterQuality filter)143 void drawCase1(SkCanvas* canvas, int transX, int transY, bool aa, SkFilterQuality filter) {
144 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
145 SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
146
147 SkPaint paint;
148 paint.setFilterQuality(filter);
149 paint.setColor(SK_ColorBLUE);
150 paint.setAntiAlias(aa);
151
152 drawImage(canvas, fSmallImage, fSmallSrcRect, dst, &paint);
153 }
154
155 // Draw the area of interest of the large image
drawCase2(SkCanvas * canvas,int transX,int transY,bool aa,SkFilterQuality filter)156 void drawCase2(SkCanvas* canvas, int transX, int transY, bool aa, SkFilterQuality filter) {
157 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
158 SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
159
160 SkPaint paint;
161 paint.setFilterQuality(filter);
162 paint.setColor(SK_ColorBLUE);
163 paint.setAntiAlias(aa);
164
165 drawImage(canvas, fBigImage, fBigSrcRect, dst, &paint);
166 }
167
168 // Draw upper-left 1/4 of the area of interest of the large image
drawCase3(SkCanvas * canvas,int transX,int transY,bool aa,SkFilterQuality filter)169 void drawCase3(SkCanvas* canvas, int transX, int transY, bool aa, SkFilterQuality filter) {
170 SkIRect src = SkIRect::MakeXYWH(fBigSrcRect.fLeft,
171 fBigSrcRect.fTop,
172 fBigSrcRect.width()/2,
173 fBigSrcRect.height()/2);
174 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
175 SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
176
177 SkPaint paint;
178 paint.setFilterQuality(filter);
179 paint.setColor(SK_ColorBLUE);
180 paint.setAntiAlias(aa);
181
182 drawImage(canvas, fBigImage, src, dst, &paint);
183 }
184
185 // Draw the area of interest of the small image with a normal blur
drawCase4(SkCanvas * canvas,int transX,int transY,bool aa,SkFilterQuality filter)186 void drawCase4(SkCanvas* canvas, int transX, int transY, bool aa, SkFilterQuality filter) {
187 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
188 SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
189
190 SkPaint paint;
191 paint.setFilterQuality(filter);
192 paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle,
193 SkBlurMask::ConvertRadiusToSigma(3)));
194 paint.setColor(SK_ColorBLUE);
195 paint.setAntiAlias(aa);
196
197 drawImage(canvas, fSmallImage, fSmallSrcRect, dst, &paint);
198 }
199
200 // Draw the area of interest of the small image with a outer blur
drawCase5(SkCanvas * canvas,int transX,int transY,bool aa,SkFilterQuality filter)201 void drawCase5(SkCanvas* canvas, int transX, int transY, bool aa, SkFilterQuality filter) {
202 SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
203 SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
204
205 SkPaint paint;
206 paint.setFilterQuality(filter);
207 paint.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle,
208 SkBlurMask::ConvertRadiusToSigma(7)));
209 paint.setColor(SK_ColorBLUE);
210 paint.setAntiAlias(aa);
211
212 drawImage(canvas, fSmallImage, fSmallSrcRect, dst, &paint);
213 }
214
onOnceBeforeDraw()215 void onOnceBeforeDraw() override {
216 std::tie(fBigImage, fBigSrcRect) = make_ringed_image(2*kMaxTileSize, 2*kMaxTileSize);
217 std::tie(fSmallImage, fSmallSrcRect) = make_ringed_image(kSmallSize, kSmallSize);
218 }
219
onDraw(SkCanvas * canvas)220 void onDraw(SkCanvas* canvas) override {
221 canvas->clear(SK_ColorGRAY);
222 std::vector<SkMatrix> matrices;
223 // Draw with identity
224 matrices.push_back(SkMatrix::I());
225
226 // Draw with rotation and scale down in x, up in y.
227 SkMatrix m;
228 constexpr SkScalar kBottom = SkIntToScalar(kRow4Y + kBlockSize + kBlockSpacing);
229 m.setTranslate(0, kBottom);
230 m.preRotate(15.f, 0, kBottom + kBlockSpacing);
231 m.preScale(0.71f, 1.22f);
232 matrices.push_back(m);
233
234 // Align the next set with the middle of the previous in y, translated to the right in x.
235 SkPoint corners[] = {{0, 0}, {0, kBottom}, {kWidth, kBottom}, {kWidth, 0}};
236 matrices.back().mapPoints(corners, 4);
237 SkScalar y = (corners[0].fY + corners[1].fY + corners[2].fY + corners[3].fY) / 4;
238 SkScalar x = std::max({corners[0].fX, corners[1].fX, corners[2].fX, corners[3].fX});
239 m.setTranslate(x, y);
240 m.preScale(0.2f, 0.2f);
241 matrices.push_back(m);
242
243 SkScalar maxX = 0;
244 for (bool antiAlias : {false, true}) {
245 canvas->save();
246 canvas->translate(maxX, 0);
247 for (const SkMatrix& matrix : matrices) {
248 canvas->save();
249 canvas->concat(matrix);
250
251 // First draw a column with no filtering
252 this->drawCase1(canvas, kCol0X, kRow0Y, antiAlias, kNone_SkFilterQuality);
253 this->drawCase2(canvas, kCol0X, kRow1Y, antiAlias, kNone_SkFilterQuality);
254 this->drawCase3(canvas, kCol0X, kRow2Y, antiAlias, kNone_SkFilterQuality);
255 this->drawCase4(canvas, kCol0X, kRow3Y, antiAlias, kNone_SkFilterQuality);
256 this->drawCase5(canvas, kCol0X, kRow4Y, antiAlias, kNone_SkFilterQuality);
257
258 // Then draw a column with low filtering
259 this->drawCase1(canvas, kCol1X, kRow0Y, antiAlias, kLow_SkFilterQuality);
260 this->drawCase2(canvas, kCol1X, kRow1Y, antiAlias, kLow_SkFilterQuality);
261 this->drawCase3(canvas, kCol1X, kRow2Y, antiAlias, kLow_SkFilterQuality);
262 this->drawCase4(canvas, kCol1X, kRow3Y, antiAlias, kLow_SkFilterQuality);
263 this->drawCase5(canvas, kCol1X, kRow4Y, antiAlias, kLow_SkFilterQuality);
264
265 // Then draw a column with high filtering. Skip it if in kStrict mode and MIP
266 // mapping will be used. On GPU we allow bleeding at non-base levels because
267 // building a new MIP chain for the subset is expensive.
268 SkScalar scales[2];
269 SkAssertResult(matrix.getMinMaxScales(scales));
270 if (fConstraint != SkCanvas::kStrict_SrcRectConstraint || scales[0] >= 1.f) {
271 this->drawCase1(canvas, kCol2X, kRow0Y, antiAlias, kHigh_SkFilterQuality);
272 this->drawCase2(canvas, kCol2X, kRow1Y, antiAlias, kHigh_SkFilterQuality);
273 this->drawCase3(canvas, kCol2X, kRow2Y, antiAlias, kHigh_SkFilterQuality);
274 this->drawCase4(canvas, kCol2X, kRow3Y, antiAlias, kHigh_SkFilterQuality);
275 this->drawCase5(canvas, kCol2X, kRow4Y, antiAlias, kHigh_SkFilterQuality);
276 }
277
278 SkPoint innerCorners[] = {{0, 0}, {0, kBottom}, {kWidth, kBottom}, {kWidth, 0}};
279 matrix.mapPoints(innerCorners, 4);
280 SkScalar x = kBlockSize + std::max({innerCorners[0].fX, innerCorners[1].fX,
281 innerCorners[2].fX, innerCorners[3].fX});
282 maxX = std::max(maxX, x);
283 canvas->restore();
284 }
285 canvas->restore();
286 }
287 }
288
modifyGrContextOptions(GrContextOptions * options)289 void modifyGrContextOptions(GrContextOptions* options) override {
290 options->fMaxTileSizeOverride = kMaxTileSize;
291 }
292
293 private:
294 static constexpr int kBlockSize = 70;
295 static constexpr int kBlockSpacing = 12;
296
297 static constexpr int kCol0X = kBlockSpacing;
298 static constexpr int kCol1X = 2*kBlockSpacing + kBlockSize;
299 static constexpr int kCol2X = 3*kBlockSpacing + 2*kBlockSize;
300 static constexpr int kWidth = 4*kBlockSpacing + 3*kBlockSize;
301
302 static constexpr int kRow0Y = kBlockSpacing;
303 static constexpr int kRow1Y = 2*kBlockSpacing + kBlockSize;
304 static constexpr int kRow2Y = 3*kBlockSpacing + 2*kBlockSize;
305 static constexpr int kRow3Y = 4*kBlockSpacing + 3*kBlockSize;
306 static constexpr int kRow4Y = 5*kBlockSpacing + 4*kBlockSize;
307
308 static constexpr int kSmallSize = 6;
309 static constexpr int kMaxTileSize = 32;
310
311 SkString fShortName;
312 sk_sp<SkImage> fBigImage;
313 sk_sp<SkImage> fSmallImage;
314 SkIRect fBigSrcRect;
315 SkIRect fSmallSrcRect;
316 SkCanvas::SrcRectConstraint fConstraint;
317 bool fBatch = false;
318 using INHERITED = GM;
319 };
320
321 DEF_GM(return new SrcRectConstraintGM("strict_constraint_no_red_allowed",
322 SkCanvas::kStrict_SrcRectConstraint,
323 /*batch=*/false););
324 DEF_GM(return new SrcRectConstraintGM("strict_constraint_batch_no_red_allowed",
325 SkCanvas::kStrict_SrcRectConstraint,
326 /*batch=*/true););
327 DEF_GM(return new SrcRectConstraintGM("fast_constraint_red_is_allowed",
328 SkCanvas::kFast_SrcRectConstraint,
329 /*batch=*/false););
330
331 ///////////////////////////////////////////////////////////////////////////////////////////////////
332
333 // Construct an image and return the inner "src" rect. Build the image such that the interior is
334 // blue, with a margin of blue (2px) but then an outer margin of red.
335 //
336 // Show that kFast_SrcRectConstraint sees even the red margin (due to mipmapping) when the image
337 // is scaled down far enough.
338 //
make_image(SkCanvas * canvas,SkRect * srcR)339 static sk_sp<SkImage> make_image(SkCanvas* canvas, SkRect* srcR) {
340 // Intentially making the size a power of 2 to avoid the noise from how different GPUs will
341 // produce different mipmap filtering when we have an odd sized texture.
342 const int N = 10 + 2 + 8 + 2 + 10;
343 SkImageInfo info = SkImageInfo::MakeN32Premul(N, N);
344 auto surface = ToolUtils::makeSurface(canvas, info);
345 SkCanvas* c = surface->getCanvas();
346 SkRect r = SkRect::MakeIWH(info.width(), info.height());
347 SkPaint paint;
348
349 paint.setColor(SK_ColorRED);
350 c->drawRect(r, paint);
351 r.inset(10, 10);
352 paint.setColor(SK_ColorBLUE);
353 c->drawRect(r, paint);
354
355 *srcR = r.makeInset(2, 2);
356 return surface->makeImageSnapshot();
357 }
358
359 DEF_SIMPLE_GM(bleed_downscale, canvas, 360, 240) {
360 SkRect src;
361 sk_sp<SkImage> img = make_image(canvas, &src);
362 SkPaint paint;
363
364 canvas->translate(10, 10);
365
366 const SkCanvas::SrcRectConstraint constraints[] = {
367 SkCanvas::kStrict_SrcRectConstraint, SkCanvas::kFast_SrcRectConstraint
368 };
369 const SkFilterQuality qualities[] = {
370 kNone_SkFilterQuality, kLow_SkFilterQuality, kMedium_SkFilterQuality
371 };
372 for (auto constraint : constraints) {
373 canvas->save();
374 for (auto quality : qualities) {
375 paint.setFilterQuality(quality);
376 auto surf = ToolUtils::makeSurface(canvas, SkImageInfo::MakeN32Premul(1, 1));
377 surf->getCanvas()->drawImageRect(img, src, SkRect::MakeWH(1, 1), &paint, constraint);
378 // now blow up the 1 pixel result
379 canvas->drawImageRect(surf->makeImageSnapshot(), SkRect::MakeWH(100, 100), nullptr);
380 canvas->translate(120, 0);
381 }
382 canvas->restore();
383 canvas->translate(0, 120);
384 }
385 }
386
387
388