1/*
2 * Copyright 2014 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 "Test.h"
9#include "RecordTestUtils.h"
10
11#include "SkBlurImageFilter.h"
12#include "SkColorFilter.h"
13#include "SkRecord.h"
14#include "SkRecordOpts.h"
15#include "SkRecorder.h"
16#include "SkRecords.h"
17#include "SkPictureRecorder.h"
18#include "SkPictureImageFilter.h"
19#include "SkSurface.h"
20
21static const int W = 1920, H = 1080;
22
23DEF_TEST(RecordOpts_NoopDraw, r) {
24    SkRecord record;
25    SkRecorder recorder(&record, W, H);
26
27    recorder.drawRect(SkRect::MakeWH(200, 200), SkPaint());
28    recorder.drawRect(SkRect::MakeWH(300, 300), SkPaint());
29    recorder.drawRect(SkRect::MakeWH(100, 100), SkPaint());
30
31    record.replace<SkRecords::NoOp>(1);  // NoOps should be allowed.
32
33    SkRecordNoopSaveRestores(&record);
34
35    REPORTER_ASSERT(r, 2 == count_instances_of_type<SkRecords::DrawRect>(record));
36}
37
38DEF_TEST(RecordOpts_SingleNoopSaveRestore, r) {
39    SkRecord record;
40    SkRecorder recorder(&record, W, H);
41
42    recorder.save();
43        recorder.clipRect(SkRect::MakeWH(200, 200));
44    recorder.restore();
45
46    SkRecordNoopSaveRestores(&record);
47    for (int i = 0; i < 3; i++) {
48        assert_type<SkRecords::NoOp>(r, record, i);
49    }
50}
51
52DEF_TEST(RecordOpts_NoopSaveRestores, r) {
53    SkRecord record;
54    SkRecorder recorder(&record, W, H);
55
56    // The second pass will clean up this pair after the first pass noops all the innards.
57    recorder.save();
58        // A simple pointless pair of save/restore.
59        recorder.save();
60        recorder.restore();
61
62        // As long as we don't draw in there, everything is a noop.
63        recorder.save();
64            recorder.clipRect(SkRect::MakeWH(200, 200));
65            recorder.clipRect(SkRect::MakeWH(100, 100));
66        recorder.restore();
67    recorder.restore();
68
69    SkRecordNoopSaveRestores(&record);
70    for (int index = 0; index < record.count(); index++) {
71        assert_type<SkRecords::NoOp>(r, record, index);
72    }
73}
74
75DEF_TEST(RecordOpts_SaveSaveLayerRestoreRestore, r) {
76    SkRecord record;
77    SkRecorder recorder(&record, W, H);
78
79    // A previous bug NoOp'd away the first 3 commands.
80    recorder.save();
81        recorder.saveLayer(nullptr, nullptr);
82        recorder.restore();
83    recorder.restore();
84
85    SkRecordNoopSaveRestores(&record);
86    switch (record.count()) {
87        case 4:
88            assert_type<SkRecords::Save>     (r, record, 0);
89            assert_type<SkRecords::SaveLayer>(r, record, 1);
90            assert_type<SkRecords::Restore>  (r, record, 2);
91            assert_type<SkRecords::Restore>  (r, record, 3);
92            break;
93        case 2:
94            assert_type<SkRecords::SaveLayer>(r, record, 0);
95            assert_type<SkRecords::Restore>  (r, record, 1);
96            break;
97        case 0:
98            break;
99        default:
100            REPORTER_ASSERT(r, false);
101    }
102}
103
104#ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK
105static void assert_savelayer_restore(skiatest::Reporter* r,
106                                     SkRecord* record,
107                                     int i,
108                                     bool shouldBeNoOped) {
109    SkRecordNoopSaveLayerDrawRestores(record);
110    if (shouldBeNoOped) {
111        assert_type<SkRecords::NoOp>(r, *record, i);
112        assert_type<SkRecords::NoOp>(r, *record, i+1);
113    } else {
114        assert_type<SkRecords::SaveLayer>(r, *record, i);
115        assert_type<SkRecords::Restore>(r, *record, i+1);
116    }
117}
118
119static void assert_savelayer_draw_restore(skiatest::Reporter* r,
120                                          SkRecord* record,
121                                          int i,
122                                          bool shouldBeNoOped) {
123    SkRecordNoopSaveLayerDrawRestores(record);
124    if (shouldBeNoOped) {
125        assert_type<SkRecords::NoOp>(r, *record, i);
126        assert_type<SkRecords::NoOp>(r, *record, i+2);
127    } else {
128        assert_type<SkRecords::SaveLayer>(r, *record, i);
129        assert_type<SkRecords::Restore>(r, *record, i+2);
130    }
131}
132
133DEF_TEST(RecordOpts_NoopSaveLayerDrawRestore, r) {
134    SkRecord record;
135    SkRecorder recorder(&record, W, H);
136
137    SkRect bounds = SkRect::MakeWH(100, 200);
138    SkRect   draw = SkRect::MakeWH(50, 60);
139
140    SkPaint alphaOnlyLayerPaint, translucentLayerPaint, xfermodeLayerPaint;
141    alphaOnlyLayerPaint.setColor(0x03000000);  // Only alpha.
142    translucentLayerPaint.setColor(0x03040506);  // Not only alpha.
143    xfermodeLayerPaint.setBlendMode(SkBlendMode::kDstIn);  // Any effect will do.
144
145    SkPaint opaqueDrawPaint, translucentDrawPaint;
146    opaqueDrawPaint.setColor(0xFF020202);  // Opaque.
147    translucentDrawPaint.setColor(0x0F020202);  // Not opaque.
148
149    // SaveLayer/Restore removed: No paint = no point.
150    recorder.saveLayer(nullptr, nullptr);
151        recorder.drawRect(draw, opaqueDrawPaint);
152    recorder.restore();
153    assert_savelayer_draw_restore(r, &record, 0, true);
154
155    // Bounds don't matter.
156    recorder.saveLayer(&bounds, nullptr);
157        recorder.drawRect(draw, opaqueDrawPaint);
158    recorder.restore();
159    assert_savelayer_draw_restore(r, &record, 3, true);
160
161    // TODO(mtklein): test case with null draw paint
162
163    // No change: layer paint isn't alpha-only.
164    recorder.saveLayer(nullptr, &translucentLayerPaint);
165        recorder.drawRect(draw, opaqueDrawPaint);
166    recorder.restore();
167    assert_savelayer_draw_restore(r, &record, 6, false);
168
169    // No change: layer paint has an effect.
170    recorder.saveLayer(nullptr, &xfermodeLayerPaint);
171        recorder.drawRect(draw, opaqueDrawPaint);
172    recorder.restore();
173    assert_savelayer_draw_restore(r, &record, 9, false);
174
175    // SaveLayer/Restore removed: we can fold in the alpha!
176    recorder.saveLayer(nullptr, &alphaOnlyLayerPaint);
177        recorder.drawRect(draw, translucentDrawPaint);
178    recorder.restore();
179    assert_savelayer_draw_restore(r, &record, 12, true);
180
181    // SaveLayer/Restore removed: we can fold in the alpha!
182    recorder.saveLayer(nullptr, &alphaOnlyLayerPaint);
183        recorder.drawRect(draw, opaqueDrawPaint);
184    recorder.restore();
185    assert_savelayer_draw_restore(r, &record, 15, true);
186
187    const SkRecords::DrawRect* drawRect = assert_type<SkRecords::DrawRect>(r, record, 16);
188    REPORTER_ASSERT(r, drawRect != nullptr);
189    REPORTER_ASSERT(r, drawRect->paint.getColor() == 0x03020202);
190
191    // saveLayer w/ backdrop should NOT go away
192    sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(3, 3, nullptr));
193    recorder.saveLayer({ nullptr, nullptr, filter.get(), nullptr, nullptr, 0});
194        recorder.drawRect(draw, opaqueDrawPaint);
195    recorder.restore();
196    assert_savelayer_draw_restore(r, &record, 18, false);
197
198    // saveLayer w/ clip mask should also NOT go away
199    {
200        sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(10, 10));
201        recorder.saveLayer({ nullptr, nullptr, nullptr, surface->makeImageSnapshot().get(),
202                             nullptr, 0});
203            recorder.drawRect(draw, opaqueDrawPaint);
204        recorder.restore();
205        assert_savelayer_draw_restore(r, &record, 21, false);
206    }
207}
208#endif
209
210static void assert_merge_svg_opacity_and_filter_layers(skiatest::Reporter* r,
211                                                       SkRecord* record,
212                                                       int i,
213                                                       bool shouldBeNoOped) {
214    SkRecordMergeSvgOpacityAndFilterLayers(record);
215    if (shouldBeNoOped) {
216        assert_type<SkRecords::NoOp>(r, *record, i);
217        assert_type<SkRecords::NoOp>(r, *record, i + 6);
218    } else {
219        assert_type<SkRecords::SaveLayer>(r, *record, i);
220        assert_type<SkRecords::Restore>(r, *record, i + 6);
221    }
222}
223
224DEF_TEST(RecordOpts_MergeSvgOpacityAndFilterLayers, r) {
225    SkRecord record;
226    SkRecorder recorder(&record, W, H);
227
228    SkRect bounds = SkRect::MakeWH(SkIntToScalar(100), SkIntToScalar(200));
229    SkRect clip = SkRect::MakeWH(SkIntToScalar(50), SkIntToScalar(60));
230
231    SkPaint alphaOnlyLayerPaint;
232    alphaOnlyLayerPaint.setColor(0x03000000);  // Only alpha.
233    SkPaint translucentLayerPaint;
234    translucentLayerPaint.setColor(0x03040506);  // Not only alpha.
235    SkPaint xfermodePaint;
236    xfermodePaint.setBlendMode(SkBlendMode::kDstIn);
237    SkPaint colorFilterPaint;
238    colorFilterPaint.setColorFilter(
239        SkColorFilter::MakeModeFilter(SK_ColorLTGRAY, SkBlendMode::kSrcIn));
240
241    SkPaint opaqueFilterLayerPaint;
242    opaqueFilterLayerPaint.setColor(0xFF020202);  // Opaque.
243    SkPaint translucentFilterLayerPaint;
244    translucentFilterLayerPaint.setColor(0x0F020202);  // Not opaque.
245    sk_sp<SkPicture> shape;
246    {
247        SkPictureRecorder recorder;
248        SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(100), SkIntToScalar(100));
249        SkPaint shapePaint;
250        shapePaint.setColor(SK_ColorWHITE);
251        canvas->drawRect(SkRect::MakeWH(SkIntToScalar(50), SkIntToScalar(50)), shapePaint);
252        shape = recorder.finishRecordingAsPicture();
253    }
254    translucentFilterLayerPaint.setImageFilter(SkPictureImageFilter::Make(shape));
255
256    int index = 0;
257
258    {
259        sk_sp<SkImageFilter> filter(SkBlurImageFilter::Make(3, 3, nullptr));
260        // first (null) should be optimized, 2nd should not
261        SkImageFilter* filters[] = { nullptr, filter.get() };
262
263        // Any combination of these should cause the pattern to be optimized.
264        SkRect* firstBounds[] = { nullptr, &bounds };
265        SkPaint* firstPaints[] = { nullptr, &alphaOnlyLayerPaint };
266        SkRect* secondBounds[] = { nullptr, &bounds };
267        SkPaint* secondPaints[] = { &opaqueFilterLayerPaint, &translucentFilterLayerPaint };
268
269        for (auto outerF : filters) {
270            bool outerNoOped = !outerF;
271            for (auto innerF : filters) {
272                for (size_t i = 0; i < SK_ARRAY_COUNT(firstBounds); ++ i) {
273                    for (size_t j = 0; j < SK_ARRAY_COUNT(firstPaints); ++j) {
274                        for (size_t k = 0; k < SK_ARRAY_COUNT(secondBounds); ++k) {
275                            for (size_t m = 0; m < SK_ARRAY_COUNT(secondPaints); ++m) {
276                                bool innerNoOped = !secondBounds[k] && !secondPaints[m] && !innerF;
277
278                                recorder.saveLayer({firstBounds[i], firstPaints[j], outerF,
279                                                    nullptr, nullptr, 0});
280                                recorder.save();
281                                recorder.clipRect(clip);
282                                recorder.saveLayer({secondBounds[k], secondPaints[m], innerF,
283                                                    nullptr, nullptr, 0});
284                                recorder.restore();
285                                recorder.restore();
286                                recorder.restore();
287                                assert_merge_svg_opacity_and_filter_layers(r, &record, index,
288                                                                           outerNoOped);
289                            #ifndef SK_BUILD_FOR_ANDROID_FRAMEWORK
290                                assert_savelayer_restore(r, &record, index + 3, innerNoOped);
291                            #endif
292                                index += 7;
293                            }
294                        }
295                    }
296                }
297            }
298        }
299    }
300
301    // These should cause the pattern to stay unoptimized:
302    struct {
303        SkPaint* firstPaint;
304        SkPaint* secondPaint;
305    } noChangeTests[] = {
306        // No change: nullptr filter layer paint not implemented.
307        { &alphaOnlyLayerPaint, nullptr },
308        // No change: layer paint is not alpha-only.
309        { &translucentLayerPaint, &opaqueFilterLayerPaint },
310        // No change: layer paint has an xfereffect.
311        { &xfermodePaint, &opaqueFilterLayerPaint },
312        // No change: filter layer paint has an xfereffect.
313        { &alphaOnlyLayerPaint, &xfermodePaint },
314        // No change: layer paint has a color filter.
315        { &colorFilterPaint, &opaqueFilterLayerPaint },
316        // No change: filter layer paint has a color filter (until the optimization accounts for
317        // constant color draws that can filter the color).
318        { &alphaOnlyLayerPaint, &colorFilterPaint }
319    };
320
321    for (size_t i = 0; i < SK_ARRAY_COUNT(noChangeTests); ++i) {
322        recorder.saveLayer(nullptr, noChangeTests[i].firstPaint);
323        recorder.save();
324        recorder.clipRect(clip);
325        recorder.saveLayer(nullptr, noChangeTests[i].secondPaint);
326        recorder.restore();
327        recorder.restore();
328        recorder.restore();
329        assert_merge_svg_opacity_and_filter_layers(r, &record, index, false);
330        index += 7;
331    }
332
333    // Test the folded alpha value.
334    recorder.saveLayer(nullptr, &alphaOnlyLayerPaint);
335    recorder.save();
336    recorder.clipRect(clip);
337    recorder.saveLayer(nullptr, &opaqueFilterLayerPaint);
338    recorder.restore();
339    recorder.restore();
340    recorder.restore();
341    assert_merge_svg_opacity_and_filter_layers(r, &record, index, true);
342
343    const SkRecords::SaveLayer* saveLayer = assert_type<SkRecords::SaveLayer>(r, record, index + 3);
344    REPORTER_ASSERT(r, saveLayer != nullptr);
345    REPORTER_ASSERT(r, saveLayer->paint->getColor() == 0x03020202);
346
347    index += 7;
348
349    // Test that currently we do not fold alphas for patterns without the clip. This is just not
350    // implemented.
351    recorder.saveLayer(nullptr, &alphaOnlyLayerPaint);
352    recorder.saveLayer(nullptr, &opaqueFilterLayerPaint);
353    recorder.restore();
354    recorder.restore();
355    SkRecordMergeSvgOpacityAndFilterLayers(&record);
356    assert_type<SkRecords::SaveLayer>(r, record, index);
357    assert_type<SkRecords::SaveLayer>(r, record, index + 1);
358    assert_type<SkRecords::Restore>(r, record, index + 2);
359    assert_type<SkRecords::Restore>(r, record, index + 3);
360    index += 4;
361}
362
363static void do_draw(SkCanvas* canvas, SkColor color, bool doLayer) {
364    canvas->drawColor(SK_ColorWHITE);
365
366    SkPaint p;
367    p.setColor(color);
368
369    if (doLayer) {
370        canvas->saveLayer(nullptr, nullptr);
371        p.setBlendMode(SkBlendMode::kSrc);
372        canvas->drawPaint(p);
373        canvas->restore();
374    } else {
375        canvas->drawPaint(p);
376    }
377}
378
379static bool is_equal(SkSurface* a, SkSurface* b) {
380    const SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
381    SkPMColor ca, cb;
382    a->readPixels(info, &ca, sizeof(SkPMColor), 0, 0);
383    b->readPixels(info, &cb, sizeof(SkPMColor), 0, 0);
384    return ca == cb;
385}
386
387// Test drawing w/ and w/o a simple layer (no bounds or paint), so see that drawing ops
388// that *should* draw the same in fact do.
389//
390// Perform this test twice : once directly, and once via a picture
391//
392static void do_savelayer_srcmode(skiatest::Reporter* r, SkColor color) {
393    for (int doPicture = 0; doPicture <= 1; ++doPicture) {
394        sk_sp<SkSurface> surf0 = SkSurface::MakeRasterN32Premul(10, 10);
395        sk_sp<SkSurface> surf1 = SkSurface::MakeRasterN32Premul(10, 10);
396        SkCanvas* c0 = surf0->getCanvas();
397        SkCanvas* c1 = surf1->getCanvas();
398
399        SkPictureRecorder rec0, rec1;
400        if (doPicture) {
401            c0 = rec0.beginRecording(10, 10);
402            c1 = rec1.beginRecording(10, 10);
403        }
404
405        do_draw(c0, color, false);
406        do_draw(c1, color, true);
407
408        if (doPicture) {
409            surf0->getCanvas()->drawPicture(rec0.finishRecordingAsPicture());
410            surf1->getCanvas()->drawPicture(rec1.finishRecordingAsPicture());
411        }
412
413        // we replicate the assert so we can see which line is reported if there is a failure
414        if (doPicture) {
415            REPORTER_ASSERT(r, is_equal(surf0.get(), surf1.get()));
416        } else {
417            REPORTER_ASSERT(r, is_equal(surf0.get(), surf1.get()));
418        }
419    }
420}
421
422DEF_TEST(savelayer_srcmode_opaque, r) {
423    do_savelayer_srcmode(r, SK_ColorRED);
424}
425
426DEF_TEST(savelayer_srcmode_alpha, r) {
427    do_savelayer_srcmode(r, 0x80FF0000);
428}
429
430