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 "SkAAClip.h"
9 #include "SkCanvas.h"
10 #include "SkMask.h"
11 #include "SkPath.h"
12 #include "SkRandom.h"
13 #include "SkRasterClip.h"
14 #include "SkRRect.h"
15 #include "Test.h"
16
operator ==(const SkMask & a,const SkMask & b)17 static bool operator==(const SkMask& a, const SkMask& b) {
18 if (a.fFormat != b.fFormat || a.fBounds != b.fBounds) {
19 return false;
20 }
21 if (!a.fImage && !b.fImage) {
22 return true;
23 }
24 if (!a.fImage || !b.fImage) {
25 return false;
26 }
27
28 size_t wbytes = a.fBounds.width();
29 switch (a.fFormat) {
30 case SkMask::kBW_Format:
31 wbytes = (wbytes + 7) >> 3;
32 break;
33 case SkMask::kA8_Format:
34 case SkMask::k3D_Format:
35 break;
36 case SkMask::kLCD16_Format:
37 wbytes <<= 1;
38 break;
39 case SkMask::kARGB32_Format:
40 wbytes <<= 2;
41 break;
42 default:
43 SkDEBUGFAIL("unknown mask format");
44 return false;
45 }
46
47 const int h = a.fBounds.height();
48 const char* aptr = (const char*)a.fImage;
49 const char* bptr = (const char*)b.fImage;
50 for (int y = 0; y < h; ++y) {
51 if (memcmp(aptr, bptr, wbytes)) {
52 return false;
53 }
54 aptr += wbytes;
55 bptr += wbytes;
56 }
57 return true;
58 }
59
copyToMask(const SkRegion & rgn,SkMask * mask)60 static void copyToMask(const SkRegion& rgn, SkMask* mask) {
61 mask->fFormat = SkMask::kA8_Format;
62
63 if (rgn.isEmpty()) {
64 mask->fBounds.setEmpty();
65 mask->fRowBytes = 0;
66 mask->fImage = nullptr;
67 return;
68 }
69
70 mask->fBounds = rgn.getBounds();
71 mask->fRowBytes = mask->fBounds.width();
72 mask->fImage = SkMask::AllocImage(mask->computeImageSize());
73 sk_bzero(mask->fImage, mask->computeImageSize());
74
75 SkImageInfo info = SkImageInfo::Make(mask->fBounds.width(),
76 mask->fBounds.height(),
77 kAlpha_8_SkColorType,
78 kPremul_SkAlphaType);
79 SkBitmap bitmap;
80 bitmap.installPixels(info, mask->fImage, mask->fRowBytes);
81
82 // canvas expects its coordinate system to always be 0,0 in the top/left
83 // so we translate the rgn to match that before drawing into the mask.
84 //
85 SkRegion tmpRgn(rgn);
86 tmpRgn.translate(-rgn.getBounds().fLeft, -rgn.getBounds().fTop);
87
88 SkCanvas canvas(bitmap);
89 canvas.clipRegion(tmpRgn);
90 canvas.drawColor(SK_ColorBLACK);
91 }
92
rand_rect(SkRandom & rand,int n)93 static SkIRect rand_rect(SkRandom& rand, int n) {
94 int x = rand.nextS() % n;
95 int y = rand.nextS() % n;
96 int w = rand.nextU() % n;
97 int h = rand.nextU() % n;
98 return SkIRect::MakeXYWH(x, y, w, h);
99 }
100
make_rand_rgn(SkRegion * rgn,SkRandom & rand)101 static void make_rand_rgn(SkRegion* rgn, SkRandom& rand) {
102 int count = rand.nextU() % 20;
103 for (int i = 0; i < count; ++i) {
104 rgn->op(rand_rect(rand, 100), SkRegion::kXOR_Op);
105 }
106 }
107
operator ==(const SkRegion & rgn,const SkAAClip & aaclip)108 static bool operator==(const SkRegion& rgn, const SkAAClip& aaclip) {
109 SkMask mask0, mask1;
110
111 copyToMask(rgn, &mask0);
112 aaclip.copyToMask(&mask1);
113 bool eq = (mask0 == mask1);
114
115 SkMask::FreeImage(mask0.fImage);
116 SkMask::FreeImage(mask1.fImage);
117 return eq;
118 }
119
equalsAAClip(const SkRegion & rgn)120 static bool equalsAAClip(const SkRegion& rgn) {
121 SkAAClip aaclip;
122 aaclip.setRegion(rgn);
123 return rgn == aaclip;
124 }
125
setRgnToPath(SkRegion * rgn,const SkPath & path)126 static void setRgnToPath(SkRegion* rgn, const SkPath& path) {
127 SkIRect ir;
128 path.getBounds().round(&ir);
129 rgn->setPath(path, SkRegion(ir));
130 }
131
132 // aaclip.setRegion should create idential masks to the region
test_rgn(skiatest::Reporter * reporter)133 static void test_rgn(skiatest::Reporter* reporter) {
134 SkRandom rand;
135 for (int i = 0; i < 1000; i++) {
136 SkRegion rgn;
137 make_rand_rgn(&rgn, rand);
138 REPORTER_ASSERT(reporter, equalsAAClip(rgn));
139 }
140
141 {
142 SkRegion rgn;
143 SkPath path;
144 path.addCircle(0, 0, SkIntToScalar(30));
145 setRgnToPath(&rgn, path);
146 REPORTER_ASSERT(reporter, equalsAAClip(rgn));
147
148 path.reset();
149 path.moveTo(0, 0);
150 path.lineTo(SkIntToScalar(100), 0);
151 path.lineTo(SkIntToScalar(100 - 20), SkIntToScalar(20));
152 path.lineTo(SkIntToScalar(20), SkIntToScalar(20));
153 setRgnToPath(&rgn, path);
154 REPORTER_ASSERT(reporter, equalsAAClip(rgn));
155 }
156 }
157
158 static const SkRegion::Op gRgnOps[] = {
159 SkRegion::kDifference_Op,
160 SkRegion::kIntersect_Op,
161 SkRegion::kUnion_Op,
162 SkRegion::kXOR_Op,
163 SkRegion::kReverseDifference_Op,
164 SkRegion::kReplace_Op
165 };
166
167 static const char* gRgnOpNames[] = {
168 "DIFF", "INTERSECT", "UNION", "XOR", "REVERSE_DIFF", "REPLACE"
169 };
170
imoveTo(SkPath & path,int x,int y)171 static void imoveTo(SkPath& path, int x, int y) {
172 path.moveTo(SkIntToScalar(x), SkIntToScalar(y));
173 }
174
icubicTo(SkPath & path,int x0,int y0,int x1,int y1,int x2,int y2)175 static void icubicTo(SkPath& path, int x0, int y0, int x1, int y1, int x2, int y2) {
176 path.cubicTo(SkIntToScalar(x0), SkIntToScalar(y0),
177 SkIntToScalar(x1), SkIntToScalar(y1),
178 SkIntToScalar(x2), SkIntToScalar(y2));
179 }
180
test_path_bounds(skiatest::Reporter * reporter)181 static void test_path_bounds(skiatest::Reporter* reporter) {
182 SkPath path;
183 SkAAClip clip;
184 const int height = 40;
185 const SkScalar sheight = SkIntToScalar(height);
186
187 path.addOval(SkRect::MakeWH(sheight, sheight));
188 REPORTER_ASSERT(reporter, sheight == path.getBounds().height());
189 clip.setPath(path, nullptr, true);
190 REPORTER_ASSERT(reporter, height == clip.getBounds().height());
191
192 // this is the trimmed height of this cubic (with aa). The critical thing
193 // for this test is that it is less than height, which represents just
194 // the bounds of the path's control-points.
195 //
196 // This used to fail until we tracked the MinY in the BuilderBlitter.
197 //
198 const int teardrop_height = 12;
199 path.reset();
200 imoveTo(path, 0, 20);
201 icubicTo(path, 40, 40, 40, 0, 0, 20);
202 REPORTER_ASSERT(reporter, sheight == path.getBounds().height());
203 clip.setPath(path, nullptr, true);
204 REPORTER_ASSERT(reporter, teardrop_height == clip.getBounds().height());
205 }
206
test_empty(skiatest::Reporter * reporter)207 static void test_empty(skiatest::Reporter* reporter) {
208 SkAAClip clip0, clip1;
209
210 REPORTER_ASSERT(reporter, clip0.isEmpty());
211 REPORTER_ASSERT(reporter, clip0.getBounds().isEmpty());
212 REPORTER_ASSERT(reporter, clip1 == clip0);
213
214 clip0.translate(10, 10); // should have no effect on empty
215 REPORTER_ASSERT(reporter, clip0.isEmpty());
216 REPORTER_ASSERT(reporter, clip0.getBounds().isEmpty());
217 REPORTER_ASSERT(reporter, clip1 == clip0);
218
219 SkIRect r = { 10, 10, 40, 50 };
220 clip0.setRect(r);
221 REPORTER_ASSERT(reporter, !clip0.isEmpty());
222 REPORTER_ASSERT(reporter, !clip0.getBounds().isEmpty());
223 REPORTER_ASSERT(reporter, clip0 != clip1);
224 REPORTER_ASSERT(reporter, clip0.getBounds() == r);
225
226 clip0.setEmpty();
227 REPORTER_ASSERT(reporter, clip0.isEmpty());
228 REPORTER_ASSERT(reporter, clip0.getBounds().isEmpty());
229 REPORTER_ASSERT(reporter, clip1 == clip0);
230
231 SkMask mask;
232 clip0.copyToMask(&mask);
233 REPORTER_ASSERT(reporter, nullptr == mask.fImage);
234 REPORTER_ASSERT(reporter, mask.fBounds.isEmpty());
235 }
236
rand_irect(SkIRect * r,int N,SkRandom & rand)237 static void rand_irect(SkIRect* r, int N, SkRandom& rand) {
238 r->setXYWH(0, 0, rand.nextU() % N, rand.nextU() % N);
239 int dx = rand.nextU() % (2*N);
240 int dy = rand.nextU() % (2*N);
241 // use int dx,dy to make the subtract be signed
242 r->offset(N - dx, N - dy);
243 }
244
test_irect(skiatest::Reporter * reporter)245 static void test_irect(skiatest::Reporter* reporter) {
246 SkRandom rand;
247
248 for (int i = 0; i < 10000; i++) {
249 SkAAClip clip0, clip1;
250 SkRegion rgn0, rgn1;
251 SkIRect r0, r1;
252
253 rand_irect(&r0, 10, rand);
254 rand_irect(&r1, 10, rand);
255 clip0.setRect(r0);
256 clip1.setRect(r1);
257 rgn0.setRect(r0);
258 rgn1.setRect(r1);
259 for (size_t j = 0; j < SK_ARRAY_COUNT(gRgnOps); ++j) {
260 SkRegion::Op op = gRgnOps[j];
261 SkAAClip clip2;
262 SkRegion rgn2;
263 bool nonEmptyAA = clip2.op(clip0, clip1, op);
264 bool nonEmptyBW = rgn2.op(rgn0, rgn1, op);
265 if (nonEmptyAA != nonEmptyBW || clip2.getBounds() != rgn2.getBounds()) {
266 ERRORF(reporter, "%s %s "
267 "[%d %d %d %d] %s [%d %d %d %d] = BW:[%d %d %d %d] AA:[%d %d %d %d]\n",
268 nonEmptyAA == nonEmptyBW ? "true" : "false",
269 clip2.getBounds() == rgn2.getBounds() ? "true" : "false",
270 r0.fLeft, r0.fTop, r0.right(), r0.bottom(),
271 gRgnOpNames[j],
272 r1.fLeft, r1.fTop, r1.right(), r1.bottom(),
273 rgn2.getBounds().fLeft, rgn2.getBounds().fTop,
274 rgn2.getBounds().right(), rgn2.getBounds().bottom(),
275 clip2.getBounds().fLeft, clip2.getBounds().fTop,
276 clip2.getBounds().right(), clip2.getBounds().bottom());
277 }
278
279 SkMask maskBW, maskAA;
280 copyToMask(rgn2, &maskBW);
281 clip2.copyToMask(&maskAA);
282 SkAutoMaskFreeImage freeBW(maskBW.fImage);
283 SkAutoMaskFreeImage freeAA(maskAA.fImage);
284 REPORTER_ASSERT(reporter, maskBW == maskAA);
285 }
286 }
287 }
288
test_path_with_hole(skiatest::Reporter * reporter)289 static void test_path_with_hole(skiatest::Reporter* reporter) {
290 static const uint8_t gExpectedImage[] = {
291 0xFF, 0xFF, 0xFF, 0xFF,
292 0xFF, 0xFF, 0xFF, 0xFF,
293 0x00, 0x00, 0x00, 0x00,
294 0x00, 0x00, 0x00, 0x00,
295 0xFF, 0xFF, 0xFF, 0xFF,
296 0xFF, 0xFF, 0xFF, 0xFF,
297 };
298 SkMask expected;
299 expected.fBounds.set(0, 0, 4, 6);
300 expected.fRowBytes = 4;
301 expected.fFormat = SkMask::kA8_Format;
302 expected.fImage = (uint8_t*)gExpectedImage;
303
304 SkPath path;
305 path.addRect(SkRect::MakeXYWH(0, 0,
306 SkIntToScalar(4), SkIntToScalar(2)));
307 path.addRect(SkRect::MakeXYWH(0, SkIntToScalar(4),
308 SkIntToScalar(4), SkIntToScalar(2)));
309
310 for (int i = 0; i < 2; ++i) {
311 SkAAClip clip;
312 clip.setPath(path, nullptr, 1 == i);
313
314 SkMask mask;
315 clip.copyToMask(&mask);
316 SkAutoMaskFreeImage freeM(mask.fImage);
317
318 REPORTER_ASSERT(reporter, expected == mask);
319 }
320 }
321
test_really_a_rect(skiatest::Reporter * reporter)322 static void test_really_a_rect(skiatest::Reporter* reporter) {
323 SkRRect rrect;
324 rrect.setRectXY(SkRect::MakeWH(100, 100), 5, 5);
325
326 SkPath path;
327 path.addRRect(rrect);
328
329 SkAAClip clip;
330 clip.setPath(path);
331
332 REPORTER_ASSERT(reporter, clip.getBounds() == SkIRect::MakeWH(100, 100));
333 REPORTER_ASSERT(reporter, !clip.isRect());
334
335 // This rect should intersect the clip, but slice-out all of the "soft" parts,
336 // leaving just a rect.
337 const SkIRect ir = SkIRect::MakeLTRB(10, -10, 50, 90);
338
339 clip.op(ir, SkRegion::kIntersect_Op);
340
341 REPORTER_ASSERT(reporter, clip.getBounds() == SkIRect::MakeLTRB(10, 0, 50, 90));
342 // the clip recognized that that it is just a rect!
343 REPORTER_ASSERT(reporter, clip.isRect());
344 }
345
did_dx_affect(skiatest::Reporter * reporter,const SkScalar dx[],size_t count,bool changed)346 static void did_dx_affect(skiatest::Reporter* reporter, const SkScalar dx[],
347 size_t count, bool changed) {
348 const SkIRect baseBounds = SkIRect::MakeXYWH(0, 0, 10, 10);
349 SkIRect ir = { 0, 0, 10, 10 };
350
351 for (size_t i = 0; i < count; ++i) {
352 SkRect r;
353 r.set(ir);
354
355 SkRasterClip rc0(ir);
356 SkRasterClip rc1(ir);
357 SkRasterClip rc2(ir);
358
359 rc0.op(r, SkMatrix::I(), baseBounds, SkRegion::kIntersect_Op, false);
360 r.offset(dx[i], 0);
361 rc1.op(r, SkMatrix::I(), baseBounds, SkRegion::kIntersect_Op, true);
362 r.offset(-2*dx[i], 0);
363 rc2.op(r, SkMatrix::I(), baseBounds, SkRegion::kIntersect_Op, true);
364
365 REPORTER_ASSERT(reporter, changed != (rc0 == rc1));
366 REPORTER_ASSERT(reporter, changed != (rc0 == rc2));
367 }
368 }
369
test_nearly_integral(skiatest::Reporter * reporter)370 static void test_nearly_integral(skiatest::Reporter* reporter) {
371 // All of these should generate equivalent rasterclips
372
373 static const SkScalar gSafeX[] = {
374 0, SK_Scalar1/1000, SK_Scalar1/100, SK_Scalar1/10,
375 };
376 did_dx_affect(reporter, gSafeX, SK_ARRAY_COUNT(gSafeX), false);
377
378 static const SkScalar gUnsafeX[] = {
379 SK_Scalar1/4, SK_Scalar1/3,
380 };
381 did_dx_affect(reporter, gUnsafeX, SK_ARRAY_COUNT(gUnsafeX), true);
382 }
383
test_regressions()384 static void test_regressions() {
385 // these should not assert in the debug build
386 // bug was introduced in rev. 3209
387 {
388 SkAAClip clip;
389 SkRect r;
390 r.fLeft = 129.892181f;
391 r.fTop = 10.3999996f;
392 r.fRight = 130.892181f;
393 r.fBottom = 20.3999996f;
394 clip.setRect(r, true);
395 }
396 }
397
398 // Building aaclip meant aa-scan-convert a path into a huge clip.
399 // the old algorithm sized the supersampler to the size of the clip, which overflowed
400 // its internal 16bit coordinates. The fix was to intersect the clip+path_bounds before
401 // sizing the supersampler.
402 //
403 // Before the fix, the following code would assert in debug builds.
404 //
test_crbug_422693(skiatest::Reporter * reporter)405 static void test_crbug_422693(skiatest::Reporter* reporter) {
406 SkRasterClip rc(SkIRect::MakeLTRB(-25000, -25000, 25000, 25000));
407 SkPath path;
408 path.addCircle(50, 50, 50);
409 rc.op(path, SkMatrix::I(), rc.getBounds(), SkRegion::kIntersect_Op, true);
410 }
411
DEF_TEST(AAClip,reporter)412 DEF_TEST(AAClip, reporter) {
413 test_empty(reporter);
414 test_path_bounds(reporter);
415 test_irect(reporter);
416 test_rgn(reporter);
417 test_path_with_hole(reporter);
418 test_regressions();
419 test_nearly_integral(reporter);
420 test_really_a_rect(reporter);
421 test_crbug_422693(reporter);
422 }
423