blob: e77c99c3042740aef3c304024ce0b1c18b8ee14c [file] [log] [blame]
scroggo478652e2015-03-25 07:11:02 -07001/*
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
jcgregorio3b27ade2014-11-13 08:06:40 -08008#include "CrashHandler.h"
mtklein748ca3b2015-01-15 10:56:12 -08009#include "DMJsonWriter.h"
10#include "DMSrcSink.h"
tomhudsoneebc39a2015-02-23 12:18:05 -080011#include "DMSrcSinkAndroid.h"
mtklein748ca3b2015-01-15 10:56:12 -080012#include "ProcStats.h"
halcanary7d571242016-02-24 17:59:16 -080013#include "Resources.h"
mtklein748ca3b2015-01-15 10:56:12 -080014#include "SkBBHFactory.h"
mtklein62bd1a62015-01-27 14:46:26 -080015#include "SkChecksum.h"
scroggocc2feb12015-08-14 08:32:46 -070016#include "SkCodec.h"
mtklein27c3fdd2016-02-26 14:43:21 -080017#include "SkColorPriv.h"
caryclark17f0b6d2014-07-22 10:15:34 -070018#include "SkCommonFlags.h"
kkinnunen3e980c32015-12-23 01:33:00 -080019#include "SkCommonFlagsConfig.h"
brianosman3c579dc2016-04-19 09:18:11 -070020#include "SkData.h"
caryclark83ca6282015-06-10 09:31:09 -070021#include "SkFontMgr.h"
mtklein@google.comd36522d2013-10-16 13:02:15 +000022#include "SkGraphics.h"
mtklein27c3fdd2016-02-26 14:43:21 -080023#include "SkHalf.h"
mtklein748ca3b2015-01-15 10:56:12 -080024#include "SkMD5.h"
mtklein1b249332015-07-07 12:21:21 -070025#include "SkMutex.h"
mtklein1d0f1642014-09-08 08:05:18 -070026#include "SkOSFile.h"
mtklein27c3fdd2016-02-26 14:43:21 -080027#include "SkPM4fPriv.h"
mtklein246ba3a2016-02-23 10:39:36 -080028#include "SkSpinlock.h"
mtkleina82f5622015-02-20 12:30:19 -080029#include "SkTHash.h"
mtklein406654b2014-09-03 15:34:37 -070030#include "SkTaskGroup.h"
mtkleinde6fc2b2015-03-12 06:28:54 -070031#include "SkThreadUtils.h"
commit-bot@chromium.org0dc5bd12014-02-26 16:31:22 +000032#include "Test.h"
mtklein748ca3b2015-01-15 10:56:12 -080033#include "Timer.h"
brianosman3c579dc2016-04-19 09:18:11 -070034#include "picture_utils.h"
caryclark83ca6282015-06-10 09:31:09 -070035#include "sk_tool_utils.h"
mtklein@google.comd36522d2013-10-16 13:02:15 +000036
halcanary7a14b312015-10-01 07:28:13 -070037#ifdef SK_PDF_IMAGE_STATS
38extern void SkPDFImageDumpStats();
39#endif
40
mtkleina5114d72015-08-24 13:27:01 -070041#include "png.h"
42
bungeman60e0fee2015-08-26 05:15:46 -070043#include <stdlib.h>
44
scroggo27a58342015-10-28 08:56:41 -070045#ifndef SK_BUILD_FOR_WIN32
46 #include <unistd.h>
47#endif
48
djsollen54416de2015-04-03 07:24:48 -070049DEFINE_string(src, "tests gm skp image", "Source types to test.");
mtklein748ca3b2015-01-15 10:56:12 -080050DEFINE_bool(nameByHash, false,
51 "If true, write to FLAGS_writePath[0]/<hash>.png instead of "
djsollen54416de2015-04-03 07:24:48 -070052 "to FLAGS_writePath[0]/<config>/<sourceType>/<sourceOptions>/<name>.png");
mtklein748ca3b2015-01-15 10:56:12 -080053DEFINE_bool2(pathOpsExtended, x, false, "Run extended pathOps tests.");
mtkleind603b222015-02-17 11:13:33 -080054DEFINE_string(matrix, "1 0 0 1",
55 "2x2 scale+skew matrix to apply or upright when using "
56 "'matrix' or 'upright' in config.");
mtklein82d28432015-01-15 12:46:02 -080057DEFINE_bool(gpu_threading, false, "Allow GPU work to run on multiple threads?");
mtklein@google.comd36522d2013-10-16 13:02:15 +000058
mtkleina2ef6422015-01-15 13:44:22 -080059DEFINE_string(blacklist, "",
djsollen54416de2015-04-03 07:24:48 -070060 "Space-separated config/src/srcOptions/name quadruples to blacklist. '_' matches anything. E.g. \n"
61 "'--blacklist gpu skp _ _' will blacklist all SKPs drawn into the gpu config.\n"
62 "'--blacklist gpu skp _ _ 8888 gm _ aarects' will also blacklist the aarects GM on 8888.");
mtkleina2ef6422015-01-15 13:44:22 -080063
mtklein62bd1a62015-01-27 14:46:26 -080064DEFINE_string2(readPath, r, "", "If set check for equality with golden results in this directory.");
65
borenet09ed4802015-04-03 14:15:33 -070066DEFINE_string(uninterestingHashesFile, "",
67 "File containing a list of uninteresting hashes. If a result hashes to something in "
68 "this list, no image is written for that result.");
69
mtklein6393c062015-04-27 08:45:01 -070070DEFINE_int32(shards, 1, "We're splitting source data into this many shards.");
71DEFINE_int32(shard, 0, "Which shard do I run?");
scroggoe4499842016-02-25 11:03:47 -080072DEFINE_bool(simpleCodec, false, "Only decode images to native scale");
mtklein6393c062015-04-27 08:45:01 -070073
mtklein748ca3b2015-01-15 10:56:12 -080074using namespace DM;
bsalomon3724e572016-03-30 18:56:19 -070075using sk_gpu_test::GrContextFactory;
bsalomon273c0f52016-03-31 10:59:06 -070076using sk_gpu_test::GLTestContext;
bsalomonf2f1c172016-04-05 12:59:06 -070077using sk_gpu_test::ContextInfo;
mtklein@google.comd36522d2013-10-16 13:02:15 +000078
mtklein748ca3b2015-01-15 10:56:12 -080079/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
80
benjaminwagnerec4d4d72016-03-25 12:59:53 -070081static const double kStartMs = SkTime::GetMSecs();
mtkleinc41fd922016-03-08 09:01:39 -080082
83static FILE* gVLog;
84
85template <typename... Args>
86static void vlog(const char* fmt, Args&&... args) {
87 if (gVLog) {
88 fprintf(gVLog, "%s\t", HumanizeMs(SkTime::GetMSecs() - kStartMs).c_str());
89 fprintf(gVLog, fmt, args...);
90 fflush(gVLog);
91 }
92}
93
94template <typename... Args>
95static void info(const char* fmt, Args&&... args) {
96 vlog(fmt, args...);
97 if (!FLAGS_quiet) {
98 printf(fmt, args...);
99 }
100}
101static void info(const char* fmt) {
102 if (!FLAGS_quiet) {
103 printf("%s", fmt); // Clang warns printf(fmt) is insecure.
104 }
105}
106
mtklein748ca3b2015-01-15 10:56:12 -0800107SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
108static SkTArray<SkString> gFailures;
109
mtklein3eed7dd2016-02-24 19:07:07 -0800110static void fail(const SkString& err) {
mtklein748ca3b2015-01-15 10:56:12 -0800111 SkAutoMutexAcquire lock(gFailuresMutex);
112 SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
113 gFailures.push_back(err);
halcanary9e398f72015-01-10 11:18:04 -0800114}
115
mtkleinb37cb412015-03-18 05:27:14 -0700116
mtklein246ba3a2016-02-23 10:39:36 -0800117// We use a spinlock to make locking this in a signal handler _somewhat_ safe.
mtklein15923c92016-02-29 10:14:38 -0800118static SkSpinlock gMutex;
mtklein3eed7dd2016-02-24 19:07:07 -0800119static int32_t gPending;
120static SkTArray<SkString> gRunning;
mtklein748ca3b2015-01-15 10:56:12 -0800121
mtklein3eed7dd2016-02-24 19:07:07 -0800122static void done(const char* config, const char* src, const char* srcOptions, const char* name) {
123 SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
mtkleinc41fd922016-03-08 09:01:39 -0800124 vlog("done %s\n", id.c_str());
mtkleinafae30a2016-02-24 12:28:32 -0800125 int pending;
mtkleinb37cb412015-03-18 05:27:14 -0700126 {
mtklein15923c92016-02-29 10:14:38 -0800127 SkAutoTAcquire<SkSpinlock> lock(gMutex);
mtkleinb37cb412015-03-18 05:27:14 -0700128 for (int i = 0; i < gRunning.count(); i++) {
129 if (gRunning[i] == id) {
130 gRunning.removeShuffle(i);
131 break;
132 }
133 }
mtkleinafae30a2016-02-24 12:28:32 -0800134 pending = --gPending;
reed50bc0512015-05-19 14:13:31 -0700135 }
mtkleina17241b2015-01-23 05:48:00 -0800136 // We write our dm.json file every once in a while in case we crash.
137 // Notice this also handles the final dm.json when pending == 0.
138 if (pending % 500 == 0) {
139 JsonWriter::DumpJson();
140 }
mtklein@google.comd36522d2013-10-16 13:02:15 +0000141}
142
mtklein3eed7dd2016-02-24 19:07:07 -0800143static void start(const char* config, const char* src, const char* srcOptions, const char* name) {
144 SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
mtkleinc41fd922016-03-08 09:01:39 -0800145 vlog("start %s\n", id.c_str());
mtklein15923c92016-02-29 10:14:38 -0800146 SkAutoTAcquire<SkSpinlock> lock(gMutex);
mtkleinb37cb412015-03-18 05:27:14 -0700147 gRunning.push_back(id);
148}
149
mtkleinafae30a2016-02-24 12:28:32 -0800150static void print_status() {
mtkleinafae30a2016-02-24 12:28:32 -0800151 int curr = sk_tools::getCurrResidentSetSizeMB(),
152 peak = sk_tools::getMaxResidentSetSizeMB();
mtkleinc41fd922016-03-08 09:01:39 -0800153 SkString elapsed = HumanizeMs(SkTime::GetMSecs() - kStartMs);
mtkleinafae30a2016-02-24 12:28:32 -0800154
mtklein15923c92016-02-29 10:14:38 -0800155 SkAutoTAcquire<SkSpinlock> lock(gMutex);
mtkleinc41fd922016-03-08 09:01:39 -0800156 info("\n%s elapsed, %d active, %d queued, %dMB RAM, %dMB peak\n",
157 elapsed.c_str(), gRunning.count(), gPending - gRunning.count(), curr, peak);
mtkleinafae30a2016-02-24 12:28:32 -0800158 for (auto& task : gRunning) {
mtkleinc41fd922016-03-08 09:01:39 -0800159 info("\t%s\n", task.c_str());
mtkleinafae30a2016-02-24 12:28:32 -0800160 }
161}
162
mtkleinf8557292016-02-29 06:35:28 -0800163// Yo dawg, I heard you like signals so I caught a signal in your
164// signal handler so you can handle signals while you handle signals.
165// Let's not get into that situation. Only print if we're the first ones to get a crash signal.
166static std::atomic<bool> in_signal_handler{false};
167
mtklein246ba3a2016-02-23 10:39:36 -0800168#if defined(SK_BUILD_FOR_WIN32)
mtkleinf8557292016-02-29 06:35:28 -0800169 static LONG WINAPI handler(EXCEPTION_POINTERS* e) {
170 static const struct {
171 const char* name;
robertphillips75467862016-03-01 14:10:23 -0800172 DWORD code;
mtkleinf8557292016-02-29 06:35:28 -0800173 } kExceptions[] = {
174 #define _(E) {#E, E}
175 _(EXCEPTION_ACCESS_VIOLATION),
176 _(EXCEPTION_BREAKPOINT),
177 _(EXCEPTION_INT_DIVIDE_BY_ZERO),
178 _(EXCEPTION_STACK_OVERFLOW),
179 // TODO: more?
180 #undef _
181 };
182
183 if (!in_signal_handler.exchange(true)) {
184 const DWORD code = e->ExceptionRecord->ExceptionCode;
mtkleinc41fd922016-03-08 09:01:39 -0800185 info("\nCaught exception %u", code);
mtkleinf8557292016-02-29 06:35:28 -0800186 for (const auto& exception : kExceptions) {
187 if (exception.code == code) {
mtkleinc41fd922016-03-08 09:01:39 -0800188 info(" %s", exception.name);
mtkleinf8557292016-02-29 06:35:28 -0800189 }
190 }
mtkleinc41fd922016-03-08 09:01:39 -0800191 info("\n");
mtkleinf8557292016-02-29 06:35:28 -0800192 print_status();
mtklein13bf3392016-03-17 10:16:12 -0700193 fflush(stdout);
mtkleinf8557292016-02-29 06:35:28 -0800194 }
195 // Execute default exception handler... hopefully, exit.
196 return EXCEPTION_EXECUTE_HANDLER;
mtklein246ba3a2016-02-23 10:39:36 -0800197 }
mtkleinf8557292016-02-29 06:35:28 -0800198 static void setup_crash_handler() { SetUnhandledExceptionFilter(handler); }
mtklein246ba3a2016-02-23 10:39:36 -0800199
mtklein819ab102016-02-29 17:02:52 -0800200#elif !defined(SK_BUILD_FOR_ANDROID)
201 #include <execinfo.h>
mtklein246ba3a2016-02-23 10:39:36 -0800202 #include <signal.h>
mtklein819ab102016-02-29 17:02:52 -0800203 #include <stdlib.h>
mtkleinf8557292016-02-29 06:35:28 -0800204
mtklein246ba3a2016-02-23 10:39:36 -0800205 static void setup_crash_handler() {
206 const int kSignals[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV };
207 for (int sig : kSignals) {
208 signal(sig, [](int sig) {
mtkleinf8557292016-02-29 06:35:28 -0800209 if (!in_signal_handler.exchange(true)) {
mtklein819ab102016-02-29 17:02:52 -0800210 SkAutoTAcquire<SkSpinlock> lock(gMutex);
mtkleinc41fd922016-03-08 09:01:39 -0800211 info("\nCaught signal %d [%s], was running:\n", sig, strsignal(sig));
mtklein819ab102016-02-29 17:02:52 -0800212 for (auto& task : gRunning) {
mtkleinc41fd922016-03-08 09:01:39 -0800213 info("\t%s\n", task.c_str());
mtklein819ab102016-02-29 17:02:52 -0800214 }
215
216 void* stack[64];
217 int count = backtrace(stack, SK_ARRAY_COUNT(stack));
218 char** symbols = backtrace_symbols(stack, count);
mtkleinc41fd922016-03-08 09:01:39 -0800219 info("\nStack trace:\n");
mtklein819ab102016-02-29 17:02:52 -0800220 for (int i = 0; i < count; i++) {
mtkleinc41fd922016-03-08 09:01:39 -0800221 info(" %s\n", symbols[i]);
mtklein819ab102016-02-29 17:02:52 -0800222 }
mtklein13bf3392016-03-17 10:16:12 -0700223 fflush(stdout);
mtkleinf8557292016-02-29 06:35:28 -0800224 }
mtklein819ab102016-02-29 17:02:52 -0800225 _Exit(sig);
mtklein246ba3a2016-02-23 10:39:36 -0800226 });
227 }
228 }
mtklein819ab102016-02-29 17:02:52 -0800229
230#else // Android
231 static void setup_crash_handler() {}
mtklein246ba3a2016-02-23 10:39:36 -0800232#endif
233
mtklein748ca3b2015-01-15 10:56:12 -0800234/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
mtklein114c3cd2015-01-15 10:15:02 -0800235
mtklein62bd1a62015-01-27 14:46:26 -0800236struct Gold : public SkString {
mtkleina82f5622015-02-20 12:30:19 -0800237 Gold() : SkString("") {}
mtklein3eed7dd2016-02-24 19:07:07 -0800238 Gold(const SkString& sink, const SkString& src,
239 const SkString& srcOptions, const SkString& name,
240 const SkString& md5)
mtklein62bd1a62015-01-27 14:46:26 -0800241 : SkString("") {
242 this->append(sink);
243 this->append(src);
djsollen54416de2015-04-03 07:24:48 -0700244 this->append(srcOptions);
mtklein62bd1a62015-01-27 14:46:26 -0800245 this->append(name);
246 this->append(md5);
mtklein62bd1a62015-01-27 14:46:26 -0800247 }
mtkleinc8d1dd42015-10-15 12:23:01 -0700248 struct Hash {
249 uint32_t operator()(const Gold& g) const {
250 return SkGoodHash()((const SkString&)g);
251 }
252 };
mtklein62bd1a62015-01-27 14:46:26 -0800253};
mtkleina82f5622015-02-20 12:30:19 -0800254static SkTHashSet<Gold, Gold::Hash> gGold;
mtklein62bd1a62015-01-27 14:46:26 -0800255
256static void add_gold(JsonWriter::BitmapResult r) {
djsollen54416de2015-04-03 07:24:48 -0700257 gGold.add(Gold(r.config, r.sourceType, r.sourceOptions, r.name, r.md5));
mtklein62bd1a62015-01-27 14:46:26 -0800258}
259
260static void gather_gold() {
261 if (!FLAGS_readPath.isEmpty()) {
262 SkString path(FLAGS_readPath[0]);
263 path.append("/dm.json");
264 if (!JsonWriter::ReadJson(path.c_str(), add_gold)) {
265 fail(SkStringPrintf("Couldn't read %s for golden results.", path.c_str()));
266 }
267 }
268}
269
270/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
271
mtklein935f1b12016-03-16 08:37:19 -0700272#if defined(SK_BUILD_FOR_WIN32)
273 static const char* kNewline = "\r\n";
274#else
275 static const char* kNewline = "\n";
276#endif
277
borenet09ed4802015-04-03 14:15:33 -0700278static SkTHashSet<SkString> gUninterestingHashes;
279
280static void gather_uninteresting_hashes() {
281 if (!FLAGS_uninterestingHashesFile.isEmpty()) {
282 SkAutoTUnref<SkData> data(SkData::NewFromFileName(FLAGS_uninterestingHashesFile[0]));
mtkleincc334b32015-09-22 11:43:53 -0700283 if (!data) {
mtkleinc41fd922016-03-08 09:01:39 -0800284 info("WARNING: unable to read uninteresting hashes from %s\n",
285 FLAGS_uninterestingHashesFile[0]);
mtkleincc334b32015-09-22 11:43:53 -0700286 return;
287 }
borenet09ed4802015-04-03 14:15:33 -0700288 SkTArray<SkString> hashes;
mtklein935f1b12016-03-16 08:37:19 -0700289 SkStrSplit((const char*)data->data(), kNewline, &hashes);
borenet09ed4802015-04-03 14:15:33 -0700290 for (const SkString& hash : hashes) {
291 gUninterestingHashes.add(hash);
292 }
mtkleinc41fd922016-03-08 09:01:39 -0800293 info("FYI: loaded %d distinct uninteresting hashes from %d lines\n",
294 gUninterestingHashes.count(), hashes.count());
borenet09ed4802015-04-03 14:15:33 -0700295 }
296}
297
298/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
299
mtkleine0effd62015-07-29 06:37:28 -0700300struct TaggedSrc : public SkAutoTDelete<Src> {
mtklein3eed7dd2016-02-24 19:07:07 -0800301 SkString tag;
302 SkString options;
mtkleine0effd62015-07-29 06:37:28 -0700303};
304
305struct TaggedSink : public SkAutoTDelete<Sink> {
kkinnunen3e980c32015-12-23 01:33:00 -0800306 SkString tag;
djsollen54416de2015-04-03 07:24:48 -0700307};
mtklein748ca3b2015-01-15 10:56:12 -0800308
309static const bool kMemcpyOK = true;
310
mtkleine0effd62015-07-29 06:37:28 -0700311static SkTArray<TaggedSrc, kMemcpyOK> gSrcs;
312static SkTArray<TaggedSink, kMemcpyOK> gSinks;
mtklein748ca3b2015-01-15 10:56:12 -0800313
mtklein6393c062015-04-27 08:45:01 -0700314static bool in_shard() {
315 static int N = 0;
316 return N++ % FLAGS_shards == FLAGS_shard;
317}
318
mtklein3eed7dd2016-02-24 19:07:07 -0800319static void push_src(const char* tag, ImplicitString options, Src* s) {
mtklein748ca3b2015-01-15 10:56:12 -0800320 SkAutoTDelete<Src> src(s);
mtklein6393c062015-04-27 08:45:01 -0700321 if (in_shard() &&
mtklein3eed7dd2016-02-24 19:07:07 -0800322 FLAGS_src.contains(tag) &&
mtklein748ca3b2015-01-15 10:56:12 -0800323 !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
mtkleine0effd62015-07-29 06:37:28 -0700324 TaggedSrc& s = gSrcs.push_back();
mtklein18300a32016-03-16 13:53:35 -0700325 s.reset(src.release());
mtklein748ca3b2015-01-15 10:56:12 -0800326 s.tag = tag;
djsollen54416de2015-04-03 07:24:48 -0700327 s.options = options;
mtklein114c3cd2015-01-15 10:15:02 -0800328 }
mtklein748ca3b2015-01-15 10:56:12 -0800329}
mtklein114c3cd2015-01-15 10:15:02 -0800330
msarett9e707a02015-09-01 14:57:57 -0700331static void push_codec_src(Path path, CodecSrc::Mode mode, CodecSrc::DstColorType dstColorType,
scroggoc5560be2016-02-03 09:42:42 -0800332 SkAlphaType dstAlphaType, float scale) {
scroggoe4499842016-02-25 11:03:47 -0800333 if (FLAGS_simpleCodec) {
334 if (mode != CodecSrc::kCodec_Mode || dstColorType != CodecSrc::kGetFromCanvas_DstColorType
335 || scale != 1.0f)
336 // Only decode in the simple case.
337 return;
338 }
msarett9e707a02015-09-01 14:57:57 -0700339 SkString folder;
340 switch (mode) {
341 case CodecSrc::kCodec_Mode:
342 folder.append("codec");
343 break;
msarettbb25b532016-01-13 09:31:39 -0800344 case CodecSrc::kCodecZeroInit_Mode:
345 folder.append("codec_zero_init");
346 break;
msarett9e707a02015-09-01 14:57:57 -0700347 case CodecSrc::kScanline_Mode:
348 folder.append("scanline");
349 break;
msarett9e707a02015-09-01 14:57:57 -0700350 case CodecSrc::kStripe_Mode:
351 folder.append("stripe");
352 break;
msarett91c22b22016-02-22 12:27:46 -0800353 case CodecSrc::kCroppedScanline_Mode:
354 folder.append("crop");
355 break;
msarett9e707a02015-09-01 14:57:57 -0700356 case CodecSrc::kSubset_Mode:
msarett36c37962015-09-02 13:20:52 -0700357 folder.append("codec_subset");
msarett9e707a02015-09-01 14:57:57 -0700358 break;
359 }
360
361 switch (dstColorType) {
362 case CodecSrc::kGrayscale_Always_DstColorType:
363 folder.append("_kGray8");
364 break;
365 case CodecSrc::kIndex8_Always_DstColorType:
366 folder.append("_kIndex8");
367 break;
msarett34e0ec42016-04-22 16:27:24 -0700368 case CodecSrc::kNonNative8888_Always_DstColorType:
369 folder.append("_kNonNative");
370 break;
msarett9e707a02015-09-01 14:57:57 -0700371 default:
372 break;
373 }
374
scroggoc5560be2016-02-03 09:42:42 -0800375 switch (dstAlphaType) {
376 case kOpaque_SkAlphaType:
377 folder.append("_opaque");
378 break;
379 case kPremul_SkAlphaType:
380 folder.append("_premul");
381 break;
382 case kUnpremul_SkAlphaType:
383 folder.append("_unpremul");
384 break;
385 default:
386 break;
387 }
388
msarett9e707a02015-09-01 14:57:57 -0700389 if (1.0f != scale) {
390 folder.appendf("_%.3f", scale);
391 }
392
scroggoc5560be2016-02-03 09:42:42 -0800393 CodecSrc* src = new CodecSrc(path, mode, dstColorType, dstAlphaType, scale);
msarett9e707a02015-09-01 14:57:57 -0700394 push_src("image", folder, src);
395}
396
msarett3d9d7a72015-10-21 10:27:10 -0700397static void push_android_codec_src(Path path, AndroidCodecSrc::Mode mode,
scroggoc5560be2016-02-03 09:42:42 -0800398 CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType, int sampleSize) {
msarett3d9d7a72015-10-21 10:27:10 -0700399 SkString folder;
400 switch (mode) {
401 case AndroidCodecSrc::kFullImage_Mode:
402 folder.append("scaled_codec");
403 break;
404 case AndroidCodecSrc::kDivisor_Mode:
405 folder.append("scaled_codec_divisor");
406 break;
407 }
408
409 switch (dstColorType) {
410 case CodecSrc::kGrayscale_Always_DstColorType:
411 folder.append("_kGray8");
412 break;
413 case CodecSrc::kIndex8_Always_DstColorType:
414 folder.append("_kIndex8");
415 break;
msarett34e0ec42016-04-22 16:27:24 -0700416 case CodecSrc::kNonNative8888_Always_DstColorType:
417 folder.append("_kNonNative");
418 break;
msarett3d9d7a72015-10-21 10:27:10 -0700419 default:
420 break;
421 }
422
scroggoc5560be2016-02-03 09:42:42 -0800423 switch (dstAlphaType) {
424 case kOpaque_SkAlphaType:
425 folder.append("_opaque");
426 break;
427 case kPremul_SkAlphaType:
428 folder.append("_premul");
429 break;
msarett9e9444c2016-02-03 12:39:10 -0800430 case kUnpremul_SkAlphaType:
431 folder.append("_unpremul");
432 break;
scroggoc5560be2016-02-03 09:42:42 -0800433 default:
434 break;
435 }
436
msarett3d9d7a72015-10-21 10:27:10 -0700437 if (1 != sampleSize) {
msarett4b0778e2015-11-13 09:59:11 -0800438 folder.appendf("_%.3f", 1.0f / (float) sampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700439 }
440
scroggoc5560be2016-02-03 09:42:42 -0800441 AndroidCodecSrc* src = new AndroidCodecSrc(path, mode, dstColorType, dstAlphaType, sampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700442 push_src("image", folder, src);
443}
444
msarett18976312016-03-09 14:20:58 -0800445static void push_image_gen_src(Path path, ImageGenSrc::Mode mode, SkAlphaType alphaType, bool isGpu)
446{
447 SkString folder;
448 switch (mode) {
449 case ImageGenSrc::kCodec_Mode:
450 folder.append("gen_codec");
451 break;
452 case ImageGenSrc::kPlatform_Mode:
453 folder.append("gen_platform");
454 break;
455 }
456
457 if (isGpu) {
458 folder.append("_gpu");
459 } else {
460 switch (alphaType) {
461 case kOpaque_SkAlphaType:
462 folder.append("_opaque");
463 break;
464 case kPremul_SkAlphaType:
465 folder.append("_premul");
466 break;
467 case kUnpremul_SkAlphaType:
468 folder.append("_unpremul");
469 break;
470 default:
471 break;
472 }
473 }
474
475 ImageGenSrc* src = new ImageGenSrc(path, mode, alphaType, isGpu);
476 push_src("image", folder, src);
477}
478
msarett438b2ad2015-04-09 12:43:10 -0700479static void push_codec_srcs(Path path) {
480 SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
481 if (!encoded) {
mtkleinc41fd922016-03-08 09:01:39 -0800482 info("Couldn't read %s.", path.c_str());
msarett438b2ad2015-04-09 12:43:10 -0700483 return;
484 }
485 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
halcanary96fcdcc2015-08-27 07:41:13 -0700486 if (nullptr == codec.get()) {
mtkleinc41fd922016-03-08 09:01:39 -0800487 info("Couldn't create codec for %s.", path.c_str());
msarett438b2ad2015-04-09 12:43:10 -0700488 return;
489 }
490
msarett36c37962015-09-02 13:20:52 -0700491 // Native Scales
emmaleer8f4ba762015-08-14 07:44:46 -0700492 // SkJpegCodec natively supports scaling to: 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875
msarett36c37962015-09-02 13:20:52 -0700493 const float nativeScales[] = { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f, 1.0f };
msarett438b2ad2015-04-09 12:43:10 -0700494
msarett91c22b22016-02-22 12:27:46 -0800495 SkTArray<CodecSrc::Mode> nativeModes;
496 nativeModes.push_back(CodecSrc::kCodec_Mode);
497 nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
msarett91c22b22016-02-22 12:27:46 -0800498 switch (codec->getEncodedFormat()) {
499 case SkEncodedFormat::kJPEG_SkEncodedFormat:
500 nativeModes.push_back(CodecSrc::kScanline_Mode);
501 nativeModes.push_back(CodecSrc::kStripe_Mode);
502 nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
503 break;
504 case SkEncodedFormat::kWEBP_SkEncodedFormat:
505 nativeModes.push_back(CodecSrc::kSubset_Mode);
506 break;
yujieqin7a307df2016-03-11 07:32:33 -0800507 case SkEncodedFormat::kDNG_SkEncodedFormat:
msarettb65e6042016-02-23 05:37:25 -0800508 break;
msarett91c22b22016-02-22 12:27:46 -0800509 default:
510 nativeModes.push_back(CodecSrc::kScanline_Mode);
511 nativeModes.push_back(CodecSrc::kStripe_Mode);
512 break;
513 }
msarett9e707a02015-09-01 14:57:57 -0700514
msarett91c22b22016-02-22 12:27:46 -0800515 SkTArray<CodecSrc::DstColorType> colorTypes;
516 colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
msarett34e0ec42016-04-22 16:27:24 -0700517 colorTypes.push_back(CodecSrc::kNonNative8888_Always_DstColorType);
msarett36c37962015-09-02 13:20:52 -0700518 switch (codec->getInfo().colorType()) {
519 case kGray_8_SkColorType:
msarett91c22b22016-02-22 12:27:46 -0800520 colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
msarett55f7bdd2016-02-16 13:24:54 -0800521 if (kWBMP_SkEncodedFormat == codec->getEncodedFormat()) {
msarett91c22b22016-02-22 12:27:46 -0800522 colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
msarett55f7bdd2016-02-16 13:24:54 -0800523 }
msarett36c37962015-09-02 13:20:52 -0700524 break;
525 case kIndex_8_SkColorType:
msarett91c22b22016-02-22 12:27:46 -0800526 colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
msarett36c37962015-09-02 13:20:52 -0700527 break;
528 default:
msarett36c37962015-09-02 13:20:52 -0700529 break;
530 }
msarett9e707a02015-09-01 14:57:57 -0700531
scroggoc5560be2016-02-03 09:42:42 -0800532 SkTArray<SkAlphaType> alphaModes;
533 alphaModes.push_back(kPremul_SkAlphaType);
msarett9e9444c2016-02-03 12:39:10 -0800534 alphaModes.push_back(kUnpremul_SkAlphaType);
scroggoc5560be2016-02-03 09:42:42 -0800535 if (codec->getInfo().alphaType() == kOpaque_SkAlphaType) {
536 alphaModes.push_back(kOpaque_SkAlphaType);
537 }
msarettb714fb02016-01-22 14:46:42 -0800538
539 for (CodecSrc::Mode mode : nativeModes) {
msarettb714fb02016-01-22 14:46:42 -0800540 for (float scale : nativeScales) {
msarett91c22b22016-02-22 12:27:46 -0800541 for (CodecSrc::DstColorType colorType : colorTypes) {
scroggoc5560be2016-02-03 09:42:42 -0800542 for (SkAlphaType alphaType : alphaModes) {
msarett91c22b22016-02-22 12:27:46 -0800543 // Only test kCroppedScanline_Mode when the alpha type is opaque. The test is
544 // slow and won't be interestingly different with different alpha types.
545 if (CodecSrc::kCroppedScanline_Mode == mode &&
546 kOpaque_SkAlphaType != alphaType) {
547 continue;
548 }
549
550 push_codec_src(path, mode, colorType, alphaType, scale);
scroggoc5560be2016-02-03 09:42:42 -0800551 }
msarett9e707a02015-09-01 14:57:57 -0700552 }
553 }
msarett0a242972015-06-11 14:27:27 -0700554 }
msarett36c37962015-09-02 13:20:52 -0700555
scroggoe4499842016-02-25 11:03:47 -0800556 if (FLAGS_simpleCodec) {
557 return;
558 }
559
halcanary6950de62015-11-07 05:29:00 -0800560 // https://bug.skia.org/4428
msarett33c76232015-11-16 13:43:40 -0800561 bool subset = false;
562 // The following image types are supported by BitmapRegionDecoder,
563 // so we will test full image decodes and subset decodes.
msarettbe8216a2015-12-04 08:00:50 -0800564 static const char* const exts[] = {
msarett3d9d7a72015-10-21 10:27:10 -0700565 "jpg", "jpeg", "png", "webp",
566 "JPG", "JPEG", "PNG", "WEBP",
567 };
msarettbe8216a2015-12-04 08:00:50 -0800568 for (const char* ext : exts) {
msarett3d9d7a72015-10-21 10:27:10 -0700569 if (path.endsWith(ext)) {
msarett33c76232015-11-16 13:43:40 -0800570 subset = true;
msarett3d9d7a72015-10-21 10:27:10 -0700571 break;
572 }
573 }
msarett33c76232015-11-16 13:43:40 -0800574
msarett3d9d7a72015-10-21 10:27:10 -0700575 const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
msarett36c37962015-09-02 13:20:52 -0700576
msarett3d9d7a72015-10-21 10:27:10 -0700577 for (int sampleSize : sampleSizes) {
msarett91c22b22016-02-22 12:27:46 -0800578 for (CodecSrc::DstColorType colorType : colorTypes) {
scroggoc5560be2016-02-03 09:42:42 -0800579 for (SkAlphaType alphaType : alphaModes) {
msarett91c22b22016-02-22 12:27:46 -0800580 push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorType,
scroggoc5560be2016-02-03 09:42:42 -0800581 alphaType, sampleSize);
582 if (subset) {
msarett91c22b22016-02-22 12:27:46 -0800583 push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorType,
scroggoc5560be2016-02-03 09:42:42 -0800584 alphaType, sampleSize);
585 }
msarett3d9d7a72015-10-21 10:27:10 -0700586 }
msarett36c37962015-09-02 13:20:52 -0700587 }
588 }
msarett18976312016-03-09 14:20:58 -0800589
590 static const char* const rawExts[] = {
591 "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
592 "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
593 };
594
595 // There is not currently a reason to test RAW images on image generator.
596 // If we want to enable these tests, we will need to fix skbug.com/5079.
597 for (const char* ext : rawExts) {
598 if (path.endsWith(ext)) {
599 return;
600 }
601 }
602
603 // Push image generator GPU test.
brianosmanc9ced392016-03-24 07:27:43 -0700604 push_image_gen_src(path, ImageGenSrc::kCodec_Mode, codec->getInfo().alphaType(), true);
msarett18976312016-03-09 14:20:58 -0800605
606 // Push image generator CPU tests.
607 for (SkAlphaType alphaType : alphaModes) {
608 push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
609
610#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
611 if (kWEBP_SkEncodedFormat != codec->getEncodedFormat() &&
612 kWBMP_SkEncodedFormat != codec->getEncodedFormat() &&
613 kUnpremul_SkAlphaType != alphaType)
614 {
615 push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
616 }
msarettfc0b6d12016-03-17 13:50:17 -0700617#elif defined(SK_BUILD_FOR_WIN)
618 if (kWEBP_SkEncodedFormat != codec->getEncodedFormat() &&
619 kWBMP_SkEncodedFormat != codec->getEncodedFormat())
620 {
621 push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
622 }
msarett18976312016-03-09 14:20:58 -0800623#endif
624 }
msarett438b2ad2015-04-09 12:43:10 -0700625}
626
msarett5cb48852015-11-06 08:56:32 -0800627static bool brd_color_type_supported(SkBitmapRegionDecoder::Strategy strategy,
msaretta5783ae2015-09-08 15:35:32 -0700628 CodecSrc::DstColorType dstColorType) {
629 switch (strategy) {
msarett5cb48852015-11-06 08:56:32 -0800630 case SkBitmapRegionDecoder::kCanvas_Strategy:
msaretta5783ae2015-09-08 15:35:32 -0700631 if (CodecSrc::kGetFromCanvas_DstColorType == dstColorType) {
632 return true;
633 }
634 return false;
msarett5cb48852015-11-06 08:56:32 -0800635 case SkBitmapRegionDecoder::kAndroidCodec_Strategy:
msarett26ad17b2015-10-22 07:29:19 -0700636 switch (dstColorType) {
637 case CodecSrc::kGetFromCanvas_DstColorType:
638 case CodecSrc::kIndex8_Always_DstColorType:
639 case CodecSrc::kGrayscale_Always_DstColorType:
640 return true;
641 default:
642 return false;
643 }
msaretta5783ae2015-09-08 15:35:32 -0700644 default:
645 SkASSERT(false);
646 return false;
647 }
648}
649
msarett5cb48852015-11-06 08:56:32 -0800650static void push_brd_src(Path path, SkBitmapRegionDecoder::Strategy strategy,
msaretta5783ae2015-09-08 15:35:32 -0700651 CodecSrc::DstColorType dstColorType, BRDSrc::Mode mode, uint32_t sampleSize) {
652 SkString folder;
653 switch (strategy) {
msarett5cb48852015-11-06 08:56:32 -0800654 case SkBitmapRegionDecoder::kCanvas_Strategy:
msaretta5783ae2015-09-08 15:35:32 -0700655 folder.append("brd_canvas");
656 break;
msarett5cb48852015-11-06 08:56:32 -0800657 case SkBitmapRegionDecoder::kAndroidCodec_Strategy:
msarett26ad17b2015-10-22 07:29:19 -0700658 folder.append("brd_android_codec");
659 break;
msaretta5783ae2015-09-08 15:35:32 -0700660 default:
661 SkASSERT(false);
662 return;
663 }
664
665 switch (mode) {
666 case BRDSrc::kFullImage_Mode:
667 break;
668 case BRDSrc::kDivisor_Mode:
669 folder.append("_divisor");
670 break;
671 default:
672 SkASSERT(false);
673 return;
674 }
675
676 switch (dstColorType) {
677 case CodecSrc::kGetFromCanvas_DstColorType:
678 break;
679 case CodecSrc::kIndex8_Always_DstColorType:
680 folder.append("_kIndex");
681 break;
682 case CodecSrc::kGrayscale_Always_DstColorType:
683 folder.append("_kGray");
684 break;
685 default:
686 SkASSERT(false);
687 return;
688 }
689
690 if (1 != sampleSize) {
msarett4b0778e2015-11-13 09:59:11 -0800691 folder.appendf("_%.3f", 1.0f / (float) sampleSize);
msaretta5783ae2015-09-08 15:35:32 -0700692 }
693
694 BRDSrc* src = new BRDSrc(path, strategy, mode, dstColorType, sampleSize);
695 push_src("image", folder, src);
696}
697
698static void push_brd_srcs(Path path) {
699
msarett5cb48852015-11-06 08:56:32 -0800700 const SkBitmapRegionDecoder::Strategy strategies[] = {
701 SkBitmapRegionDecoder::kCanvas_Strategy,
msarett5cb48852015-11-06 08:56:32 -0800702 SkBitmapRegionDecoder::kAndroidCodec_Strategy,
msaretta5783ae2015-09-08 15:35:32 -0700703 };
704
scroggo501b7342015-11-03 07:55:11 -0800705 // Test on a variety of sampleSizes, making sure to include:
706 // - 2, 4, and 8, which are natively supported by jpeg
707 // - multiples of 2 which are not divisible by 4 (analogous for 4)
708 // - larger powers of two, since BRD clients generally use powers of 2
709 // We will only produce output for the larger sizes on large images.
710 const uint32_t sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 24, 32, 64 };
msarett6efbe052015-09-11 09:01:16 -0700711
msaretta5783ae2015-09-08 15:35:32 -0700712 // We will only test to one backend (8888), but we will test all of the
713 // color types that we need to decode to on this backend.
714 const CodecSrc::DstColorType dstColorTypes[] = {
msarett26ad17b2015-10-22 07:29:19 -0700715 CodecSrc::kGetFromCanvas_DstColorType,
716 CodecSrc::kIndex8_Always_DstColorType,
717 CodecSrc::kGrayscale_Always_DstColorType,
msaretta5783ae2015-09-08 15:35:32 -0700718 };
719
720 const BRDSrc::Mode modes[] = {
msarett26ad17b2015-10-22 07:29:19 -0700721 BRDSrc::kFullImage_Mode,
722 BRDSrc::kDivisor_Mode,
msaretta5783ae2015-09-08 15:35:32 -0700723 };
724
msarett5cb48852015-11-06 08:56:32 -0800725 for (SkBitmapRegionDecoder::Strategy strategy : strategies) {
msarett6efbe052015-09-11 09:01:16 -0700726 for (uint32_t sampleSize : sampleSizes) {
msarett6efbe052015-09-11 09:01:16 -0700727 for (CodecSrc::DstColorType dstColorType : dstColorTypes) {
728 if (brd_color_type_supported(strategy, dstColorType)) {
729 for (BRDSrc::Mode mode : modes) {
msaretta5783ae2015-09-08 15:35:32 -0700730 push_brd_src(path, strategy, dstColorType, mode, sampleSize);
731 }
732 }
733 }
734 }
735 }
736}
737
738static bool brd_supported(const char* ext) {
msarett8c8f22a2015-04-01 06:58:48 -0700739 static const char* const exts[] = {
msaretta5783ae2015-09-08 15:35:32 -0700740 "jpg", "jpeg", "png", "webp",
741 "JPG", "JPEG", "PNG", "WEBP",
msarett8c8f22a2015-04-01 06:58:48 -0700742 };
743
744 for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
745 if (0 == strcmp(exts[i], ext)) {
746 return true;
747 }
748 }
749 return false;
scroggo9b77ddd2015-03-19 06:03:39 -0700750}
751
scroggo86737142016-02-03 12:19:11 -0800752static bool gather_srcs() {
mtklein748ca3b2015-01-15 10:56:12 -0800753 for (const skiagm::GMRegistry* r = skiagm::GMRegistry::Head(); r; r = r->next()) {
djsollen54416de2015-04-03 07:24:48 -0700754 push_src("gm", "", new GMSrc(r->factory()));
mtklein748ca3b2015-01-15 10:56:12 -0800755 }
halcanaryfc37ad12015-01-30 07:31:19 -0800756 for (int i = 0; i < FLAGS_skps.count(); i++) {
757 const char* path = FLAGS_skps[i];
758 if (sk_isdir(path)) {
759 SkOSFile::Iter it(path, "skp");
760 for (SkString file; it.next(&file); ) {
djsollen54416de2015-04-03 07:24:48 -0700761 push_src("skp", "", new SKPSrc(SkOSPath::Join(path, file.c_str())));
halcanaryfc37ad12015-01-30 07:31:19 -0800762 }
763 } else {
djsollen54416de2015-04-03 07:24:48 -0700764 push_src("skp", "", new SKPSrc(path));
mtklein114c3cd2015-01-15 10:15:02 -0800765 }
766 }
scroggo86737142016-02-03 12:19:11 -0800767
768 SkTArray<SkString> images;
769 if (!CollectImages(&images)) {
770 return false;
771 }
772
773 for (auto image : images) {
774 push_codec_srcs(image);
scroggoe4499842016-02-25 11:03:47 -0800775 if (FLAGS_simpleCodec) {
776 continue;
777 }
778
mtklein21eaf3b2016-02-08 12:39:59 -0800779 const char* ext = strrchr(image.c_str(), '.');
780 if (ext && brd_supported(ext+1)) {
scroggo86737142016-02-03 12:19:11 -0800781 push_brd_srcs(image);
mtklein709d2c32015-01-15 08:30:25 -0800782 }
mtklein709d2c32015-01-15 08:30:25 -0800783 }
scroggo86737142016-02-03 12:19:11 -0800784
785 return true;
mtklein709d2c32015-01-15 08:30:25 -0800786}
787
kkinnunen3e980c32015-12-23 01:33:00 -0800788static void push_sink(const SkCommandLineConfig& config, Sink* s) {
rmistry0f515bd2015-12-22 10:22:26 -0800789 SkAutoTDelete<Sink> sink(s);
kkinnunen3e980c32015-12-23 01:33:00 -0800790
mtkleine0effd62015-07-29 06:37:28 -0700791 // Try a simple Src as a canary. If it fails, skip this sink.
mtklein748ca3b2015-01-15 10:56:12 -0800792 struct : public Src {
mtkleine0effd62015-07-29 06:37:28 -0700793 Error draw(SkCanvas* c) const override {
794 c->drawRect(SkRect::MakeWH(1,1), SkPaint());
795 return "";
796 }
mtklein36352bf2015-03-25 18:17:31 -0700797 SkISize size() const override { return SkISize::Make(16, 16); }
mtkleine0effd62015-07-29 06:37:28 -0700798 Name name() const override { return "justOneRect"; }
799 } justOneRect;
mtklein114c3cd2015-01-15 10:15:02 -0800800
mtklein748ca3b2015-01-15 10:56:12 -0800801 SkBitmap bitmap;
802 SkDynamicMemoryWStream stream;
mtkleinb9eb4ac2015-02-02 18:26:03 -0800803 SkString log;
mtkleine0effd62015-07-29 06:37:28 -0700804 Error err = sink->draw(justOneRect, &bitmap, &stream, &log);
mtklein4089ef72015-03-05 08:40:28 -0800805 if (err.isFatal()) {
mtkleinc41fd922016-03-08 09:01:39 -0800806 info("Could not run %s: %s\n", config.getTag().c_str(), err.c_str());
mtklein05641a52015-04-21 10:49:13 -0700807 exit(1);
mtklein114c3cd2015-01-15 10:15:02 -0800808 }
809
mtkleine0effd62015-07-29 06:37:28 -0700810 TaggedSink& ts = gSinks.push_back();
mtklein18300a32016-03-16 13:53:35 -0700811 ts.reset(sink.release());
kkinnunen3e980c32015-12-23 01:33:00 -0800812 ts.tag = config.getTag();
mtklein748ca3b2015-01-15 10:56:12 -0800813}
814
815static bool gpu_supported() {
816#if SK_SUPPORT_GPU
817 return FLAGS_gpu;
818#else
819 return false;
820#endif
821}
kkinnunen9ebc3f02015-12-21 23:48:13 -0800822
kkinnunen3e980c32015-12-23 01:33:00 -0800823static Sink* create_sink(const SkCommandLineConfig* config) {
824#if SK_SUPPORT_GPU
825 if (gpu_supported()) {
826 if (const SkCommandLineConfigGpu* gpuConfig = config->asConfigGpu()) {
bsalomon85b4b532016-04-05 11:06:27 -0700827 GrContextFactory::ContextType contextType = gpuConfig->getContextType();
828 GrContextFactory::ContextOptions contextOptions =
829 GrContextFactory::kNone_ContextOptions;
kkinnunen3e980c32015-12-23 01:33:00 -0800830 if (gpuConfig->getUseNVPR()) {
bsalomon85b4b532016-04-05 11:06:27 -0700831 contextOptions = static_cast<GrContextFactory::ContextOptions>(
832 contextOptions | GrContextFactory::kEnableNVPR_ContextOptions);
kkinnunen3e980c32015-12-23 01:33:00 -0800833 }
brianosman898235c2016-04-06 07:38:23 -0700834 if (SkColorAndProfileAreGammaCorrect(gpuConfig->getColorType(),
835 gpuConfig->getProfileType())) {
bsalomon85b4b532016-04-05 11:06:27 -0700836 contextOptions = static_cast<GrContextFactory::ContextOptions>(
837 contextOptions | GrContextFactory::kRequireSRGBSupport_ContextOptions);
brianosman61d3b082016-03-30 11:19:36 -0700838 }
kkinnunen3e980c32015-12-23 01:33:00 -0800839 GrContextFactory testFactory;
840 if (!testFactory.get(contextType, contextOptions)) {
mtkleinc41fd922016-03-08 09:01:39 -0800841 info("WARNING: can not create GPU context for config '%s'. "
842 "GM tests will be skipped.\n", gpuConfig->getTag().c_str());
kkinnunen3e980c32015-12-23 01:33:00 -0800843 return nullptr;
844 }
845 return new GPUSink(contextType, contextOptions, gpuConfig->getSamples(),
brianosmand93c1202016-03-10 07:49:08 -0800846 gpuConfig->getUseDIText(), gpuConfig->getColorType(),
847 gpuConfig->getProfileType(), FLAGS_gpu_threading);
kkinnunen3e980c32015-12-23 01:33:00 -0800848 }
849 }
850#endif
851
852#define SINK(t, sink, ...) if (config->getBackend().equals(t)) { return new sink(__VA_ARGS__); }
853
tomhudsoneebc39a2015-02-23 12:18:05 -0800854#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
855 SINK("hwui", HWUISink);
856#endif
857
mtklein748ca3b2015-01-15 10:56:12 -0800858 if (FLAGS_cpu) {
859 SINK("565", RasterSink, kRGB_565_SkColorType);
860 SINK("8888", RasterSink, kN32_SkColorType);
mtklein27c3fdd2016-02-26 14:43:21 -0800861 SINK("srgb", RasterSink, kN32_SkColorType, kSRGB_SkColorProfileType);
862 SINK("f16", RasterSink, kRGBA_F16_SkColorType);
halcanary94b87bd2016-04-04 06:12:15 -0700863 SINK("pdf", PDFSink);
mtklein9c3f17d2015-01-28 11:35:18 -0800864 SINK("skp", SKPSink);
mtklein8a4527e2015-01-31 20:00:58 -0800865 SINK("svg", SVGSink);
866 SINK("null", NullSink);
halcanary47ef4d52015-03-03 09:13:09 -0800867 SINK("xps", XPSSink);
mtklein748ca3b2015-01-15 10:56:12 -0800868 }
869#undef SINK
halcanary96fcdcc2015-08-27 07:41:13 -0700870 return nullptr;
mtklein114c3cd2015-01-15 10:15:02 -0800871}
872
kkinnunen3e980c32015-12-23 01:33:00 -0800873static Sink* create_via(const SkString& tag, Sink* wrapped) {
874#define VIA(t, via, ...) if (tag.equals(t)) { return new via(__VA_ARGS__); }
halcanary96fcdcc2015-08-27 07:41:13 -0700875 VIA("twice", ViaTwice, wrapped);
halcanary96fcdcc2015-08-27 07:41:13 -0700876 VIA("serialize", ViaSerialization, wrapped);
mtklein4a34ecb2016-01-08 10:19:35 -0800877 VIA("pic", ViaPicture, wrapped);
halcanary96fcdcc2015-08-27 07:41:13 -0700878 VIA("2ndpic", ViaSecondPicture, wrapped);
mtkleind31c13d2015-05-05 12:59:56 -0700879 VIA("sp", ViaSingletonPictures, wrapped);
halcanary96fcdcc2015-08-27 07:41:13 -0700880 VIA("tiles", ViaTiles, 256, 256, nullptr, wrapped);
mtklein7edca212015-01-21 13:18:51 -0800881 VIA("tiles_rt", ViaTiles, 256, 256, new SkRTreeFactory, wrapped);
mtklein748ca3b2015-01-15 10:56:12 -0800882
mtkleind603b222015-02-17 11:13:33 -0800883 if (FLAGS_matrix.count() == 4) {
mtklein748ca3b2015-01-15 10:56:12 -0800884 SkMatrix m;
mtkleind603b222015-02-17 11:13:33 -0800885 m.reset();
886 m.setScaleX((SkScalar)atof(FLAGS_matrix[0]));
887 m.setSkewX ((SkScalar)atof(FLAGS_matrix[1]));
888 m.setSkewY ((SkScalar)atof(FLAGS_matrix[2]));
889 m.setScaleY((SkScalar)atof(FLAGS_matrix[3]));
890 VIA("matrix", ViaMatrix, m, wrapped);
891 VIA("upright", ViaUpright, m, wrapped);
mtklein748ca3b2015-01-15 10:56:12 -0800892 }
tomhudson64de1e12015-03-05 08:01:07 -0800893
894#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
895 VIA("androidsdk", ViaAndroidSDK, wrapped);
896#endif
897
mtklein748ca3b2015-01-15 10:56:12 -0800898#undef VIA
halcanary96fcdcc2015-08-27 07:41:13 -0700899 return nullptr;
mtklein114c3cd2015-01-15 10:15:02 -0800900}
901
mtklein748ca3b2015-01-15 10:56:12 -0800902static void gather_sinks() {
kkinnunen3e980c32015-12-23 01:33:00 -0800903 SkCommandLineConfigArray configs;
904 ParseConfigs(FLAGS_config, &configs);
905 for (int i = 0; i < configs.count(); i++) {
906 const SkCommandLineConfig& config = *configs[i];
907 Sink* sink = create_sink(&config);
908 if (sink == nullptr) {
mtkleinc41fd922016-03-08 09:01:39 -0800909 info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
910 config.getTag().c_str());
kkinnunen3e980c32015-12-23 01:33:00 -0800911 continue;
912 }
mtklein748ca3b2015-01-15 10:56:12 -0800913
kkinnunen3e980c32015-12-23 01:33:00 -0800914 const SkTArray<SkString>& parts = config.getViaParts();
915 for (int j = parts.count(); j-- > 0;) {
916 const SkString& part = parts[j];
917 Sink* next = create_via(part, sink);
halcanary96fcdcc2015-08-27 07:41:13 -0700918 if (next == nullptr) {
mtkleinc41fd922016-03-08 09:01:39 -0800919 info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
920 part.c_str());
mtklein748ca3b2015-01-15 10:56:12 -0800921 delete sink;
halcanary96fcdcc2015-08-27 07:41:13 -0700922 sink = nullptr;
mtklein748ca3b2015-01-15 10:56:12 -0800923 break;
924 }
925 sink = next;
926 }
927 if (sink) {
928 push_sink(config, sink);
mtklein114c3cd2015-01-15 10:15:02 -0800929 }
930 }
931}
mtklein709d2c32015-01-15 08:30:25 -0800932
mtkleina5114d72015-08-24 13:27:01 -0700933static bool dump_png(SkBitmap bitmap, const char* path, const char* md5) {
934 const int w = bitmap.width(),
935 h = bitmap.height();
936
brianosman3c579dc2016-04-19 09:18:11 -0700937 sk_sp<SkData> encodedBitmap = sk_tools::encode_bitmap_for_png(bitmap);
938 if (encodedBitmap.get() == nullptr) {
939 return false;
mtkleina5114d72015-08-24 13:27:01 -0700940 }
brianosman3c579dc2016-04-19 09:18:11 -0700941 uint32_t* rgba = static_cast<uint32_t*>(encodedBitmap.get()->writable_data());
mtkleina5114d72015-08-24 13:27:01 -0700942
943 // We don't need bitmap anymore. Might as well drop our ref.
mtkleinfccb77d2015-08-24 14:13:29 -0700944 bitmap.reset();
mtkleina5114d72015-08-24 13:27:01 -0700945
mtkleinc64137c2015-08-25 10:56:08 -0700946 FILE* f = fopen(path, "wb");
mtkleina5114d72015-08-24 13:27:01 -0700947 if (!f) { return false; }
948
949 png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
950 if (!png) {
951 fclose(f);
952 return false;
953 }
954
955 png_infop info = png_create_info_struct(png);
956 if (!info) {
957 png_destroy_write_struct(&png, &info);
958 fclose(f);
959 return false;
960 }
961
mtkleind69ece62015-09-10 10:37:44 -0700962 SkString description;
963 description.append("Key: ");
964 for (int i = 0; i < FLAGS_key.count(); i++) {
965 description.appendf("%s ", FLAGS_key[i]);
966 }
967 description.append("Properties: ");
968 for (int i = 0; i < FLAGS_properties.count(); i++) {
969 description.appendf("%s ", FLAGS_properties[i]);
970 }
971 description.appendf("MD5: %s", md5);
972
mtkleina5114d72015-08-24 13:27:01 -0700973 png_text text[2];
974 text[0].key = (png_charp)"Author";
975 text[0].text = (png_charp)"DM dump_png()";
976 text[0].compression = PNG_TEXT_COMPRESSION_NONE;
977 text[1].key = (png_charp)"Description";
mtkleind69ece62015-09-10 10:37:44 -0700978 text[1].text = (png_charp)description.c_str();
mtkleina5114d72015-08-24 13:27:01 -0700979 text[1].compression = PNG_TEXT_COMPRESSION_NONE;
980 png_set_text(png, info, text, 2);
981
982 png_init_io(png, f);
983 png_set_IHDR(png, info, (png_uint_32)w, (png_uint_32)h, 8,
984 PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
985 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
986 png_write_info(png, info);
987 for (int j = 0; j < h; j++) {
brianosman3c579dc2016-04-19 09:18:11 -0700988 png_bytep row = (png_bytep)(rgba + w*j);
mtkleina5114d72015-08-24 13:27:01 -0700989 png_write_rows(png, &row, 1);
990 }
991 png_write_end(png, info);
992
993 png_destroy_write_struct(&png, &info);
994 fclose(f);
995 return true;
996}
997
mtkleina2ef6422015-01-15 13:44:22 -0800998static bool match(const char* needle, const char* haystack) {
halcanary96fcdcc2015-08-27 07:41:13 -0700999 return 0 == strcmp("_", needle) || nullptr != strstr(haystack, needle);
mtkleina2ef6422015-01-15 13:44:22 -08001000}
1001
mtklein3eed7dd2016-02-24 19:07:07 -08001002static bool is_blacklisted(const char* sink, const char* src,
1003 const char* srcOptions, const char* name) {
mtklein0d243ff2015-04-03 07:51:00 -07001004 for (int i = 0; i < FLAGS_blacklist.count() - 3; i += 4) {
mtkleina2ef6422015-01-15 13:44:22 -08001005 if (match(FLAGS_blacklist[i+0], sink) &&
djsollen54416de2015-04-03 07:24:48 -07001006 match(FLAGS_blacklist[i+1], src) &&
1007 match(FLAGS_blacklist[i+2], srcOptions) &&
1008 match(FLAGS_blacklist[i+3], name)) {
mtklein3eed7dd2016-02-24 19:07:07 -08001009 return true;
mtkleina2ef6422015-01-15 13:44:22 -08001010 }
1011 }
mtklein3eed7dd2016-02-24 19:07:07 -08001012 return false;
mtkleina2ef6422015-01-15 13:44:22 -08001013}
1014
mtkleincd50bca2016-01-05 06:20:20 -08001015// Even when a Task Sink reports to be non-threadsafe (e.g. GPU), we know things like
1016// .png encoding are definitely thread safe. This lets us offload that work to CPU threads.
1017static SkTaskGroup gDefinitelyThreadSafeWork;
1018
mtklein748ca3b2015-01-15 10:56:12 -08001019// The finest-grained unit of work we can run: draw a single Src into a single Sink,
1020// report any errors, and perhaps write out the output: a .png of the bitmap, or a raw stream.
1021struct Task {
mtkleine0effd62015-07-29 06:37:28 -07001022 Task(const TaggedSrc& src, const TaggedSink& sink) : src(src), sink(sink) {}
1023 const TaggedSrc& src;
1024 const TaggedSink& sink;
mtklein748ca3b2015-01-15 10:56:12 -08001025
mtklein21eaf3b2016-02-08 12:39:59 -08001026 static void Run(const Task& task) {
1027 SkString name = task.src->name();
mtkleine0effd62015-07-29 06:37:28 -07001028
mtkleinb9eb4ac2015-02-02 18:26:03 -08001029 SkString log;
mtklein3eed7dd2016-02-24 19:07:07 -08001030 if (!FLAGS_dryRun) {
mtklein748ca3b2015-01-15 10:56:12 -08001031 SkBitmap bitmap;
1032 SkDynamicMemoryWStream stream;
mtklein3eed7dd2016-02-24 19:07:07 -08001033 start(task.sink.tag.c_str(), task.src.tag.c_str(),
1034 task.src.options.c_str(), name.c_str());
mtklein21eaf3b2016-02-08 12:39:59 -08001035 Error err = task.sink->draw(*task.src, &bitmap, &stream, &log);
mtkleinb3b13b72016-03-07 13:20:52 -08001036 if (!log.isEmpty()) {
mtkleinc41fd922016-03-08 09:01:39 -08001037 info("%s %s %s %s:\n%s\n", task.sink.tag.c_str()
1038 , task.src.tag.c_str()
1039 , task.src.options.c_str()
1040 , name.c_str()
1041 , log.c_str());
mtkleinb3b13b72016-03-07 13:20:52 -08001042 }
mtklein748ca3b2015-01-15 10:56:12 -08001043 if (!err.isEmpty()) {
mtklein4089ef72015-03-05 08:40:28 -08001044 if (err.isFatal()) {
djsollen54416de2015-04-03 07:24:48 -07001045 fail(SkStringPrintf("%s %s %s %s: %s",
mtklein21eaf3b2016-02-08 12:39:59 -08001046 task.sink.tag.c_str(),
1047 task.src.tag.c_str(),
1048 task.src.options.c_str(),
mtklein4089ef72015-03-05 08:40:28 -08001049 name.c_str(),
1050 err.c_str()));
mtkleinb37cb412015-03-18 05:27:14 -07001051 } else {
mtklein3eed7dd2016-02-24 19:07:07 -08001052 done(task.sink.tag.c_str(), task.src.tag.c_str(),
1053 task.src.options.c_str(), name.c_str());
mtkleinba6ada72016-01-21 09:39:35 -08001054 return;
mtklein4089ef72015-03-05 08:40:28 -08001055 }
mtklein748ca3b2015-01-15 10:56:12 -08001056 }
mtklein62bd1a62015-01-27 14:46:26 -08001057
mtkleincd50bca2016-01-05 06:20:20 -08001058 // We're likely switching threads here, so we must capture by value, [=] or [foo,bar].
1059 SkStreamAsset* data = stream.detachAsStream();
1060 gDefinitelyThreadSafeWork.add([task,name,bitmap,data]{
1061 SkAutoTDelete<SkStreamAsset> ownedData(data);
1062
1063 // Why doesn't the copy constructor do this when we have pre-locked pixels?
1064 bitmap.lockPixels();
1065
1066 SkString md5;
1067 if (!FLAGS_writePath.isEmpty() || !FLAGS_readPath.isEmpty()) {
1068 SkMD5 hash;
1069 if (data->getLength()) {
1070 hash.writeStream(data, data->getLength());
1071 data->rewind();
mtklein38408462015-07-08 07:25:27 -07001072 } else {
mtkleincd50bca2016-01-05 06:20:20 -08001073 // If we're BGRA (Linux, Windows), swizzle over to RGBA (Mac, Android).
1074 // This helps eliminate multiple 0-pixel-diff hashes on gold.skia.org.
1075 // (Android's general slow speed breaks the tie arbitrarily in RGBA's favor.)
1076 // We might consider promoting 565 to RGBA too.
1077 if (bitmap.colorType() == kBGRA_8888_SkColorType) {
1078 SkBitmap swizzle;
1079 SkAssertResult(bitmap.copyTo(&swizzle, kRGBA_8888_SkColorType));
1080 hash.write(swizzle.getPixels(), swizzle.getSize());
1081 } else {
1082 hash.write(bitmap.getPixels(), bitmap.getSize());
1083 }
1084 }
1085 SkMD5::Digest digest;
1086 hash.finish(digest);
1087 for (int i = 0; i < 16; i++) {
1088 md5.appendf("%02x", digest.data[i]);
mtklein38408462015-07-08 07:25:27 -07001089 }
mtklein62bd1a62015-01-27 14:46:26 -08001090 }
mtklein62bd1a62015-01-27 14:46:26 -08001091
mtkleincd50bca2016-01-05 06:20:20 -08001092 if (!FLAGS_readPath.isEmpty() &&
mtklein3eed7dd2016-02-24 19:07:07 -08001093 !gGold.contains(Gold(task.sink.tag, task.src.tag,
1094 task.src.options, name, md5))) {
mtkleincd50bca2016-01-05 06:20:20 -08001095 fail(SkStringPrintf("%s not found for %s %s %s %s in %s",
1096 md5.c_str(),
mtklein21eaf3b2016-02-08 12:39:59 -08001097 task.sink.tag.c_str(),
1098 task.src.tag.c_str(),
1099 task.src.options.c_str(),
mtkleincd50bca2016-01-05 06:20:20 -08001100 name.c_str(),
1101 FLAGS_readPath[0]));
mtklein748ca3b2015-01-15 10:56:12 -08001102 }
mtkleincd50bca2016-01-05 06:20:20 -08001103
1104 if (!FLAGS_writePath.isEmpty()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001105 const char* ext = task.sink->fileExtension();
mtkleincd50bca2016-01-05 06:20:20 -08001106 if (data->getLength()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001107 WriteToDisk(task, md5, ext, data, data->getLength(), nullptr);
mtkleincd50bca2016-01-05 06:20:20 -08001108 SkASSERT(bitmap.drawsNothing());
1109 } else if (!bitmap.drawsNothing()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001110 WriteToDisk(task, md5, ext, nullptr, 0, &bitmap);
mtkleincd50bca2016-01-05 06:20:20 -08001111 }
1112 }
1113 });
mtklein748ca3b2015-01-15 10:56:12 -08001114 }
mtklein3eed7dd2016-02-24 19:07:07 -08001115 done(task.sink.tag.c_str(), task.src.tag.c_str(), task.src.options.c_str(), name.c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001116 }
1117
1118 static void WriteToDisk(const Task& task,
mtklein62bd1a62015-01-27 14:46:26 -08001119 SkString md5,
1120 const char* ext,
mtklein748ca3b2015-01-15 10:56:12 -08001121 SkStream* data, size_t len,
mtklein62bd1a62015-01-27 14:46:26 -08001122 const SkBitmap* bitmap) {
mtklein409d4702016-02-29 07:38:01 -08001123 bool gammaCorrect = false;
1124 if (bitmap) {
brianosman898235c2016-04-06 07:38:23 -07001125 gammaCorrect = SkImageInfoIsGammaCorrect(bitmap->info());
mtklein409d4702016-02-29 07:38:01 -08001126 }
1127
mtklein748ca3b2015-01-15 10:56:12 -08001128 JsonWriter::BitmapResult result;
djsollen54416de2015-04-03 07:24:48 -07001129 result.name = task.src->name();
mtklein3eed7dd2016-02-24 19:07:07 -08001130 result.config = task.sink.tag;
djsollen54416de2015-04-03 07:24:48 -07001131 result.sourceType = task.src.tag;
1132 result.sourceOptions = task.src.options;
1133 result.ext = ext;
mtklein409d4702016-02-29 07:38:01 -08001134 result.gammaCorrect = gammaCorrect;
djsollen54416de2015-04-03 07:24:48 -07001135 result.md5 = md5;
mtklein748ca3b2015-01-15 10:56:12 -08001136 JsonWriter::AddBitmapResult(result);
1137
mtkleinb0531a72015-04-07 13:38:48 -07001138 // If an MD5 is uninteresting, we want it noted in the JSON file,
1139 // but don't want to dump it out as a .png (or whatever ext is).
1140 if (gUninterestingHashes.contains(md5)) {
1141 return;
1142 }
1143
mtklein748ca3b2015-01-15 10:56:12 -08001144 const char* dir = FLAGS_writePath[0];
1145 if (0 == strcmp(dir, "@")) { // Needed for iOS.
1146 dir = FLAGS_resourcePath[0];
1147 }
1148 sk_mkdir(dir);
1149
1150 SkString path;
1151 if (FLAGS_nameByHash) {
1152 path = SkOSPath::Join(dir, result.md5.c_str());
1153 path.append(".");
1154 path.append(ext);
1155 if (sk_exists(path.c_str())) {
1156 return; // Content-addressed. If it exists already, we're done.
1157 }
1158 } else {
kkinnunen3e980c32015-12-23 01:33:00 -08001159 path = SkOSPath::Join(dir, task.sink.tag.c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001160 sk_mkdir(path.c_str());
msarett9e707a02015-09-01 14:57:57 -07001161 path = SkOSPath::Join(path.c_str(), task.src.tag.c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001162 sk_mkdir(path.c_str());
msarett9e707a02015-09-01 14:57:57 -07001163 if (strcmp(task.src.options.c_str(), "") != 0) {
1164 path = SkOSPath::Join(path.c_str(), task.src.options.c_str());
djsollen54416de2015-04-03 07:24:48 -07001165 sk_mkdir(path.c_str());
1166 }
mtklein748ca3b2015-01-15 10:56:12 -08001167 path = SkOSPath::Join(path.c_str(), task.src->name().c_str());
1168 path.append(".");
1169 path.append(ext);
1170 }
1171
mtklein748ca3b2015-01-15 10:56:12 -08001172 if (bitmap) {
mtkleina5114d72015-08-24 13:27:01 -07001173 if (!dump_png(*bitmap, path.c_str(), result.md5.c_str())) {
mtklein748ca3b2015-01-15 10:56:12 -08001174 fail(SkStringPrintf("Can't encode PNG to %s.\n", path.c_str()));
1175 return;
1176 }
1177 } else {
mtkleina5114d72015-08-24 13:27:01 -07001178 SkFILEWStream file(path.c_str());
1179 if (!file.isValid()) {
1180 fail(SkStringPrintf("Can't open %s for writing.\n", path.c_str()));
1181 return;
1182 }
mtklein748ca3b2015-01-15 10:56:12 -08001183 if (!file.writeStream(data, len)) {
1184 fail(SkStringPrintf("Can't write to %s.\n", path.c_str()));
1185 return;
1186 }
1187 }
1188 }
1189};
1190
mtklein748ca3b2015-01-15 10:56:12 -08001191/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1192
1193// Unit tests don't fit so well into the Src/Sink model, so we give them special treatment.
1194
mtklein21eaf3b2016-02-08 12:39:59 -08001195static SkTDArray<skiatest::Test> gParallelTests, gSerialTests;
mtklein748ca3b2015-01-15 10:56:12 -08001196
1197static void gather_tests() {
mtklein6c5fed22015-01-20 13:47:23 -08001198 if (!FLAGS_src.contains("tests")) {
mtklein748ca3b2015-01-15 10:56:12 -08001199 return;
1200 }
mtklein6393c062015-04-27 08:45:01 -07001201 for (const skiatest::TestRegistry* r = skiatest::TestRegistry::Head(); r; r = r->next()) {
1202 if (!in_shard()) {
1203 continue;
1204 }
halcanary87f3ba42015-01-20 09:30:20 -08001205 // Despite its name, factory() is returning a reference to
1206 // link-time static const POD data.
1207 const skiatest::Test& test = r->factory();
1208 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, test.name)) {
mtklein748ca3b2015-01-15 10:56:12 -08001209 continue;
1210 }
halcanary87f3ba42015-01-20 09:30:20 -08001211 if (test.needsGpu && gpu_supported()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001212 (FLAGS_gpu_threading ? gParallelTests : gSerialTests).push(test);
halcanary87f3ba42015-01-20 09:30:20 -08001213 } else if (!test.needsGpu && FLAGS_cpu) {
mtklein21eaf3b2016-02-08 12:39:59 -08001214 gParallelTests.push(test);
mtklein82d28432015-01-15 12:46:02 -08001215 }
mtklein748ca3b2015-01-15 10:56:12 -08001216 }
1217}
1218
mtklein21eaf3b2016-02-08 12:39:59 -08001219static void run_test(skiatest::Test test) {
halcanary87f3ba42015-01-20 09:30:20 -08001220 struct : public skiatest::Reporter {
mtklein36352bf2015-03-25 18:17:31 -07001221 void reportFailed(const skiatest::Failure& failure) override {
halcanary87f3ba42015-01-20 09:30:20 -08001222 fail(failure.toString());
1223 JsonWriter::AddTestFailure(failure);
1224 }
mtklein36352bf2015-03-25 18:17:31 -07001225 bool allowExtendedTest() const override {
halcanary87f3ba42015-01-20 09:30:20 -08001226 return FLAGS_pathOpsExtended;
1227 }
mtklein36352bf2015-03-25 18:17:31 -07001228 bool verbose() const override { return FLAGS_veryVerbose; }
halcanary87f3ba42015-01-20 09:30:20 -08001229 } reporter;
djsollen824996a2015-06-12 12:06:22 -07001230
mtklein3eed7dd2016-02-24 19:07:07 -08001231 if (!FLAGS_dryRun && !is_blacklisted("_", "tests", "_", test.name)) {
mtklein21eaf3b2016-02-08 12:39:59 -08001232 start("unit", "test", "", test.name);
mtklein55e88b22015-01-21 15:50:13 -08001233 GrContextFactory factory;
mtklein21eaf3b2016-02-08 12:39:59 -08001234 test.proc(&reporter, &factory);
mtklein748ca3b2015-01-15 10:56:12 -08001235 }
mtklein3eed7dd2016-02-24 19:07:07 -08001236 done("unit", "test", "", test.name);
mtklein748ca3b2015-01-15 10:56:12 -08001237}
1238
1239/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1240
mtkleinafae30a2016-02-24 12:28:32 -08001241DEFINE_int32(status_sec, 15, "Print status this often (and if we crash).");
1242
1243SkThread* start_status_thread() {
1244 auto thread = new SkThread([] (void*) {
1245 for (;;) {
1246 print_status();
1247 #if defined(SK_BUILD_FOR_WIN)
1248 Sleep(FLAGS_status_sec * 1000);
1249 #else
1250 sleep(FLAGS_status_sec);
1251 #endif
mtklein2e1c47e2015-03-12 07:16:56 -07001252 }
mtkleinafae30a2016-02-24 12:28:32 -08001253 });
1254 thread->start();
1255 return thread;
mtkleinde6fc2b2015-03-12 06:28:54 -07001256}
1257
caryclark83ca6282015-06-10 09:31:09 -07001258#define PORTABLE_FONT_PREFIX "Toy Liberation "
1259
1260static SkTypeface* create_from_name(const char familyName[], SkTypeface::Style style) {
1261 if (familyName && strlen(familyName) > sizeof(PORTABLE_FONT_PREFIX)
1262 && !strncmp(familyName, PORTABLE_FONT_PREFIX, sizeof(PORTABLE_FONT_PREFIX) - 1)) {
caryclark1818acb2015-07-24 12:09:25 -07001263 return sk_tool_utils::create_portable_typeface(familyName, style);
caryclark83ca6282015-06-10 09:31:09 -07001264 }
halcanary96fcdcc2015-08-27 07:41:13 -07001265 return nullptr;
caryclark83ca6282015-06-10 09:31:09 -07001266}
1267
1268#undef PORTABLE_FONT_PREFIX
1269
1270extern SkTypeface* (*gCreateTypefaceDelegate)(const char [], SkTypeface::Style );
1271
jcgregorio3b27ade2014-11-13 08:06:40 -08001272int dm_main();
caryclark17f0b6d2014-07-22 10:15:34 -07001273int dm_main() {
mtklein246ba3a2016-02-23 10:39:36 -08001274 setup_crash_handler();
mtkleinafae30a2016-02-24 12:28:32 -08001275
mtkleina483da32016-03-17 12:53:36 -07001276 if (FLAGS_verbose) {
1277 gVLog = stderr;
1278 } else if (!FLAGS_writePath.isEmpty()) {
mtklein51c8cfc2016-03-11 12:59:09 -08001279 sk_mkdir(FLAGS_writePath[0]);
1280 gVLog = freopen(SkOSPath::Join(FLAGS_writePath[0], "verbose.log").c_str(), "w", stderr);
mtkleinc41fd922016-03-08 09:01:39 -08001281 }
1282
mtklein5286f022016-01-22 08:18:14 -08001283 JsonWriter::DumpJson(); // It's handy for the bots to assume this is ~never missing.
commit-bot@chromium.org39e8d932014-05-29 20:14:48 +00001284 SkAutoGraphics ag;
mtklein406654b2014-09-03 15:34:37 -07001285 SkTaskGroup::Enabler enabled(FLAGS_threads);
caryclark83ca6282015-06-10 09:31:09 -07001286 gCreateTypefaceDelegate = &create_from_name;
commit-bot@chromium.orga65e2fd2014-05-30 17:23:31 +00001287
halcanary7d571242016-02-24 17:59:16 -08001288 {
1289 SkString testResourcePath = GetResourcePath("color_wheel.png");
1290 SkFILEStream testResource(testResourcePath.c_str());
1291 if (!testResource.isValid()) {
mtkleinc41fd922016-03-08 09:01:39 -08001292 info("Some resources are missing. Do you need to set --resourcePath?\n");
halcanary7d571242016-02-24 17:59:16 -08001293 }
1294 }
mtklein62bd1a62015-01-27 14:46:26 -08001295 gather_gold();
borenet09ed4802015-04-03 14:15:33 -07001296 gather_uninteresting_hashes();
mtklein62bd1a62015-01-27 14:46:26 -08001297
scroggo86737142016-02-03 12:19:11 -08001298 if (!gather_srcs()) {
1299 return 1;
1300 }
mtklein748ca3b2015-01-15 10:56:12 -08001301 gather_sinks();
1302 gather_tests();
mtklein21eaf3b2016-02-08 12:39:59 -08001303 gPending = gSrcs.count() * gSinks.count() + gParallelTests.count() + gSerialTests.count();
mtkleinc41fd922016-03-08 09:01:39 -08001304 info("%d srcs * %d sinks + %d tests == %d tasks",
1305 gSrcs.count(), gSinks.count(), gParallelTests.count() + gSerialTests.count(), gPending);
mtkleinafae30a2016-02-24 12:28:32 -08001306 SkAutoTDelete<SkThread> statusThread(start_status_thread());
mtklein748ca3b2015-01-15 10:56:12 -08001307
mtklein21eaf3b2016-02-08 12:39:59 -08001308 // Kick off as much parallel work as we can, making note of any serial work we'll need to do.
1309 SkTaskGroup parallel;
1310 SkTArray<Task> serial;
1311
1312 for (auto& sink : gSinks)
1313 for (auto& src : gSrcs) {
mtklein3eed7dd2016-02-24 19:07:07 -08001314 if (src->veto(sink->flags()) ||
1315 is_blacklisted(sink.tag.c_str(), src.tag.c_str(),
1316 src.options.c_str(), src->name().c_str())) {
mtklein15923c92016-02-29 10:14:38 -08001317 SkAutoTAcquire<SkSpinlock> lock(gMutex);
mtklein3eed7dd2016-02-24 19:07:07 -08001318 gPending--;
1319 continue;
1320 }
1321
mtklein21eaf3b2016-02-08 12:39:59 -08001322 Task task(src, sink);
1323 if (src->serial() || sink->serial()) {
1324 serial.push_back(task);
1325 } else {
1326 parallel.add([task] { Task::Run(task); });
mtklein748ca3b2015-01-15 10:56:12 -08001327 }
commit-bot@chromium.org38aeb0f2014-02-26 23:01:57 +00001328 }
mtklein21eaf3b2016-02-08 12:39:59 -08001329 for (auto test : gParallelTests) {
1330 parallel.add([test] { run_test(test); });
mtklein55e88b22015-01-21 15:50:13 -08001331 }
mtklein21eaf3b2016-02-08 12:39:59 -08001332
1333 // With the parallel work running, run serial tasks and tests here on main thread.
1334 for (auto task : serial) { Task::Run(task); }
1335 for (auto test : gSerialTests) { run_test(test); }
1336
1337 // Wait for any remaining parallel work to complete (including any spun off of serial tasks).
1338 parallel.wait();
mtkleincd50bca2016-01-05 06:20:20 -08001339 gDefinitelyThreadSafeWork.wait();
1340
mtkleinda884c42016-02-24 18:00:23 -08001341 // We'd better have run everything.
1342 SkASSERT(gPending == 0);
mtkleine027f172016-02-26 15:53:06 -08001343 // Make sure we've flushed all our results to disk.
1344 JsonWriter::DumpJson();
mtkleinda884c42016-02-24 18:00:23 -08001345
mtklein748ca3b2015-01-15 10:56:12 -08001346 // At this point we're back in single-threaded land.
caryclarkf53ce802015-06-15 06:48:30 -07001347 sk_tool_utils::release_portable_typefaces();
mtklein@google.comd36522d2013-10-16 13:02:15 +00001348
mtklein748ca3b2015-01-15 10:56:12 -08001349 if (gFailures.count() > 0) {
mtkleinc41fd922016-03-08 09:01:39 -08001350 info("Failures:\n");
mtklein748ca3b2015-01-15 10:56:12 -08001351 for (int i = 0; i < gFailures.count(); i++) {
mtkleinc41fd922016-03-08 09:01:39 -08001352 info("\t%s\n", gFailures[i].c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001353 }
mtkleinc41fd922016-03-08 09:01:39 -08001354 info("%d failures\n", gFailures.count());
mtklein748ca3b2015-01-15 10:56:12 -08001355 return 1;
mtklein114c3cd2015-01-15 10:15:02 -08001356 }
mtkleinafae30a2016-02-24 12:28:32 -08001357
1358#ifdef SK_PDF_IMAGE_STATS
halcanary7a14b312015-10-01 07:28:13 -07001359 SkPDFImageDumpStats();
mtkleinafae30a2016-02-24 12:28:32 -08001360#endif // SK_PDF_IMAGE_STATS
1361
1362 print_status();
mtkleinc41fd922016-03-08 09:01:39 -08001363 info("Finished!\n");
mtklein748ca3b2015-01-15 10:56:12 -08001364 return 0;
mtklein@google.comd36522d2013-10-16 13:02:15 +00001365}
jcgregorio3b27ade2014-11-13 08:06:40 -08001366
kkinnunen179a8f52015-11-20 13:32:24 -08001367// TODO: currently many GPU tests are declared outside SK_SUPPORT_GPU guards.
1368// Thus we export the empty RunWithGPUTestContexts when SK_SUPPORT_GPU=0.
1369namespace skiatest {
bsalomon758586c2016-04-06 14:02:39 -07001370
1371#if SK_SUPPORT_GPU
1372bool IsGLContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1373 return kOpenGL_GrBackend == GrContextFactory::ContextTypeBackend(type);
1374}
bsalomondc0fcd42016-04-11 14:21:33 -07001375bool IsVulkanContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1376 return kVulkan_GrBackend == GrContextFactory::ContextTypeBackend(type);
1377}
bsalomon758586c2016-04-06 14:02:39 -07001378bool IsRenderingGLContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1379 return IsGLContextType(type) && GrContextFactory::IsRenderingContext(type);
1380}
1381bool IsNullGLContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1382 return type == GrContextFactory::kNullGL_ContextType;
1383}
1384#else
1385bool IsGLContextType(int) { return false; }
bsalomondc0fcd42016-04-11 14:21:33 -07001386bool IsVulkanContextType(int) { return false; }
bsalomon758586c2016-04-06 14:02:39 -07001387bool IsRenderingGLContextType(int) { return false; }
1388bool IsNullGLContextType(int) { return false; }
1389#endif
1390
1391void RunWithGPUTestContexts(GrContextTestFn* test, GrContextTypeFilterFn* contextTypeFilter,
bsalomonf2f1c172016-04-05 12:59:06 -07001392 Reporter* reporter, GrContextFactory* factory) {
kkinnunen179a8f52015-11-20 13:32:24 -08001393#if SK_SUPPORT_GPU
kkinnunen3e980c32015-12-23 01:33:00 -08001394
bsalomon758586c2016-04-06 14:02:39 -07001395 for (int typeInt = 0; typeInt < GrContextFactory::kContextTypeCnt; ++typeInt) {
1396 GrContextFactory::ContextType contextType = (GrContextFactory::ContextType) typeInt;
1397 ContextInfo ctxInfo = factory->getContextInfo(contextType);
bsalomonfda88072016-04-11 14:40:50 -07001398 if (contextTypeFilter && !(*contextTypeFilter)(contextType)) {
kkinnunen179a8f52015-11-20 13:32:24 -08001399 continue;
1400 }
bsalomon758586c2016-04-06 14:02:39 -07001401 // Use "native" instead of explicitly trying OpenGL and OpenGL ES. Do not use GLES on,
1402 // desktop since tests do not account for not fixing http://skbug.com/2809
1403 if (contextType == GrContextFactory::kGL_ContextType ||
1404 contextType == GrContextFactory::kGLES_ContextType) {
1405 if (contextType != GrContextFactory::kNativeGL_ContextType) {
1406 continue;
1407 }
1408 }
bsalomonf2f1c172016-04-05 12:59:06 -07001409 if (ctxInfo.fGrContext) {
1410 (*test)(reporter, ctxInfo);
kkinnunen5219fd92015-12-10 06:28:13 -08001411 }
bsalomonf2f1c172016-04-05 12:59:06 -07001412 ctxInfo = factory->getContextInfo(contextType,
bsalomon85b4b532016-04-05 11:06:27 -07001413 GrContextFactory::kEnableNVPR_ContextOptions);
bsalomonf2f1c172016-04-05 12:59:06 -07001414 if (ctxInfo.fGrContext) {
1415 (*test)(reporter, ctxInfo);
kkinnunen179a8f52015-11-20 13:32:24 -08001416 }
1417 }
1418#endif
1419}
kkinnunen179a8f52015-11-20 13:32:24 -08001420} // namespace skiatest
1421
borenet48087572015-04-02 12:16:36 -07001422#if !defined(SK_BUILD_FOR_IOS)
jcgregorio3b27ade2014-11-13 08:06:40 -08001423int main(int argc, char** argv) {
1424 SkCommandLineFlags::Parse(argc, argv);
1425 return dm_main();
1426}
1427#endif