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