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