1 // Copyright 2018 Google LLC.
2 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
3 
4 // Jitter GMs
5 //
6 // Re-execute rendering tests with slight translational changes and see if
7 // there is a significant change.  Print `1` if the named test has no
8 // significant change, `0` otherwise
9 
10 #include "gm.h"
11 #include "SkGraphics.h"
12 #include "SkExecutor.h"
13 #include "SkSemaphore.h"
14 
15 #include "skqp_model.h"
16 
17 #include <algorithm>
18 #include <cstdio>
19 #include <fstream>
20 #include <iostream>
21 #include <mutex>
22 #include <string>
23 #include <vector>
24 
25 // Error tolerance distance in 8888 color space with Manhattan metric on color channel.
26 static constexpr uint8_t kSkiaSkqpGlobalErrorTolerance = 8;
27 
28 // Number of times to jitter the canvas.
29 static constexpr int kNumberOfJitters = 7;
30 
31 // Distance to translate the canvas in each jitter (direction will be different each time).
32 static constexpr float kJitterMagnitude = 0.03125f;
33 
34 // The `kNumberOfJitters` different runs will each go in a different direction.
35 // this is the angle (in radians) for the first one.
36 static constexpr float kPhase = 0.3f;
37 
do_gm(SkBitmap * bm,skiagm::GM * gm,SkPoint jitter)38 static void do_gm(SkBitmap* bm, skiagm::GM* gm, SkPoint jitter) {
39     SkASSERT(bm);
40     SkASSERT(gm);
41     SkASSERT(bm->dimensions() == gm->getISize());
42     SkCanvas canvas(*bm);
43     SkAutoCanvasRestore autoCanvasRestore(&canvas, true);
44     canvas.clear(SK_ColorWHITE);
45     canvas.translate(jitter.x(), jitter.y());
46     gm->draw(&canvas);
47     canvas.flush();
48 }
49 
50 // Return true if passes jitter test.
test_jitter(skiagm::GM * gm)51 static bool test_jitter(skiagm::GM* gm) {
52     SkASSERT(gm);
53     SkISize size = gm->getISize();
54     SkBitmap control, experimental;
55     control.allocN32Pixels(size.width(), size.height());
56     experimental.allocN32Pixels(size.width(), size.height());
57     do_gm(&control, gm, {0, 0});
58     for (int i = 0; i < kNumberOfJitters; ++i) {
59         float angle = i * (6.2831853f / kNumberOfJitters) + kPhase;
60         do_gm(&experimental, gm, SkPoint{kJitterMagnitude * cosf(angle),
61                                          kJitterMagnitude * sinf(angle)});
62         SkQP::RenderOutcome result = skqp::Check(
63                 control.pixmap(), control.pixmap(), experimental.pixmap(),
64                 kSkiaSkqpGlobalErrorTolerance, nullptr);
65         if (result.fTotalError > 0) {
66             return false;
67         }
68     }
69     return true;
70 }
71 
do_this_test(const char * name,const std::vector<std::string> & doNotRun,const std::vector<std::string> & testOnlyThese)72 static bool do_this_test(const char* name,
73                     const std::vector<std::string>& doNotRun,
74                     const std::vector<std::string>& testOnlyThese) {
75     for (const std::string& bad : doNotRun) {
76         if (bad == name) {
77             return false;
78         }
79     }
80     for (const std::string& good : testOnlyThese) {
81         if (good == name) {
82             return true;
83         }
84     }
85     return testOnlyThese.empty();
86 }
87 
88 
main(int argc,char ** argv)89 int main(int argc, char** argv) {
90     std::vector<std::string> doNotRun;
91     std::vector<std::string> testOnlyThese;
92     if (argc > 1) {
93         std::ifstream ifs(argv[1]);
94         if (ifs.is_open()) {
95             std::string str;
96             while (std::getline(ifs, str)) {
97                 doNotRun.push_back(str);
98             }
99         }
100     }
101     if (argc > 2) {
102         for (int i = 2; i < argc; ++i) {
103             testOnlyThese.emplace_back(argv[i]);
104         }
105     }
106     SkGraphics::Init();
107     std::mutex mutex;
108     std::vector<std::string> goodResults;
109     std::vector<std::string> badResults;
110 
111     int total = 0;
112     SkSemaphore semaphore;
113     auto executor = SkExecutor::MakeFIFOThreadPool();
114     for (skiagm::GMFactory factory : skiagm::GMRegistry::Range()) {
115         ++total;
116         executor->add([factory, &mutex, &goodResults, &badResults,
117                        &semaphore, &doNotRun, &testOnlyThese](){
118             std::unique_ptr<skiagm::GM> gm(factory(nullptr));
119             const char* name = gm->getName();
120             if (do_this_test(name, doNotRun, testOnlyThese)) {
121                 bool success = test_jitter(gm.get());
122                 std::lock_guard<std::mutex> lock(mutex);
123                 if (success) {
124                     goodResults.emplace_back(name);
125                 } else {
126                     badResults.emplace_back(name);
127                 }
128                 fputc('.', stderr);
129                 fflush(stderr);
130             }
131             semaphore.signal();
132         });
133     }
134     while (total-- > 0) { semaphore.wait(); }
135     fputc('\n', stderr);
136     fflush(stderr);
137     std::sort(goodResults.begin(), goodResults.end());
138     std::sort(badResults.begin(), badResults.end());
139     std::ofstream good("good.txt");
140     std::ofstream bad("bad.txt");
141     for (const std::string& s : goodResults) { good << s << '\n'; }
142     for (const std::string& s : badResults) { bad << s << '\n'; }
143     fprintf(stderr, "good = %u\nbad = %u\n\n",
144             (unsigned)goodResults.size(), (unsigned)badResults.size());
145 }
146