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