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 "include/core/SkBitmap.h"
9 #include "include/core/SkCanvas.h"
10 #include "include/core/SkColor.h"
11 #include "include/core/SkImageInfo.h"
12 #include "include/core/SkPaint.h"
13 #include "include/core/SkRRect.h"
14 #include "include/core/SkRect.h"
15 #include "include/core/SkRegion.h"
16 #include "include/core/SkScalar.h"
17 #include "include/core/SkSurface.h"
18 #include "include/core/SkTypes.h"
19 #include "include/private/SkTDArray.h"
20 #include "include/utils/SkCanvasStateUtils.h"
21 #include "src/core/SkCanvasPriv.h"
22 #include "src/core/SkClipOpPriv.h"
23 #include "src/core/SkTLazy.h"
24 #include "tests/CanvasStateHelpers.h"
25 #include "tests/Test.h"
26 #include "tools/flags/CommandLineFlags.h"
27
28 #include <cstring>
29
30 class SkCanvasState;
31
32 // dlopen and the library flag are only used for tests which require this flag.
33 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
34 #include <dlfcn.h>
35
36 static DEFINE_string(library, "",
37 "Support library to use for CanvasState test. If empty (the default), "
38 "the test will be run without crossing a library boundary. Otherwise, "
39 "it is expected to be a full path to a shared library file, which will"
40 " be dynamically loaded. Functions from the library will be called to "
41 "test SkCanvasState. Instructions for generating the library are in "
42 "gyp/canvas_state_lib.gyp");
43
44
45 // This class calls dlopen on the library passed in to the command line flag library, and handles
46 // calling dlclose when it goes out of scope.
47 class OpenLibResult {
48 public:
49 // If the flag library was passed to this run of the test, attempt to open it using dlopen and
50 // report whether it succeeded.
OpenLibResult(skiatest::Reporter * reporter)51 OpenLibResult(skiatest::Reporter* reporter) {
52 if (FLAGS_library.count() == 1) {
53 fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
54 REPORTER_ASSERT(reporter, fHandle != nullptr, "Failed to open library!");
55 } else {
56 fHandle = nullptr;
57 }
58 }
59
60 // Automatically call dlclose when going out of scope.
~OpenLibResult()61 ~OpenLibResult() {
62 if (fHandle) {
63 dlclose(fHandle);
64 }
65 }
66
67 // Pointer to the shared library object.
handle()68 void* handle() { return fHandle; }
69
70 private:
71 void* fHandle;
72 };
73
write_image(const SkImage * img,const char path[])74 static void write_image(const SkImage* img, const char path[]) {
75 auto data = img->encodeToData();
76 SkFILEWStream(path).write(data->data(), data->size());
77 }
78
compare(skiatest::Reporter * reporter,SkImage * img0,SkImage * img1)79 static void compare(skiatest::Reporter* reporter, SkImage* img0, SkImage* img1) {
80 if (false) {
81 static int counter;
82
83 SkDebugf("---- counter %d\n", counter);
84 SkString name;
85 name.printf("no_capture_%d.png", counter);
86 write_image(img0, name.c_str());
87 name.printf("capture_%d.png", counter);
88 write_image(img1, name.c_str());
89 counter++;
90 }
91
92 SkPixmap pm[2];
93 REPORTER_ASSERT(reporter, img0->peekPixels(&pm[0]));
94 REPORTER_ASSERT(reporter, img1->peekPixels(&pm[1]));
95 // now we memcmp the two bitmaps
96 REPORTER_ASSERT(reporter, pm[0].computeByteSize() == pm[1].computeByteSize());
97 REPORTER_ASSERT(reporter, pm[0].rowBytes() == (size_t)pm[0].width() * pm[0].info().bytesPerPixel());
98 REPORTER_ASSERT(reporter, pm[1].rowBytes() == (size_t)pm[1].width() * pm[1].info().bytesPerPixel());
99 if (memcmp(pm[0].addr(0, 0), pm[1].addr(0, 0), pm[0].computeByteSize())) {
100 REPORTER_ASSERT(reporter, false);
101 }
102 }
103
DEF_TEST(CanvasState_test_complex_layers,reporter)104 DEF_TEST(CanvasState_test_complex_layers, reporter) {
105 const int WIDTH = 400;
106 const int HEIGHT = 400;
107 const int SPACER = 10;
108
109 SkRect rect = SkRect::MakeXYWH(SkIntToScalar(SPACER), SkIntToScalar(SPACER),
110 SkIntToScalar(WIDTH-(2*SPACER)),
111 SkIntToScalar((HEIGHT-(2*SPACER)) / 7));
112
113 const SkColorType colorTypes[] = {
114 kRGB_565_SkColorType, kN32_SkColorType
115 };
116
117 const int layerAlpha[] = { 255, 255, 0 };
118 const SkCanvas::SaveLayerFlags flags[] = {
119 static_cast<SkCanvas::SaveLayerFlags>(SkCanvasPriv::kDontClipToLayer_SaveLayerFlag),
120 0,
121 static_cast<SkCanvas::SaveLayerFlags>(SkCanvasPriv::kDontClipToLayer_SaveLayerFlag),
122 };
123 REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
124
125 bool (*drawFn)(SkCanvasState* state, float l, float t,
126 float r, float b, int32_t s);
127
128 OpenLibResult openLibResult(reporter);
129 if (openLibResult.handle() != nullptr) {
130 *(void**) (&drawFn) = dlsym(openLibResult.handle(),
131 "complex_layers_draw_from_canvas_state");
132 } else {
133 drawFn = complex_layers_draw_from_canvas_state;
134 }
135
136 REPORTER_ASSERT(reporter, drawFn);
137 if (!drawFn) {
138 return;
139 }
140
141 for (size_t i = 0; i < SK_ARRAY_COUNT(colorTypes); ++i) {
142 sk_sp<SkImage> images[2];
143 for (int j = 0; j < 2; ++j) {
144 auto surf = SkSurface::MakeRaster(SkImageInfo::Make(WIDTH, HEIGHT,
145 colorTypes[i],
146 kPremul_SkAlphaType));
147 SkCanvas* canvas = surf->getCanvas();
148
149 canvas->drawColor(SK_ColorRED);
150
151 for (size_t k = 0; k < SK_ARRAY_COUNT(layerAlpha); ++k) {
152 SkTLazy<SkPaint> paint;
153 if (layerAlpha[k] != 0xFF) {
154 paint.init()->setAlpha(layerAlpha[k]);
155 }
156
157 // draw a rect within the layer's bounds and again outside the layer's bounds
158 canvas->saveLayer(SkCanvas::SaveLayerRec(&rect, paint.getMaybeNull(), flags[k]));
159
160 if (j) {
161 // Capture from the first Skia.
162 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(canvas);
163 REPORTER_ASSERT(reporter, state);
164
165 // And draw to it in the second Skia.
166 bool success = complex_layers_draw_from_canvas_state(state,
167 rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, SPACER);
168 REPORTER_ASSERT(reporter, success);
169
170 // And release it in the *first* Skia.
171 SkCanvasStateUtils::ReleaseCanvasState(state);
172 } else {
173 // Draw in the first Skia.
174 complex_layers_draw(canvas, rect.fLeft, rect.fTop,
175 rect.fRight, rect.fBottom, SPACER);
176 }
177
178 canvas->restore();
179
180 // translate the canvas for the next iteration
181 canvas->translate(0, 2*(rect.height() + SPACER));
182 }
183 images[j] = surf->makeImageSnapshot();
184 }
185
186 compare(reporter, images[0].get(), images[1].get());
187 }
188 }
189 #endif
190
191 ////////////////////////////////////////////////////////////////////////////////
192
193 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
DEF_TEST(CanvasState_test_complex_clips,reporter)194 DEF_TEST(CanvasState_test_complex_clips, reporter) {
195 const int WIDTH = 400;
196 const int HEIGHT = 400;
197 const int SPACER = 10;
198
199 SkIRect layerRect = SkIRect::MakeWH(WIDTH, HEIGHT / 4);
200 layerRect.inset(2*SPACER, 2*SPACER);
201
202 SkIRect clipRect = layerRect;
203 clipRect.fRight = clipRect.fLeft + (clipRect.width() / 2) - (2*SPACER);
204 clipRect.outset(SPACER, SPACER);
205
206 SkIRect regionBounds = clipRect;
207 regionBounds.offset(clipRect.width() + (2*SPACER), 0);
208
209 SkIRect regionInterior = regionBounds;
210 regionInterior.inset(SPACER*3, SPACER*3);
211
212 SkRegion clipRegion;
213 clipRegion.setRect(regionBounds);
214 clipRegion.op(regionInterior, SkRegion::kDifference_Op);
215
216
217 const SkRegion::Op clipOps[] = { SkRegion::kIntersect_Op,
218 SkRegion::kIntersect_Op,
219 SkRegion::kReplace_Op,
220 };
221 const SkCanvas::SaveLayerFlags flags[] = {
222 static_cast<SkCanvas::SaveLayerFlags>(SkCanvasPriv::kDontClipToLayer_SaveLayerFlag),
223 0,
224 static_cast<SkCanvas::SaveLayerFlags>(SkCanvasPriv::kDontClipToLayer_SaveLayerFlag),
225 };
226 REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
227
228 bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
229 int32_t r, int32_t b, int32_t clipOp,
230 int32_t regionRects, int32_t* rectCoords);
231
232 OpenLibResult openLibResult(reporter);
233 if (openLibResult.handle() != nullptr) {
234 *(void**) (&drawFn) = dlsym(openLibResult.handle(),
235 "complex_clips_draw_from_canvas_state");
236 } else {
237 drawFn = complex_clips_draw_from_canvas_state;
238 }
239
240 REPORTER_ASSERT(reporter, drawFn);
241 if (!drawFn) {
242 return;
243 }
244
245 sk_sp<SkImage> images[2];
246 for (int i = 0; i < 2; ++i) {
247 auto surf = SkSurface::MakeRaster(SkImageInfo::MakeN32Premul(WIDTH, HEIGHT));
248 SkCanvas* canvas = surf->getCanvas();
249
250 canvas->drawColor(SK_ColorRED);
251
252 SkRegion localRegion = clipRegion;
253
254 SkPaint paint;
255 paint.setAlpha(128);
256 for (size_t j = 0; j < SK_ARRAY_COUNT(flags); ++j) {
257 SkRect layerBounds = SkRect::Make(layerRect);
258 canvas->saveLayer(SkCanvas::SaveLayerRec(&layerBounds, &paint, flags[j]));
259
260 if (i) {
261 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(canvas);
262 REPORTER_ASSERT(reporter, state);
263
264 SkRegion::Iterator iter(localRegion);
265 SkTDArray<int32_t> rectCoords;
266 for (; !iter.done(); iter.next()) {
267 const SkIRect& rect = iter.rect();
268 *rectCoords.append() = rect.fLeft;
269 *rectCoords.append() = rect.fTop;
270 *rectCoords.append() = rect.fRight;
271 *rectCoords.append() = rect.fBottom;
272 }
273 bool success = drawFn(state, clipRect.fLeft, clipRect.fTop,
274 clipRect.fRight, clipRect.fBottom, clipOps[j],
275 rectCoords.count() / 4, rectCoords.begin());
276 REPORTER_ASSERT(reporter, success);
277
278 SkCanvasStateUtils::ReleaseCanvasState(state);
279 } else {
280 complex_clips_draw(canvas, clipRect.fLeft, clipRect.fTop,
281 clipRect.fRight, clipRect.fBottom, clipOps[j],
282 localRegion);
283 }
284
285 canvas->restore();
286
287 // translate the canvas and region for the next iteration
288 canvas->translate(0, SkIntToScalar(2*(layerRect.height() + (SPACER))));
289 localRegion.translate(0, 2*(layerRect.height() + SPACER));
290 }
291 images[i] = surf->makeImageSnapshot();
292 }
293
294 compare(reporter, images[0].get(), images[1].get());
295 }
296 #endif
297
298 ////////////////////////////////////////////////////////////////////////////////
299
DEF_TEST(CanvasState_test_soft_clips,reporter)300 DEF_TEST(CanvasState_test_soft_clips, reporter) {
301 SkBitmap bitmap;
302 bitmap.allocN32Pixels(10, 10);
303 SkCanvas canvas(bitmap);
304
305 SkRRect roundRect;
306 roundRect.setOval(SkRect::MakeWH(5, 5));
307
308 canvas.clipRRect(roundRect, kIntersect_SkClipOp, true);
309
310 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
311 REPORTER_ASSERT(reporter, !state);
312 }
313
DEF_TEST(CanvasState_test_saveLayer_clip,reporter)314 DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
315 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
316 static_assert(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag ==
317 SkCanvasPriv::kDontClipToLayer_SaveLayerFlag, "");
318 #endif
319 const int WIDTH = 100;
320 const int HEIGHT = 100;
321 const int LAYER_WIDTH = 50;
322 const int LAYER_HEIGHT = 50;
323
324 SkBitmap bitmap;
325 bitmap.allocN32Pixels(WIDTH, HEIGHT);
326 SkCanvas canvas(bitmap);
327
328 SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
329 canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
330
331 SkIRect devClip;
332 // Check that saveLayer without the kClipToLayer_SaveFlag leaves the clip unchanged.
333 canvas.saveLayer(SkCanvas::SaveLayerRec(&bounds, nullptr,
334 (SkCanvas::SaveLayerFlags) SkCanvasPriv::kDontClipToLayer_SaveLayerFlag));
335 devClip = canvas.getDeviceClipBounds();
336 REPORTER_ASSERT(reporter, canvas.isClipRect());
337 REPORTER_ASSERT(reporter, devClip.width() == WIDTH);
338 REPORTER_ASSERT(reporter, devClip.height() == HEIGHT);
339 canvas.restore();
340
341 // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
342 // stack to the layer bounds.
343 canvas.saveLayer(&bounds, nullptr);
344 devClip = canvas.getDeviceClipBounds();
345 REPORTER_ASSERT(reporter, canvas.isClipRect());
346 REPORTER_ASSERT(reporter, devClip.width() == LAYER_WIDTH);
347 REPORTER_ASSERT(reporter, devClip.height() == LAYER_HEIGHT);
348 canvas.restore();
349 }
350