blob: ad796821a4a27d6da1756f384954cb8e2150de74 [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
mtklein748ca3b2015-01-15 10:56:12 -08008#include "DMJsonWriter.h"
9#include "DMSrcSink.h"
mtklein748ca3b2015-01-15 10:56:12 -080010#include "ProcStats.h"
halcanary7d571242016-02-24 17:59:16 -080011#include "Resources.h"
mtklein748ca3b2015-01-15 10:56:12 -080012#include "SkBBHFactory.h"
mtklein62bd1a62015-01-27 14:46:26 -080013#include "SkChecksum.h"
scroggocc2feb12015-08-14 08:32:46 -070014#include "SkCodec.h"
mtklein27c3fdd2016-02-26 14:43:21 -080015#include "SkColorPriv.h"
msarett888dc162016-05-23 10:21:17 -070016#include "SkColorSpace.h"
Mike Klein919cc452017-03-18 15:36:52 +000017#include "SkColorSpacePriv.h"
caryclark17f0b6d2014-07-22 10:15:34 -070018#include "SkCommonFlags.h"
kkinnunen3e980c32015-12-23 01:33:00 -080019#include "SkCommonFlagsConfig.h"
csmartdalton008b9d82017-02-22 12:00:42 -070020#include "SkCommonFlagsPathRenderer.h"
brianosman3c579dc2016-04-19 09:18:11 -070021#include "SkData.h"
caryclark83ca6282015-06-10 09:31:09 -070022#include "SkFontMgr.h"
mtklein@google.comd36522d2013-10-16 13:02:15 +000023#include "SkGraphics.h"
mtklein27c3fdd2016-02-26 14:43:21 -080024#include "SkHalf.h"
halcanary4dbbd042016-06-07 17:21:10 -070025#include "SkLeanWindows.h"
mtklein748ca3b2015-01-15 10:56:12 -080026#include "SkMD5.h"
mtklein1b249332015-07-07 12:21:21 -070027#include "SkMutex.h"
mtklein1d0f1642014-09-08 08:05:18 -070028#include "SkOSFile.h"
Ben Wagnerbf111d72016-11-07 18:05:29 -050029#include "SkOSPath.h"
mtklein27c3fdd2016-02-26 14:43:21 -080030#include "SkPM4fPriv.h"
Mike Klein13b6afd2017-06-12 12:45:41 -040031#include "SkPngEncoder.h"
mtklein246ba3a2016-02-23 10:39:36 -080032#include "SkSpinlock.h"
mtkleina82f5622015-02-20 12:30:19 -080033#include "SkTHash.h"
mtklein406654b2014-09-03 15:34:37 -070034#include "SkTaskGroup.h"
mtkleinde6fc2b2015-03-12 06:28:54 -070035#include "SkThreadUtils.h"
commit-bot@chromium.org0dc5bd12014-02-26 16:31:22 +000036#include "Test.h"
mtklein748ca3b2015-01-15 10:56:12 -080037#include "Timer.h"
Mike Kleinadacaef2017-02-06 09:26:14 -050038#include "ios_utils.h"
brianosman3c579dc2016-04-19 09:18:11 -070039#include "picture_utils.h"
caryclark83ca6282015-06-10 09:31:09 -070040#include "sk_tool_utils.h"
liyuqian38911a72016-10-04 11:23:22 -070041#include "SkScan.h"
mtklein@google.comd36522d2013-10-16 13:02:15 +000042
scroggo19b91532016-10-24 09:03:26 -070043#include <vector>
44
halcanary7a14b312015-10-01 07:28:13 -070045#ifdef SK_PDF_IMAGE_STATS
46extern void SkPDFImageDumpStats();
47#endif
48
mtkleina5114d72015-08-24 13:27:01 -070049#include "png.h"
50
bungeman60e0fee2015-08-26 05:15:46 -070051#include <stdlib.h>
52
scroggo27a58342015-10-28 08:56:41 -070053#ifndef SK_BUILD_FOR_WIN32
54 #include <unistd.h>
55#endif
56
djsollen54416de2015-04-03 07:24:48 -070057DEFINE_string(src, "tests gm skp image", "Source types to test.");
mtklein748ca3b2015-01-15 10:56:12 -080058DEFINE_bool(nameByHash, false,
59 "If true, write to FLAGS_writePath[0]/<hash>.png instead of "
djsollen54416de2015-04-03 07:24:48 -070060 "to FLAGS_writePath[0]/<config>/<sourceType>/<sourceOptions>/<name>.png");
mtklein748ca3b2015-01-15 10:56:12 -080061DEFINE_bool2(pathOpsExtended, x, false, "Run extended pathOps tests.");
mtkleind603b222015-02-17 11:13:33 -080062DEFINE_string(matrix, "1 0 0 1",
63 "2x2 scale+skew matrix to apply or upright when using "
64 "'matrix' or 'upright' in config.");
mtklein82d28432015-01-15 12:46:02 -080065DEFINE_bool(gpu_threading, false, "Allow GPU work to run on multiple threads?");
mtklein@google.comd36522d2013-10-16 13:02:15 +000066
mtkleina2ef6422015-01-15 13:44:22 -080067DEFINE_string(blacklist, "",
djsollen54416de2015-04-03 07:24:48 -070068 "Space-separated config/src/srcOptions/name quadruples to blacklist. '_' matches anything. E.g. \n"
69 "'--blacklist gpu skp _ _' will blacklist all SKPs drawn into the gpu config.\n"
70 "'--blacklist gpu skp _ _ 8888 gm _ aarects' will also blacklist the aarects GM on 8888.");
mtkleina2ef6422015-01-15 13:44:22 -080071
mtklein62bd1a62015-01-27 14:46:26 -080072DEFINE_string2(readPath, r, "", "If set check for equality with golden results in this directory.");
73
borenet09ed4802015-04-03 14:15:33 -070074DEFINE_string(uninterestingHashesFile, "",
75 "File containing a list of uninteresting hashes. If a result hashes to something in "
76 "this list, no image is written for that result.");
77
mtklein6393c062015-04-27 08:45:01 -070078DEFINE_int32(shards, 1, "We're splitting source data into this many shards.");
79DEFINE_int32(shard, 0, "Which shard do I run?");
80
halcanary45420a92016-06-02 12:41:14 -070081DEFINE_string(mskps, "", "Directory to read mskps from, or a single mskp file.");
82
csmartdalton008b9d82017-02-22 12:00:42 -070083#if SK_SUPPORT_GPU
84DEFINE_pathrenderer_flag;
85#endif
86
mtklein748ca3b2015-01-15 10:56:12 -080087using namespace DM;
bsalomon3724e572016-03-30 18:56:19 -070088using sk_gpu_test::GrContextFactory;
bsalomon273c0f52016-03-31 10:59:06 -070089using sk_gpu_test::GLTestContext;
bsalomonf2f1c172016-04-05 12:59:06 -070090using sk_gpu_test::ContextInfo;
mtklein@google.comd36522d2013-10-16 13:02:15 +000091
mtklein748ca3b2015-01-15 10:56:12 -080092/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
93
benjaminwagnerec4d4d72016-03-25 12:59:53 -070094static const double kStartMs = SkTime::GetMSecs();
mtkleinc41fd922016-03-08 09:01:39 -080095
96static FILE* gVLog;
97
98template <typename... Args>
99static void vlog(const char* fmt, Args&&... args) {
100 if (gVLog) {
101 fprintf(gVLog, "%s\t", HumanizeMs(SkTime::GetMSecs() - kStartMs).c_str());
102 fprintf(gVLog, fmt, args...);
103 fflush(gVLog);
104 }
105}
106
107template <typename... Args>
108static void info(const char* fmt, Args&&... args) {
109 vlog(fmt, args...);
110 if (!FLAGS_quiet) {
111 printf(fmt, args...);
112 }
113}
114static void info(const char* fmt) {
115 if (!FLAGS_quiet) {
116 printf("%s", fmt); // Clang warns printf(fmt) is insecure.
117 }
118}
119
reed086eea92016-05-04 17:12:46 -0700120SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
mtklein748ca3b2015-01-15 10:56:12 -0800121static SkTArray<SkString> gFailures;
122
mtklein3eed7dd2016-02-24 19:07:07 -0800123static void fail(const SkString& err) {
mtklein748ca3b2015-01-15 10:56:12 -0800124 SkAutoMutexAcquire lock(gFailuresMutex);
125 SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
126 gFailures.push_back(err);
halcanary9e398f72015-01-10 11:18:04 -0800127}
128
mtklein0f7748a2016-07-25 15:27:29 -0700129struct Running {
130 SkString id;
131 SkThreadID thread;
132
133 void dump() const {
134 info("\t%s\n", id.c_str());
135 }
136};
mtkleinb37cb412015-03-18 05:27:14 -0700137
mtklein246ba3a2016-02-23 10:39:36 -0800138// We use a spinlock to make locking this in a signal handler _somewhat_ safe.
Mike Klein03a95ad2017-06-23 12:36:32 -0400139static SkSpinlock gMutex;
140static int gPending;
mtklein0f7748a2016-07-25 15:27:29 -0700141static SkTArray<Running> gRunning;
mtklein748ca3b2015-01-15 10:56:12 -0800142
mtklein3eed7dd2016-02-24 19:07:07 -0800143static void done(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("done %s\n", id.c_str());
mtkleinafae30a2016-02-24 12:28:32 -0800146 int pending;
mtkleinb37cb412015-03-18 05:27:14 -0700147 {
mtkleinf10637f2016-06-10 13:56:35 -0700148 SkAutoMutexAcquire lock(gMutex);
mtkleinb37cb412015-03-18 05:27:14 -0700149 for (int i = 0; i < gRunning.count(); i++) {
mtklein0f7748a2016-07-25 15:27:29 -0700150 if (gRunning[i].id == id) {
mtkleinb37cb412015-03-18 05:27:14 -0700151 gRunning.removeShuffle(i);
152 break;
153 }
154 }
mtkleinafae30a2016-02-24 12:28:32 -0800155 pending = --gPending;
reed50bc0512015-05-19 14:13:31 -0700156 }
Mike Klein03a95ad2017-06-23 12:36:32 -0400157
158 // We write out dm.json file and print out a progress update every once in a while.
159 // Notice this also handles the final dm.json and progress update when pending == 0.
mtkleina17241b2015-01-23 05:48:00 -0800160 if (pending % 500 == 0) {
161 JsonWriter::DumpJson();
Mike Klein03a95ad2017-06-23 12:36:32 -0400162
163 int curr = sk_tools::getCurrResidentSetSizeMB(),
164 peak = sk_tools::getMaxResidentSetSizeMB();
165 SkString elapsed = HumanizeMs(SkTime::GetMSecs() - kStartMs);
166
167 SkAutoMutexAcquire lock(gMutex);
168 info("\n%dMB RAM, %dMB peak, %s elapsed, %d queued, %d active:\n",
169 curr, peak, elapsed.c_str(), gPending - gRunning.count(), gRunning.count());
170 for (auto& task : gRunning) {
171 task.dump();
172 }
mtkleina17241b2015-01-23 05:48:00 -0800173 }
mtklein@google.comd36522d2013-10-16 13:02:15 +0000174}
175
mtklein3eed7dd2016-02-24 19:07:07 -0800176static void start(const char* config, const char* src, const char* srcOptions, const char* name) {
177 SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
mtkleinc41fd922016-03-08 09:01:39 -0800178 vlog("start %s\n", id.c_str());
mtkleinf10637f2016-06-10 13:56:35 -0700179 SkAutoMutexAcquire lock(gMutex);
mtklein0f7748a2016-07-25 15:27:29 -0700180 gRunning.push_back({id,SkGetThreadID()});
mtkleinb37cb412015-03-18 05:27:14 -0700181}
182
Mike Klein3cc2d202016-10-24 11:39:43 -0400183static void find_culprit() {
184 // Assumes gMutex is locked.
185 SkThreadID thisThread = SkGetThreadID();
186 for (auto& task : gRunning) {
187 if (task.thread == thisThread) {
188 info("Likely culprit:\n");
189 task.dump();
mtklein0f7748a2016-07-25 15:27:29 -0700190 }
191 }
Mike Klein3cc2d202016-10-24 11:39:43 -0400192}
mtklein0f7748a2016-07-25 15:27:29 -0700193
mtklein246ba3a2016-02-23 10:39:36 -0800194#if defined(SK_BUILD_FOR_WIN32)
mtklein5b64dab2016-06-09 08:59:48 -0700195 static LONG WINAPI crash_handler(EXCEPTION_POINTERS* e) {
mtkleinf8557292016-02-29 06:35:28 -0800196 static const struct {
197 const char* name;
robertphillips75467862016-03-01 14:10:23 -0800198 DWORD code;
mtkleinf8557292016-02-29 06:35:28 -0800199 } kExceptions[] = {
200 #define _(E) {#E, E}
201 _(EXCEPTION_ACCESS_VIOLATION),
202 _(EXCEPTION_BREAKPOINT),
203 _(EXCEPTION_INT_DIVIDE_BY_ZERO),
204 _(EXCEPTION_STACK_OVERFLOW),
205 // TODO: more?
206 #undef _
207 };
208
mtkleinf10637f2016-06-10 13:56:35 -0700209 SkAutoMutexAcquire lock(gMutex);
mtklein5b64dab2016-06-09 08:59:48 -0700210
211 const DWORD code = e->ExceptionRecord->ExceptionCode;
212 info("\nCaught exception %u", code);
213 for (const auto& exception : kExceptions) {
214 if (exception.code == code) {
215 info(" %s", exception.name);
mtkleinf8557292016-02-29 06:35:28 -0800216 }
mtkleinf8557292016-02-29 06:35:28 -0800217 }
mtklein5b64dab2016-06-09 08:59:48 -0700218 info(", was running:\n");
219 for (auto& task : gRunning) {
mtklein0f7748a2016-07-25 15:27:29 -0700220 task.dump();
mtklein5b64dab2016-06-09 08:59:48 -0700221 }
mtklein0f7748a2016-07-25 15:27:29 -0700222 find_culprit();
mtklein5b64dab2016-06-09 08:59:48 -0700223 fflush(stdout);
224
mtkleinf8557292016-02-29 06:35:28 -0800225 // Execute default exception handler... hopefully, exit.
226 return EXCEPTION_EXECUTE_HANDLER;
mtklein246ba3a2016-02-23 10:39:36 -0800227 }
228
Mike Klein3cc2d202016-10-24 11:39:43 -0400229 static void setup_crash_handler() {
230 SetUnhandledExceptionFilter(crash_handler);
231 }
232#else
mtklein246ba3a2016-02-23 10:39:36 -0800233 #include <signal.h>
Mike Klein3cc2d202016-10-24 11:39:43 -0400234 #if !defined(SK_BUILD_FOR_ANDROID)
235 #include <execinfo.h>
236 #endif
237
238 static constexpr int max_of() { return 0; }
239 template <typename... Rest>
240 static constexpr int max_of(int x, Rest... rest) {
241 return x > max_of(rest...) ? x : max_of(rest...);
242 }
243
244 static void (*previous_handler[max_of(SIGABRT,SIGBUS,SIGFPE,SIGILL,SIGSEGV)+1])(int);
mtkleinf8557292016-02-29 06:35:28 -0800245
mtklein5b64dab2016-06-09 08:59:48 -0700246 static void crash_handler(int sig) {
mtkleinf10637f2016-06-10 13:56:35 -0700247 SkAutoMutexAcquire lock(gMutex);
mtklein5b64dab2016-06-09 08:59:48 -0700248
249 info("\nCaught signal %d [%s], was running:\n", sig, strsignal(sig));
250 for (auto& task : gRunning) {
mtklein0f7748a2016-07-25 15:27:29 -0700251 task.dump();
mtklein5b64dab2016-06-09 08:59:48 -0700252 }
mtklein0f7748a2016-07-25 15:27:29 -0700253 find_culprit();
mtklein5b64dab2016-06-09 08:59:48 -0700254
Mike Klein3cc2d202016-10-24 11:39:43 -0400255 #if !defined(SK_BUILD_FOR_ANDROID)
mtklein5b64dab2016-06-09 08:59:48 -0700256 void* stack[64];
257 int count = backtrace(stack, SK_ARRAY_COUNT(stack));
258 char** symbols = backtrace_symbols(stack, count);
259 info("\nStack trace:\n");
260 for (int i = 0; i < count; i++) {
261 info(" %s\n", symbols[i]);
262 }
Mike Klein3cc2d202016-10-24 11:39:43 -0400263 #endif
mtklein5b64dab2016-06-09 08:59:48 -0700264 fflush(stdout);
265
Mike Klein3cc2d202016-10-24 11:39:43 -0400266 signal(sig, previous_handler[sig]);
267 raise(sig);
mtklein5b64dab2016-06-09 08:59:48 -0700268 }
269
mtklein246ba3a2016-02-23 10:39:36 -0800270 static void setup_crash_handler() {
271 const int kSignals[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV };
272 for (int sig : kSignals) {
Mike Klein3cc2d202016-10-24 11:39:43 -0400273 previous_handler[sig] = signal(sig, crash_handler);
mtklein246ba3a2016-02-23 10:39:36 -0800274 }
275 }
276#endif
277
mtklein748ca3b2015-01-15 10:56:12 -0800278/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
mtklein114c3cd2015-01-15 10:15:02 -0800279
mtklein62bd1a62015-01-27 14:46:26 -0800280struct Gold : public SkString {
mtkleina82f5622015-02-20 12:30:19 -0800281 Gold() : SkString("") {}
mtklein3eed7dd2016-02-24 19:07:07 -0800282 Gold(const SkString& sink, const SkString& src,
283 const SkString& srcOptions, const SkString& name,
284 const SkString& md5)
mtklein62bd1a62015-01-27 14:46:26 -0800285 : SkString("") {
286 this->append(sink);
287 this->append(src);
djsollen54416de2015-04-03 07:24:48 -0700288 this->append(srcOptions);
mtklein62bd1a62015-01-27 14:46:26 -0800289 this->append(name);
290 this->append(md5);
mtklein62bd1a62015-01-27 14:46:26 -0800291 }
mtkleinc8d1dd42015-10-15 12:23:01 -0700292 struct Hash {
293 uint32_t operator()(const Gold& g) const {
294 return SkGoodHash()((const SkString&)g);
295 }
296 };
mtklein62bd1a62015-01-27 14:46:26 -0800297};
mtkleina82f5622015-02-20 12:30:19 -0800298static SkTHashSet<Gold, Gold::Hash> gGold;
mtklein62bd1a62015-01-27 14:46:26 -0800299
300static void add_gold(JsonWriter::BitmapResult r) {
djsollen54416de2015-04-03 07:24:48 -0700301 gGold.add(Gold(r.config, r.sourceType, r.sourceOptions, r.name, r.md5));
mtklein62bd1a62015-01-27 14:46:26 -0800302}
303
304static void gather_gold() {
305 if (!FLAGS_readPath.isEmpty()) {
306 SkString path(FLAGS_readPath[0]);
307 path.append("/dm.json");
308 if (!JsonWriter::ReadJson(path.c_str(), add_gold)) {
309 fail(SkStringPrintf("Couldn't read %s for golden results.", path.c_str()));
310 }
311 }
312}
313
314/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
315
mtklein935f1b12016-03-16 08:37:19 -0700316#if defined(SK_BUILD_FOR_WIN32)
317 static const char* kNewline = "\r\n";
318#else
319 static const char* kNewline = "\n";
320#endif
321
borenet09ed4802015-04-03 14:15:33 -0700322static SkTHashSet<SkString> gUninterestingHashes;
323
324static void gather_uninteresting_hashes() {
325 if (!FLAGS_uninterestingHashesFile.isEmpty()) {
bungeman38d909e2016-08-02 14:40:46 -0700326 sk_sp<SkData> data(SkData::MakeFromFileName(FLAGS_uninterestingHashesFile[0]));
mtkleincc334b32015-09-22 11:43:53 -0700327 if (!data) {
mtkleinc41fd922016-03-08 09:01:39 -0800328 info("WARNING: unable to read uninteresting hashes from %s\n",
329 FLAGS_uninterestingHashesFile[0]);
mtkleincc334b32015-09-22 11:43:53 -0700330 return;
331 }
Mike Klein45dcc0c2017-04-05 18:04:31 -0400332
333 // Copy to a string to make sure SkStrSplit has a terminating \0 to find.
334 SkString contents((const char*)data->data(), data->size());
335
borenet09ed4802015-04-03 14:15:33 -0700336 SkTArray<SkString> hashes;
Mike Klein45dcc0c2017-04-05 18:04:31 -0400337 SkStrSplit(contents.c_str(), kNewline, &hashes);
borenet09ed4802015-04-03 14:15:33 -0700338 for (const SkString& hash : hashes) {
339 gUninterestingHashes.add(hash);
340 }
mtkleinc41fd922016-03-08 09:01:39 -0800341 info("FYI: loaded %d distinct uninteresting hashes from %d lines\n",
342 gUninterestingHashes.count(), hashes.count());
borenet09ed4802015-04-03 14:15:33 -0700343 }
344}
345
346/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
347
Ben Wagner145dbcd2016-11-03 14:40:50 -0400348struct TaggedSrc : public std::unique_ptr<Src> {
mtklein3eed7dd2016-02-24 19:07:07 -0800349 SkString tag;
350 SkString options;
mtkleine0effd62015-07-29 06:37:28 -0700351};
352
Ben Wagner145dbcd2016-11-03 14:40:50 -0400353struct TaggedSink : public std::unique_ptr<Sink> {
kkinnunen3e980c32015-12-23 01:33:00 -0800354 SkString tag;
djsollen54416de2015-04-03 07:24:48 -0700355};
mtklein748ca3b2015-01-15 10:56:12 -0800356
357static const bool kMemcpyOK = true;
358
mtkleine0effd62015-07-29 06:37:28 -0700359static SkTArray<TaggedSrc, kMemcpyOK> gSrcs;
360static SkTArray<TaggedSink, kMemcpyOK> gSinks;
mtklein748ca3b2015-01-15 10:56:12 -0800361
mtklein6393c062015-04-27 08:45:01 -0700362static bool in_shard() {
363 static int N = 0;
364 return N++ % FLAGS_shards == FLAGS_shard;
365}
366
mtklein3eed7dd2016-02-24 19:07:07 -0800367static void push_src(const char* tag, ImplicitString options, Src* s) {
Ben Wagner145dbcd2016-11-03 14:40:50 -0400368 std::unique_ptr<Src> src(s);
mtklein6393c062015-04-27 08:45:01 -0700369 if (in_shard() &&
mtklein3eed7dd2016-02-24 19:07:07 -0800370 FLAGS_src.contains(tag) &&
mtklein748ca3b2015-01-15 10:56:12 -0800371 !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
mtkleine0effd62015-07-29 06:37:28 -0700372 TaggedSrc& s = gSrcs.push_back();
mtklein18300a32016-03-16 13:53:35 -0700373 s.reset(src.release());
mtklein748ca3b2015-01-15 10:56:12 -0800374 s.tag = tag;
djsollen54416de2015-04-03 07:24:48 -0700375 s.options = options;
mtklein114c3cd2015-01-15 10:15:02 -0800376 }
mtklein748ca3b2015-01-15 10:56:12 -0800377}
mtklein114c3cd2015-01-15 10:15:02 -0800378
msarett9e707a02015-09-01 14:57:57 -0700379static void push_codec_src(Path path, CodecSrc::Mode mode, CodecSrc::DstColorType dstColorType,
scroggoc5560be2016-02-03 09:42:42 -0800380 SkAlphaType dstAlphaType, float scale) {
scroggoe4499842016-02-25 11:03:47 -0800381 if (FLAGS_simpleCodec) {
scroggo19b91532016-10-24 09:03:26 -0700382 const bool simple = CodecSrc::kCodec_Mode == mode || CodecSrc::kAnimated_Mode == mode;
383 if (!simple || dstColorType != CodecSrc::kGetFromCanvas_DstColorType || scale != 1.0f) {
scroggoe4499842016-02-25 11:03:47 -0800384 // Only decode in the simple case.
385 return;
scroggo19b91532016-10-24 09:03:26 -0700386 }
scroggoe4499842016-02-25 11:03:47 -0800387 }
msarett9e707a02015-09-01 14:57:57 -0700388 SkString folder;
389 switch (mode) {
390 case CodecSrc::kCodec_Mode:
391 folder.append("codec");
392 break;
msarettbb25b532016-01-13 09:31:39 -0800393 case CodecSrc::kCodecZeroInit_Mode:
394 folder.append("codec_zero_init");
395 break;
msarett9e707a02015-09-01 14:57:57 -0700396 case CodecSrc::kScanline_Mode:
397 folder.append("scanline");
398 break;
msarett9e707a02015-09-01 14:57:57 -0700399 case CodecSrc::kStripe_Mode:
400 folder.append("stripe");
401 break;
msarett91c22b22016-02-22 12:27:46 -0800402 case CodecSrc::kCroppedScanline_Mode:
403 folder.append("crop");
404 break;
msarett9e707a02015-09-01 14:57:57 -0700405 case CodecSrc::kSubset_Mode:
msarett36c37962015-09-02 13:20:52 -0700406 folder.append("codec_subset");
msarett9e707a02015-09-01 14:57:57 -0700407 break;
scroggo19b91532016-10-24 09:03:26 -0700408 case CodecSrc::kAnimated_Mode:
409 folder.append("codec_animated");
410 break;
msarett9e707a02015-09-01 14:57:57 -0700411 }
412
413 switch (dstColorType) {
414 case CodecSrc::kGrayscale_Always_DstColorType:
415 folder.append("_kGray8");
416 break;
417 case CodecSrc::kIndex8_Always_DstColorType:
418 folder.append("_kIndex8");
419 break;
msarett34e0ec42016-04-22 16:27:24 -0700420 case CodecSrc::kNonNative8888_Always_DstColorType:
421 folder.append("_kNonNative");
422 break;
msarett9e707a02015-09-01 14:57:57 -0700423 default:
424 break;
425 }
426
scroggoc5560be2016-02-03 09:42:42 -0800427 switch (dstAlphaType) {
scroggoc5560be2016-02-03 09:42:42 -0800428 case kPremul_SkAlphaType:
429 folder.append("_premul");
430 break;
431 case kUnpremul_SkAlphaType:
432 folder.append("_unpremul");
433 break;
434 default:
435 break;
436 }
437
msarett9e707a02015-09-01 14:57:57 -0700438 if (1.0f != scale) {
439 folder.appendf("_%.3f", scale);
440 }
441
scroggoc5560be2016-02-03 09:42:42 -0800442 CodecSrc* src = new CodecSrc(path, mode, dstColorType, dstAlphaType, scale);
msarett9e707a02015-09-01 14:57:57 -0700443 push_src("image", folder, src);
444}
445
scroggof8dc9df2016-05-16 09:04:13 -0700446static void push_android_codec_src(Path path, CodecSrc::DstColorType dstColorType,
447 SkAlphaType dstAlphaType, int sampleSize) {
msarett3d9d7a72015-10-21 10:27:10 -0700448 SkString folder;
scroggof8dc9df2016-05-16 09:04:13 -0700449 folder.append("scaled_codec");
msarett3d9d7a72015-10-21 10:27:10 -0700450
451 switch (dstColorType) {
452 case CodecSrc::kGrayscale_Always_DstColorType:
453 folder.append("_kGray8");
454 break;
455 case CodecSrc::kIndex8_Always_DstColorType:
456 folder.append("_kIndex8");
457 break;
msarett34e0ec42016-04-22 16:27:24 -0700458 case CodecSrc::kNonNative8888_Always_DstColorType:
459 folder.append("_kNonNative");
460 break;
msarett3d9d7a72015-10-21 10:27:10 -0700461 default:
462 break;
463 }
464
scroggoc5560be2016-02-03 09:42:42 -0800465 switch (dstAlphaType) {
scroggoc5560be2016-02-03 09:42:42 -0800466 case kPremul_SkAlphaType:
467 folder.append("_premul");
468 break;
msarett9e9444c2016-02-03 12:39:10 -0800469 case kUnpremul_SkAlphaType:
470 folder.append("_unpremul");
471 break;
scroggoc5560be2016-02-03 09:42:42 -0800472 default:
473 break;
474 }
475
msarett3d9d7a72015-10-21 10:27:10 -0700476 if (1 != sampleSize) {
msarett4b0778e2015-11-13 09:59:11 -0800477 folder.appendf("_%.3f", 1.0f / (float) sampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700478 }
479
scroggof8dc9df2016-05-16 09:04:13 -0700480 AndroidCodecSrc* src = new AndroidCodecSrc(path, dstColorType, dstAlphaType, sampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700481 push_src("image", folder, src);
482}
483
msarett18976312016-03-09 14:20:58 -0800484static void push_image_gen_src(Path path, ImageGenSrc::Mode mode, SkAlphaType alphaType, bool isGpu)
485{
486 SkString folder;
487 switch (mode) {
488 case ImageGenSrc::kCodec_Mode:
489 folder.append("gen_codec");
490 break;
491 case ImageGenSrc::kPlatform_Mode:
492 folder.append("gen_platform");
493 break;
494 }
495
496 if (isGpu) {
497 folder.append("_gpu");
498 } else {
499 switch (alphaType) {
500 case kOpaque_SkAlphaType:
501 folder.append("_opaque");
502 break;
503 case kPremul_SkAlphaType:
504 folder.append("_premul");
505 break;
506 case kUnpremul_SkAlphaType:
507 folder.append("_unpremul");
508 break;
509 default:
510 break;
511 }
512 }
513
514 ImageGenSrc* src = new ImageGenSrc(path, mode, alphaType, isGpu);
515 push_src("image", folder, src);
516}
517
msarett438b2ad2015-04-09 12:43:10 -0700518static void push_codec_srcs(Path path) {
bungeman38d909e2016-08-02 14:40:46 -0700519 sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
msarett438b2ad2015-04-09 12:43:10 -0700520 if (!encoded) {
mtkleinc41fd922016-03-08 09:01:39 -0800521 info("Couldn't read %s.", path.c_str());
msarett438b2ad2015-04-09 12:43:10 -0700522 return;
523 }
Ben Wagner145dbcd2016-11-03 14:40:50 -0400524 std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(encoded));
halcanary96fcdcc2015-08-27 07:41:13 -0700525 if (nullptr == codec.get()) {
mtkleinc41fd922016-03-08 09:01:39 -0800526 info("Couldn't create codec for %s.", path.c_str());
msarett438b2ad2015-04-09 12:43:10 -0700527 return;
528 }
529
scroggo9366aff2016-05-20 08:38:54 -0700530 // native scaling is only supported by WEBP and JPEG
531 bool supportsNativeScaling = false;
msarett438b2ad2015-04-09 12:43:10 -0700532
msarett91c22b22016-02-22 12:27:46 -0800533 SkTArray<CodecSrc::Mode> nativeModes;
534 nativeModes.push_back(CodecSrc::kCodec_Mode);
535 nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
msarett91c22b22016-02-22 12:27:46 -0800536 switch (codec->getEncodedFormat()) {
Hal Canarydb683012016-11-23 08:55:18 -0700537 case SkEncodedImageFormat::kJPEG:
msarett91c22b22016-02-22 12:27:46 -0800538 nativeModes.push_back(CodecSrc::kScanline_Mode);
539 nativeModes.push_back(CodecSrc::kStripe_Mode);
540 nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
scroggo9366aff2016-05-20 08:38:54 -0700541 supportsNativeScaling = true;
msarett91c22b22016-02-22 12:27:46 -0800542 break;
Hal Canarydb683012016-11-23 08:55:18 -0700543 case SkEncodedImageFormat::kWEBP:
msarett91c22b22016-02-22 12:27:46 -0800544 nativeModes.push_back(CodecSrc::kSubset_Mode);
scroggo9366aff2016-05-20 08:38:54 -0700545 supportsNativeScaling = true;
msarett91c22b22016-02-22 12:27:46 -0800546 break;
Hal Canarydb683012016-11-23 08:55:18 -0700547 case SkEncodedImageFormat::kDNG:
msarettb65e6042016-02-23 05:37:25 -0800548 break;
msarett91c22b22016-02-22 12:27:46 -0800549 default:
550 nativeModes.push_back(CodecSrc::kScanline_Mode);
msarett91c22b22016-02-22 12:27:46 -0800551 break;
552 }
msarett9e707a02015-09-01 14:57:57 -0700553
msarett91c22b22016-02-22 12:27:46 -0800554 SkTArray<CodecSrc::DstColorType> colorTypes;
555 colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
msarett34e0ec42016-04-22 16:27:24 -0700556 colorTypes.push_back(CodecSrc::kNonNative8888_Always_DstColorType);
msarett36c37962015-09-02 13:20:52 -0700557 switch (codec->getInfo().colorType()) {
558 case kGray_8_SkColorType:
msarett91c22b22016-02-22 12:27:46 -0800559 colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
Hal Canarydb683012016-11-23 08:55:18 -0700560 if (SkEncodedImageFormat::kWBMP == codec->getEncodedFormat()) {
msarett91c22b22016-02-22 12:27:46 -0800561 colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
msarett55f7bdd2016-02-16 13:24:54 -0800562 }
msarett36c37962015-09-02 13:20:52 -0700563 break;
564 case kIndex_8_SkColorType:
msarett91c22b22016-02-22 12:27:46 -0800565 colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
msarett36c37962015-09-02 13:20:52 -0700566 break;
567 default:
msarett36c37962015-09-02 13:20:52 -0700568 break;
569 }
msarett9e707a02015-09-01 14:57:57 -0700570
scroggoc5560be2016-02-03 09:42:42 -0800571 SkTArray<SkAlphaType> alphaModes;
572 alphaModes.push_back(kPremul_SkAlphaType);
scroggof2c96a22016-05-20 11:08:27 -0700573 if (codec->getInfo().alphaType() != kOpaque_SkAlphaType) {
574 alphaModes.push_back(kUnpremul_SkAlphaType);
scroggoc5560be2016-02-03 09:42:42 -0800575 }
msarettb714fb02016-01-22 14:46:42 -0800576
577 for (CodecSrc::Mode mode : nativeModes) {
scroggo9366aff2016-05-20 08:38:54 -0700578 for (CodecSrc::DstColorType colorType : colorTypes) {
579 for (SkAlphaType alphaType : alphaModes) {
scroggof2c96a22016-05-20 11:08:27 -0700580 // Only test kCroppedScanline_Mode when the alpha type is premul. The test is
scroggo9366aff2016-05-20 08:38:54 -0700581 // slow and won't be interestingly different with different alpha types.
582 if (CodecSrc::kCroppedScanline_Mode == mode &&
scroggof2c96a22016-05-20 11:08:27 -0700583 kPremul_SkAlphaType != alphaType) {
scroggo9366aff2016-05-20 08:38:54 -0700584 continue;
585 }
msarett91c22b22016-02-22 12:27:46 -0800586
scroggo9366aff2016-05-20 08:38:54 -0700587 push_codec_src(path, mode, colorType, alphaType, 1.0f);
msarettf3dc1882016-04-26 13:06:38 -0700588
scroggo9366aff2016-05-20 08:38:54 -0700589 // Skip kNonNative on different native scales. It won't be interestingly
590 // different.
591 if (supportsNativeScaling &&
592 CodecSrc::kNonNative8888_Always_DstColorType == colorType) {
593 // Native Scales
594 // SkJpegCodec natively supports scaling to the following:
595 for (auto scale : { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f }) {
596 push_codec_src(path, mode, colorType, alphaType, scale);
597 }
scroggoc5560be2016-02-03 09:42:42 -0800598 }
msarett9e707a02015-09-01 14:57:57 -0700599 }
600 }
msarett0a242972015-06-11 14:27:27 -0700601 }
msarett36c37962015-09-02 13:20:52 -0700602
scroggo19b91532016-10-24 09:03:26 -0700603 {
604 std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
605 if (frameInfos.size() > 1) {
Leon Scroggins III557fbbe2017-05-23 09:37:21 -0400606 for (auto dstCT : { CodecSrc::kNonNative8888_Always_DstColorType,
607 CodecSrc::kGetFromCanvas_DstColorType }) {
608 for (auto at : { kUnpremul_SkAlphaType, kPremul_SkAlphaType }) {
609 push_codec_src(path, CodecSrc::kAnimated_Mode, dstCT, at, 1.0f);
610 }
611 }
scroggo19b91532016-10-24 09:03:26 -0700612 }
613
614 }
615
scroggoe4499842016-02-25 11:03:47 -0800616 if (FLAGS_simpleCodec) {
617 return;
618 }
619
msarett3d9d7a72015-10-21 10:27:10 -0700620 const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
msarett36c37962015-09-02 13:20:52 -0700621
msarett3d9d7a72015-10-21 10:27:10 -0700622 for (int sampleSize : sampleSizes) {
msarett91c22b22016-02-22 12:27:46 -0800623 for (CodecSrc::DstColorType colorType : colorTypes) {
scroggoc5560be2016-02-03 09:42:42 -0800624 for (SkAlphaType alphaType : alphaModes) {
msarettf3dc1882016-04-26 13:06:38 -0700625 // We can exercise all of the kNonNative support code in the swizzler with just a
626 // few sample sizes. Skip the rest.
627 if (CodecSrc::kNonNative8888_Always_DstColorType == colorType && sampleSize > 3) {
628 continue;
629 }
630
scroggof8dc9df2016-05-16 09:04:13 -0700631 push_android_codec_src(path, colorType, alphaType, sampleSize);
msarett3d9d7a72015-10-21 10:27:10 -0700632 }
msarett36c37962015-09-02 13:20:52 -0700633 }
634 }
msarett18976312016-03-09 14:20:58 -0800635
636 static const char* const rawExts[] = {
637 "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
638 "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
639 };
640
641 // There is not currently a reason to test RAW images on image generator.
642 // If we want to enable these tests, we will need to fix skbug.com/5079.
643 for (const char* ext : rawExts) {
644 if (path.endsWith(ext)) {
645 return;
646 }
647 }
648
649 // Push image generator GPU test.
brianosmanc9ced392016-03-24 07:27:43 -0700650 push_image_gen_src(path, ImageGenSrc::kCodec_Mode, codec->getInfo().alphaType(), true);
msarett18976312016-03-09 14:20:58 -0800651
652 // Push image generator CPU tests.
653 for (SkAlphaType alphaType : alphaModes) {
654 push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
655
656#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
Hal Canarydb683012016-11-23 08:55:18 -0700657 if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
658 SkEncodedImageFormat::kWBMP != codec->getEncodedFormat() &&
msarett18976312016-03-09 14:20:58 -0800659 kUnpremul_SkAlphaType != alphaType)
660 {
661 push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
662 }
msarettfc0b6d12016-03-17 13:50:17 -0700663#elif defined(SK_BUILD_FOR_WIN)
Hal Canarydb683012016-11-23 08:55:18 -0700664 if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
665 SkEncodedImageFormat::kWBMP != codec->getEncodedFormat())
msarettfc0b6d12016-03-17 13:50:17 -0700666 {
667 push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
668 }
msarett18976312016-03-09 14:20:58 -0800669#endif
670 }
msarett438b2ad2015-04-09 12:43:10 -0700671}
672
msarettd1227a72016-05-18 06:23:57 -0700673static void push_brd_src(Path path, CodecSrc::DstColorType dstColorType, BRDSrc::Mode mode,
674 uint32_t sampleSize) {
675 SkString folder("brd_android_codec");
msaretta5783ae2015-09-08 15:35:32 -0700676 switch (mode) {
677 case BRDSrc::kFullImage_Mode:
678 break;
679 case BRDSrc::kDivisor_Mode:
680 folder.append("_divisor");
681 break;
682 default:
683 SkASSERT(false);
684 return;
685 }
686
687 switch (dstColorType) {
688 case CodecSrc::kGetFromCanvas_DstColorType:
689 break;
690 case CodecSrc::kIndex8_Always_DstColorType:
691 folder.append("_kIndex");
692 break;
693 case CodecSrc::kGrayscale_Always_DstColorType:
694 folder.append("_kGray");
695 break;
696 default:
697 SkASSERT(false);
698 return;
699 }
700
701 if (1 != sampleSize) {
msarett4b0778e2015-11-13 09:59:11 -0800702 folder.appendf("_%.3f", 1.0f / (float) sampleSize);
msaretta5783ae2015-09-08 15:35:32 -0700703 }
704
msarettd1227a72016-05-18 06:23:57 -0700705 BRDSrc* src = new BRDSrc(path, mode, dstColorType, sampleSize);
msaretta5783ae2015-09-08 15:35:32 -0700706 push_src("image", folder, src);
707}
708
709static void push_brd_srcs(Path path) {
scroggo24a9bd72016-05-20 06:02:42 -0700710 // Only run Index8 and grayscale to one sampleSize and Mode. Though interesting
711 // to test these color types, they should not reveal anything across various
712 // sampleSizes and Modes
713 for (auto type : { CodecSrc::kIndex8_Always_DstColorType,
714 CodecSrc::kGrayscale_Always_DstColorType }) {
715 // Arbitrarily choose Mode and sampleSize.
716 push_brd_src(path, type, BRDSrc::kFullImage_Mode, 2);
717 }
718
719
scroggo501b7342015-11-03 07:55:11 -0800720 // Test on a variety of sampleSizes, making sure to include:
721 // - 2, 4, and 8, which are natively supported by jpeg
722 // - multiples of 2 which are not divisible by 4 (analogous for 4)
723 // - larger powers of two, since BRD clients generally use powers of 2
724 // We will only produce output for the larger sizes on large images.
725 const uint32_t sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 24, 32, 64 };
msarett6efbe052015-09-11 09:01:16 -0700726
msaretta5783ae2015-09-08 15:35:32 -0700727 const BRDSrc::Mode modes[] = {
msarett26ad17b2015-10-22 07:29:19 -0700728 BRDSrc::kFullImage_Mode,
729 BRDSrc::kDivisor_Mode,
msaretta5783ae2015-09-08 15:35:32 -0700730 };
731
msarettd1227a72016-05-18 06:23:57 -0700732 for (uint32_t sampleSize : sampleSizes) {
scroggo24a9bd72016-05-20 06:02:42 -0700733 for (BRDSrc::Mode mode : modes) {
734 push_brd_src(path, CodecSrc::kGetFromCanvas_DstColorType, mode, sampleSize);
msaretta5783ae2015-09-08 15:35:32 -0700735 }
736 }
737}
738
739static bool brd_supported(const char* ext) {
msarett8c8f22a2015-04-01 06:58:48 -0700740 static const char* const exts[] = {
msaretta5783ae2015-09-08 15:35:32 -0700741 "jpg", "jpeg", "png", "webp",
742 "JPG", "JPEG", "PNG", "WEBP",
msarett8c8f22a2015-04-01 06:58:48 -0700743 };
744
745 for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
746 if (0 == strcmp(exts[i], ext)) {
747 return true;
748 }
749 }
750 return false;
scroggo9b77ddd2015-03-19 06:03:39 -0700751}
752
fmalitaa2b9fdf2016-08-03 19:53:36 -0700753template <typename T>
754void gather_file_srcs(const SkCommandLineFlags::StringArray& flags, const char* ext) {
755 for (int i = 0; i < flags.count(); i++) {
756 const char* path = flags[i];
757 if (sk_isdir(path)) {
758 SkOSFile::Iter it(path, ext);
759 for (SkString file; it.next(&file); ) {
760 push_src(ext, "", new T(SkOSPath::Join(path, file.c_str())));
761 }
762 } else {
763 push_src(ext, "", new T(path));
764 }
765 }
766}
767
scroggo86737142016-02-03 12:19:11 -0800768static bool gather_srcs() {
mtklein748ca3b2015-01-15 10:56:12 -0800769 for (const skiagm::GMRegistry* r = skiagm::GMRegistry::Head(); r; r = r->next()) {
djsollen54416de2015-04-03 07:24:48 -0700770 push_src("gm", "", new GMSrc(r->factory()));
mtklein748ca3b2015-01-15 10:56:12 -0800771 }
scroggo86737142016-02-03 12:19:11 -0800772
fmalitaa2b9fdf2016-08-03 19:53:36 -0700773 gather_file_srcs<SKPSrc>(FLAGS_skps, "skp");
774 gather_file_srcs<MSKPSrc>(FLAGS_mskps, "mskp");
775#if defined(SK_XML)
776 gather_file_srcs<SVGSrc>(FLAGS_svgs, "svg");
777#endif
halcanary45420a92016-06-02 12:41:14 -0700778
scroggo86737142016-02-03 12:19:11 -0800779 SkTArray<SkString> images;
msarett69deca82016-04-29 09:38:40 -0700780 if (!CollectImages(FLAGS_images, &images)) {
scroggo86737142016-02-03 12:19:11 -0800781 return false;
782 }
783
784 for (auto image : images) {
785 push_codec_srcs(image);
scroggoe4499842016-02-25 11:03:47 -0800786 if (FLAGS_simpleCodec) {
787 continue;
788 }
789
mtklein21eaf3b2016-02-08 12:39:59 -0800790 const char* ext = strrchr(image.c_str(), '.');
791 if (ext && brd_supported(ext+1)) {
scroggo86737142016-02-03 12:19:11 -0800792 push_brd_srcs(image);
mtklein709d2c32015-01-15 08:30:25 -0800793 }
mtklein709d2c32015-01-15 08:30:25 -0800794 }
scroggo86737142016-02-03 12:19:11 -0800795
msarett69deca82016-04-29 09:38:40 -0700796 SkTArray<SkString> colorImages;
797 if (!CollectImages(FLAGS_colorImages, &colorImages)) {
798 return false;
799 }
800
801 for (auto colorImage : colorImages) {
msarett9ce3a542016-07-15 13:54:38 -0700802 ColorCodecSrc* src = new ColorCodecSrc(colorImage, ColorCodecSrc::kBaseline_Mode,
803 kN32_SkColorType);
msarettb8d1aac2016-08-04 12:22:06 -0700804 push_src("colorImage", "color_codec_baseline", src);
msarett888dc162016-05-23 10:21:17 -0700805
msarett9ce3a542016-07-15 13:54:38 -0700806 src = new ColorCodecSrc(colorImage, ColorCodecSrc::kDst_HPZR30w_Mode, kN32_SkColorType);
msarettb8d1aac2016-08-04 12:22:06 -0700807 push_src("colorImage", "color_codec_HPZR30w", src);
msarett9ce3a542016-07-15 13:54:38 -0700808 // TODO (msarett):
809 // Should we test this Dst in F16 mode (even though the Dst gamma is 2.2 instead of sRGB)?
msarett9876ac52016-06-01 14:47:18 -0700810
msarett9ce3a542016-07-15 13:54:38 -0700811 src = new ColorCodecSrc(colorImage, ColorCodecSrc::kDst_sRGB_Mode, kN32_SkColorType);
msarettb8d1aac2016-08-04 12:22:06 -0700812 push_src("colorImage", "color_codec_sRGB_kN32", src);
msarett9ce3a542016-07-15 13:54:38 -0700813 src = new ColorCodecSrc(colorImage, ColorCodecSrc::kDst_sRGB_Mode, kRGBA_F16_SkColorType);
msarettb8d1aac2016-08-04 12:22:06 -0700814 push_src("colorImage", "color_codec_sRGB_kF16", src);
msarett69deca82016-04-29 09:38:40 -0700815 }
816
scroggo86737142016-02-03 12:19:11 -0800817 return true;
mtklein709d2c32015-01-15 08:30:25 -0800818}
819
kkinnunen3e980c32015-12-23 01:33:00 -0800820static void push_sink(const SkCommandLineConfig& config, Sink* s) {
Ben Wagner145dbcd2016-11-03 14:40:50 -0400821 std::unique_ptr<Sink> sink(s);
kkinnunen3e980c32015-12-23 01:33:00 -0800822
mtkleine0effd62015-07-29 06:37:28 -0700823 // Try a simple Src as a canary. If it fails, skip this sink.
mtklein748ca3b2015-01-15 10:56:12 -0800824 struct : public Src {
mtkleine0effd62015-07-29 06:37:28 -0700825 Error draw(SkCanvas* c) const override {
826 c->drawRect(SkRect::MakeWH(1,1), SkPaint());
827 return "";
828 }
mtklein36352bf2015-03-25 18:17:31 -0700829 SkISize size() const override { return SkISize::Make(16, 16); }
mtkleine0effd62015-07-29 06:37:28 -0700830 Name name() const override { return "justOneRect"; }
831 } justOneRect;
mtklein114c3cd2015-01-15 10:15:02 -0800832
mtklein748ca3b2015-01-15 10:56:12 -0800833 SkBitmap bitmap;
834 SkDynamicMemoryWStream stream;
mtkleinb9eb4ac2015-02-02 18:26:03 -0800835 SkString log;
mtkleine0effd62015-07-29 06:37:28 -0700836 Error err = sink->draw(justOneRect, &bitmap, &stream, &log);
mtklein4089ef72015-03-05 08:40:28 -0800837 if (err.isFatal()) {
mtkleinc41fd922016-03-08 09:01:39 -0800838 info("Could not run %s: %s\n", config.getTag().c_str(), err.c_str());
mtklein05641a52015-04-21 10:49:13 -0700839 exit(1);
mtklein114c3cd2015-01-15 10:15:02 -0800840 }
841
mtkleine0effd62015-07-29 06:37:28 -0700842 TaggedSink& ts = gSinks.push_back();
mtklein18300a32016-03-16 13:53:35 -0700843 ts.reset(sink.release());
kkinnunen3e980c32015-12-23 01:33:00 -0800844 ts.tag = config.getTag();
mtklein748ca3b2015-01-15 10:56:12 -0800845}
846
847static bool gpu_supported() {
848#if SK_SUPPORT_GPU
849 return FLAGS_gpu;
850#else
851 return false;
852#endif
853}
kkinnunen9ebc3f02015-12-21 23:48:13 -0800854
csmartdalton008b9d82017-02-22 12:00:42 -0700855static Sink* create_sink(const GrContextOptions& grCtxOptions, const SkCommandLineConfig* config) {
kkinnunen3e980c32015-12-23 01:33:00 -0800856#if SK_SUPPORT_GPU
857 if (gpu_supported()) {
858 if (const SkCommandLineConfigGpu* gpuConfig = config->asConfigGpu()) {
bsalomon85b4b532016-04-05 11:06:27 -0700859 GrContextFactory::ContextType contextType = gpuConfig->getContextType();
csmartdaltone812d492017-02-21 12:36:05 -0700860 GrContextFactory::ContextOverrides contextOverrides = gpuConfig->getContextOverrides();
csmartdalton008b9d82017-02-22 12:00:42 -0700861 GrContextFactory testFactory(grCtxOptions);
csmartdaltone812d492017-02-21 12:36:05 -0700862 if (!testFactory.get(contextType, contextOverrides)) {
mtkleinc41fd922016-03-08 09:01:39 -0800863 info("WARNING: can not create GPU context for config '%s'. "
864 "GM tests will be skipped.\n", gpuConfig->getTag().c_str());
kkinnunen3e980c32015-12-23 01:33:00 -0800865 return nullptr;
866 }
csmartdaltone812d492017-02-21 12:36:05 -0700867 return new GPUSink(contextType, contextOverrides, gpuConfig->getSamples(),
brianosmand93c1202016-03-10 07:49:08 -0800868 gpuConfig->getUseDIText(), gpuConfig->getColorType(),
brianosmanb109b8c2016-06-16 13:03:24 -0700869 sk_ref_sp(gpuConfig->getColorSpace()), FLAGS_gpu_threading);
kkinnunen3e980c32015-12-23 01:33:00 -0800870 }
871 }
872#endif
873
874#define SINK(t, sink, ...) if (config->getBackend().equals(t)) { return new sink(__VA_ARGS__); }
875
mtklein748ca3b2015-01-15 10:56:12 -0800876 if (FLAGS_cpu) {
Matt Sarett77a7a1b2017-02-07 13:56:11 -0500877 auto srgbColorSpace = SkColorSpace::MakeSRGB();
878 auto srgbLinearColorSpace = SkColorSpace::MakeSRGBLinear();
brianosmanb109b8c2016-06-16 13:03:24 -0700879
Matt Sarettd2228302017-03-02 08:53:46 -0500880 SINK("565", RasterSink, kRGB_565_SkColorType);
881 SINK("8888", RasterSink, kN32_SkColorType);
882 SINK("srgb", RasterSink, kN32_SkColorType, srgbColorSpace);
Matt Sarettd2228302017-03-02 08:53:46 -0500883 SINK("f16", RasterSink, kRGBA_F16_SkColorType, srgbLinearColorSpace);
884 SINK("pdf", PDFSink);
885 SINK("skp", SKPSink);
886 SINK("pipe", PipeSink);
887 SINK("svg", SVGSink);
888 SINK("null", NullSink);
889 SINK("xps", XPSSink);
890 SINK("pdfa", PDFSink, true);
Hal Canary85c7fe82016-10-25 10:33:27 -0400891 SINK("jsdebug", DebugSink);
mtklein748ca3b2015-01-15 10:56:12 -0800892 }
893#undef SINK
halcanary96fcdcc2015-08-27 07:41:13 -0700894 return nullptr;
mtklein114c3cd2015-01-15 10:15:02 -0800895}
896
Mike Klein841101d2017-03-10 09:55:51 -0500897static sk_sp<SkColorSpace> adobe_rgb() {
898 return SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma,
899 SkColorSpace::kAdobeRGB_Gamut);
900}
901
Mike Klein919cc452017-03-18 15:36:52 +0000902static sk_sp<SkColorSpace> rgb_to_gbr() {
903 float gbr[9];
904 gbr[0] = gSRGB_toXYZD50[1];
905 gbr[1] = gSRGB_toXYZD50[2];
906 gbr[2] = gSRGB_toXYZD50[0];
907 gbr[3] = gSRGB_toXYZD50[4];
908 gbr[4] = gSRGB_toXYZD50[5];
909 gbr[5] = gSRGB_toXYZD50[3];
910 gbr[6] = gSRGB_toXYZD50[7];
911 gbr[7] = gSRGB_toXYZD50[8];
912 gbr[8] = gSRGB_toXYZD50[6];
913 SkMatrix44 toXYZD50(SkMatrix44::kUninitialized_Constructor);
914 toXYZD50.set3x3RowMajorf(gbr);
915 return SkColorSpace::MakeRGB(SkColorSpace::kSRGB_RenderTargetGamma, toXYZD50);
916}
917
kkinnunen3e980c32015-12-23 01:33:00 -0800918static Sink* create_via(const SkString& tag, Sink* wrapped) {
919#define VIA(t, via, ...) if (tag.equals(t)) { return new via(__VA_ARGS__); }
Mike Klein919cc452017-03-18 15:36:52 +0000920 VIA("adobe", ViaCSXform, wrapped, adobe_rgb(), false);
921 VIA("gbr", ViaCSXform, wrapped, rgb_to_gbr(), true);
mtklein9c5052f2016-08-06 12:51:51 -0700922 VIA("lite", ViaLite, wrapped);
reed54dc4872016-09-13 08:09:45 -0700923 VIA("pipe", ViaPipe, wrapped);
halcanary96fcdcc2015-08-27 07:41:13 -0700924 VIA("twice", ViaTwice, wrapped);
Mike Reedbae888e2017-02-18 16:50:45 -0500925#ifdef TEST_VIA_SVG
Mike Reedf67c4592017-02-17 17:06:11 -0500926 VIA("svg", ViaSVG, wrapped);
Mike Reedbae888e2017-02-18 16:50:45 -0500927#endif
halcanary96fcdcc2015-08-27 07:41:13 -0700928 VIA("serialize", ViaSerialization, wrapped);
mtklein4a34ecb2016-01-08 10:19:35 -0800929 VIA("pic", ViaPicture, wrapped);
halcanary96fcdcc2015-08-27 07:41:13 -0700930 VIA("2ndpic", ViaSecondPicture, wrapped);
mtkleind31c13d2015-05-05 12:59:56 -0700931 VIA("sp", ViaSingletonPictures, wrapped);
reedbabc3de2016-07-08 08:43:27 -0700932 VIA("defer", ViaDefer, wrapped);
halcanary96fcdcc2015-08-27 07:41:13 -0700933 VIA("tiles", ViaTiles, 256, 256, nullptr, wrapped);
mtklein7edca212015-01-21 13:18:51 -0800934 VIA("tiles_rt", ViaTiles, 256, 256, new SkRTreeFactory, wrapped);
mtklein748ca3b2015-01-15 10:56:12 -0800935
mtkleind603b222015-02-17 11:13:33 -0800936 if (FLAGS_matrix.count() == 4) {
mtklein748ca3b2015-01-15 10:56:12 -0800937 SkMatrix m;
mtkleind603b222015-02-17 11:13:33 -0800938 m.reset();
939 m.setScaleX((SkScalar)atof(FLAGS_matrix[0]));
940 m.setSkewX ((SkScalar)atof(FLAGS_matrix[1]));
941 m.setSkewY ((SkScalar)atof(FLAGS_matrix[2]));
942 m.setScaleY((SkScalar)atof(FLAGS_matrix[3]));
943 VIA("matrix", ViaMatrix, m, wrapped);
944 VIA("upright", ViaUpright, m, wrapped);
mtklein748ca3b2015-01-15 10:56:12 -0800945 }
tomhudson64de1e12015-03-05 08:01:07 -0800946
mtklein748ca3b2015-01-15 10:56:12 -0800947#undef VIA
halcanary96fcdcc2015-08-27 07:41:13 -0700948 return nullptr;
mtklein114c3cd2015-01-15 10:15:02 -0800949}
950
csmartdalton008b9d82017-02-22 12:00:42 -0700951static bool gather_sinks(const GrContextOptions& grCtxOptions) {
kkinnunen3e980c32015-12-23 01:33:00 -0800952 SkCommandLineConfigArray configs;
953 ParseConfigs(FLAGS_config, &configs);
954 for (int i = 0; i < configs.count(); i++) {
955 const SkCommandLineConfig& config = *configs[i];
csmartdalton008b9d82017-02-22 12:00:42 -0700956 Sink* sink = create_sink(grCtxOptions, &config);
kkinnunen3e980c32015-12-23 01:33:00 -0800957 if (sink == nullptr) {
mtkleinc41fd922016-03-08 09:01:39 -0800958 info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
959 config.getTag().c_str());
kkinnunen3e980c32015-12-23 01:33:00 -0800960 continue;
961 }
mtklein748ca3b2015-01-15 10:56:12 -0800962
kkinnunen3e980c32015-12-23 01:33:00 -0800963 const SkTArray<SkString>& parts = config.getViaParts();
964 for (int j = parts.count(); j-- > 0;) {
965 const SkString& part = parts[j];
966 Sink* next = create_via(part, sink);
halcanary96fcdcc2015-08-27 07:41:13 -0700967 if (next == nullptr) {
mtkleinc41fd922016-03-08 09:01:39 -0800968 info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
969 part.c_str());
mtklein748ca3b2015-01-15 10:56:12 -0800970 delete sink;
halcanary96fcdcc2015-08-27 07:41:13 -0700971 sink = nullptr;
mtklein748ca3b2015-01-15 10:56:12 -0800972 break;
973 }
974 sink = next;
975 }
976 if (sink) {
977 push_sink(config, sink);
mtklein114c3cd2015-01-15 10:15:02 -0800978 }
979 }
brianosman05c987c2016-05-09 13:42:16 -0700980
981 // If no configs were requested (just running tests, perhaps?), then we're okay.
982 // Otherwise, make sure that at least one sink was constructed correctly. This catches
983 // the case of bots without a GPU being assigned GPU configs.
984 return (configs.count() == 0) || (gSinks.count() > 0);
mtklein114c3cd2015-01-15 10:15:02 -0800985}
mtklein709d2c32015-01-15 08:30:25 -0800986
mtkleina5114d72015-08-24 13:27:01 -0700987static bool dump_png(SkBitmap bitmap, const char* path, const char* md5) {
Mike Klein13b6afd2017-06-12 12:45:41 -0400988 SkPixmap pm;
989 if (!bitmap.peekPixels(&pm)) {
990 return false; // Ought to never happen... we're already read-back at this point.
mtkleina5114d72015-08-24 13:27:01 -0700991 }
Mike Klein13b6afd2017-06-12 12:45:41 -0400992 SkFILEWStream dst{path};
mtkleina5114d72015-08-24 13:27:01 -0700993
mtkleind69ece62015-09-10 10:37:44 -0700994 SkString description;
995 description.append("Key: ");
996 for (int i = 0; i < FLAGS_key.count(); i++) {
997 description.appendf("%s ", FLAGS_key[i]);
998 }
999 description.append("Properties: ");
1000 for (int i = 0; i < FLAGS_properties.count(); i++) {
1001 description.appendf("%s ", FLAGS_properties[i]);
1002 }
1003 description.appendf("MD5: %s", md5);
1004
Mike Klein13b6afd2017-06-12 12:45:41 -04001005 const char* comments[] = {
1006 "Author", "DM dump_png()",
1007 "Description", description.c_str(),
1008 };
1009 size_t lengths[] = {
1010 strlen(comments[0])+1, strlen(comments[1])+1,
1011 strlen(comments[2])+1, strlen(comments[3])+1,
1012 };
mtkleina5114d72015-08-24 13:27:01 -07001013
Mike Klein13b6afd2017-06-12 12:45:41 -04001014 SkPngEncoder::Options options;
1015 options.fComments = SkDataTable::MakeCopyArrays((const void**)comments, lengths, 4);
1016 options.fFilterFlags = SkPngEncoder::FilterFlag::kNone;
1017 options.fZLibLevel = 1;
1018 options.fUnpremulBehavior = pm.colorSpace() ? SkTransferFunctionBehavior::kRespect
1019 : SkTransferFunctionBehavior::kIgnore;
1020 return SkPngEncoder::Encode(&dst, pm, options);
mtkleina5114d72015-08-24 13:27:01 -07001021}
1022
mtkleina2ef6422015-01-15 13:44:22 -08001023static bool match(const char* needle, const char* haystack) {
halcanary96fcdcc2015-08-27 07:41:13 -07001024 return 0 == strcmp("_", needle) || nullptr != strstr(haystack, needle);
mtkleina2ef6422015-01-15 13:44:22 -08001025}
1026
mtklein3eed7dd2016-02-24 19:07:07 -08001027static bool is_blacklisted(const char* sink, const char* src,
1028 const char* srcOptions, const char* name) {
mtklein0d243ff2015-04-03 07:51:00 -07001029 for (int i = 0; i < FLAGS_blacklist.count() - 3; i += 4) {
mtkleina2ef6422015-01-15 13:44:22 -08001030 if (match(FLAGS_blacklist[i+0], sink) &&
djsollen54416de2015-04-03 07:24:48 -07001031 match(FLAGS_blacklist[i+1], src) &&
1032 match(FLAGS_blacklist[i+2], srcOptions) &&
1033 match(FLAGS_blacklist[i+3], name)) {
mtklein3eed7dd2016-02-24 19:07:07 -08001034 return true;
mtkleina2ef6422015-01-15 13:44:22 -08001035 }
1036 }
mtklein3eed7dd2016-02-24 19:07:07 -08001037 return false;
mtkleina2ef6422015-01-15 13:44:22 -08001038}
1039
mtkleincd50bca2016-01-05 06:20:20 -08001040// Even when a Task Sink reports to be non-threadsafe (e.g. GPU), we know things like
1041// .png encoding are definitely thread safe. This lets us offload that work to CPU threads.
1042static SkTaskGroup gDefinitelyThreadSafeWork;
1043
mtklein748ca3b2015-01-15 10:56:12 -08001044// The finest-grained unit of work we can run: draw a single Src into a single Sink,
1045// report any errors, and perhaps write out the output: a .png of the bitmap, or a raw stream.
1046struct Task {
mtkleine0effd62015-07-29 06:37:28 -07001047 Task(const TaggedSrc& src, const TaggedSink& sink) : src(src), sink(sink) {}
1048 const TaggedSrc& src;
1049 const TaggedSink& sink;
mtklein748ca3b2015-01-15 10:56:12 -08001050
mtklein21eaf3b2016-02-08 12:39:59 -08001051 static void Run(const Task& task) {
1052 SkString name = task.src->name();
mtkleine0effd62015-07-29 06:37:28 -07001053
mtkleinb9eb4ac2015-02-02 18:26:03 -08001054 SkString log;
mtklein3eed7dd2016-02-24 19:07:07 -08001055 if (!FLAGS_dryRun) {
mtklein748ca3b2015-01-15 10:56:12 -08001056 SkBitmap bitmap;
1057 SkDynamicMemoryWStream stream;
mtklein3eed7dd2016-02-24 19:07:07 -08001058 start(task.sink.tag.c_str(), task.src.tag.c_str(),
1059 task.src.options.c_str(), name.c_str());
mtklein21eaf3b2016-02-08 12:39:59 -08001060 Error err = task.sink->draw(*task.src, &bitmap, &stream, &log);
mtkleinb3b13b72016-03-07 13:20:52 -08001061 if (!log.isEmpty()) {
mtkleinc41fd922016-03-08 09:01:39 -08001062 info("%s %s %s %s:\n%s\n", task.sink.tag.c_str()
1063 , task.src.tag.c_str()
1064 , task.src.options.c_str()
1065 , name.c_str()
1066 , log.c_str());
mtkleinb3b13b72016-03-07 13:20:52 -08001067 }
mtklein748ca3b2015-01-15 10:56:12 -08001068 if (!err.isEmpty()) {
mtklein4089ef72015-03-05 08:40:28 -08001069 if (err.isFatal()) {
djsollen54416de2015-04-03 07:24:48 -07001070 fail(SkStringPrintf("%s %s %s %s: %s",
mtklein21eaf3b2016-02-08 12:39:59 -08001071 task.sink.tag.c_str(),
1072 task.src.tag.c_str(),
1073 task.src.options.c_str(),
mtklein4089ef72015-03-05 08:40:28 -08001074 name.c_str(),
1075 err.c_str()));
mtkleinb37cb412015-03-18 05:27:14 -07001076 } else {
mtklein3eed7dd2016-02-24 19:07:07 -08001077 done(task.sink.tag.c_str(), task.src.tag.c_str(),
1078 task.src.options.c_str(), name.c_str());
mtkleinba6ada72016-01-21 09:39:35 -08001079 return;
mtklein4089ef72015-03-05 08:40:28 -08001080 }
mtklein748ca3b2015-01-15 10:56:12 -08001081 }
mtklein62bd1a62015-01-27 14:46:26 -08001082
mtkleincd50bca2016-01-05 06:20:20 -08001083 // We're likely switching threads here, so we must capture by value, [=] or [foo,bar].
Hal Canary0b833192017-03-14 14:35:02 -04001084 SkStreamAsset* data = stream.detachAsStream().release();
mtkleincd50bca2016-01-05 06:20:20 -08001085 gDefinitelyThreadSafeWork.add([task,name,bitmap,data]{
Ben Wagner145dbcd2016-11-03 14:40:50 -04001086 std::unique_ptr<SkStreamAsset> ownedData(data);
mtkleincd50bca2016-01-05 06:20:20 -08001087
mtkleincd50bca2016-01-05 06:20:20 -08001088 SkString md5;
1089 if (!FLAGS_writePath.isEmpty() || !FLAGS_readPath.isEmpty()) {
1090 SkMD5 hash;
1091 if (data->getLength()) {
1092 hash.writeStream(data, data->getLength());
1093 data->rewind();
mtklein38408462015-07-08 07:25:27 -07001094 } else {
mtkleincd50bca2016-01-05 06:20:20 -08001095 // If we're BGRA (Linux, Windows), swizzle over to RGBA (Mac, Android).
1096 // This helps eliminate multiple 0-pixel-diff hashes on gold.skia.org.
1097 // (Android's general slow speed breaks the tie arbitrarily in RGBA's favor.)
1098 // We might consider promoting 565 to RGBA too.
1099 if (bitmap.colorType() == kBGRA_8888_SkColorType) {
1100 SkBitmap swizzle;
Matt Sarett68b8e3d2017-04-28 11:15:22 -04001101 SkAssertResult(sk_tool_utils::copy_to(&swizzle, kRGBA_8888_SkColorType,
1102 bitmap));
mtkleincd50bca2016-01-05 06:20:20 -08001103 hash.write(swizzle.getPixels(), swizzle.getSize());
1104 } else {
1105 hash.write(bitmap.getPixels(), bitmap.getSize());
1106 }
1107 }
1108 SkMD5::Digest digest;
1109 hash.finish(digest);
1110 for (int i = 0; i < 16; i++) {
1111 md5.appendf("%02x", digest.data[i]);
mtklein38408462015-07-08 07:25:27 -07001112 }
mtklein62bd1a62015-01-27 14:46:26 -08001113 }
mtklein62bd1a62015-01-27 14:46:26 -08001114
mtkleincd50bca2016-01-05 06:20:20 -08001115 if (!FLAGS_readPath.isEmpty() &&
mtklein3eed7dd2016-02-24 19:07:07 -08001116 !gGold.contains(Gold(task.sink.tag, task.src.tag,
1117 task.src.options, name, md5))) {
mtkleincd50bca2016-01-05 06:20:20 -08001118 fail(SkStringPrintf("%s not found for %s %s %s %s in %s",
1119 md5.c_str(),
mtklein21eaf3b2016-02-08 12:39:59 -08001120 task.sink.tag.c_str(),
1121 task.src.tag.c_str(),
1122 task.src.options.c_str(),
mtkleincd50bca2016-01-05 06:20:20 -08001123 name.c_str(),
1124 FLAGS_readPath[0]));
mtklein748ca3b2015-01-15 10:56:12 -08001125 }
mtkleincd50bca2016-01-05 06:20:20 -08001126
1127 if (!FLAGS_writePath.isEmpty()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001128 const char* ext = task.sink->fileExtension();
mtkleincd50bca2016-01-05 06:20:20 -08001129 if (data->getLength()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001130 WriteToDisk(task, md5, ext, data, data->getLength(), nullptr);
mtkleincd50bca2016-01-05 06:20:20 -08001131 SkASSERT(bitmap.drawsNothing());
1132 } else if (!bitmap.drawsNothing()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001133 WriteToDisk(task, md5, ext, nullptr, 0, &bitmap);
mtkleincd50bca2016-01-05 06:20:20 -08001134 }
1135 }
1136 });
mtklein748ca3b2015-01-15 10:56:12 -08001137 }
mtklein3eed7dd2016-02-24 19:07:07 -08001138 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 -08001139 }
1140
1141 static void WriteToDisk(const Task& task,
mtklein62bd1a62015-01-27 14:46:26 -08001142 SkString md5,
1143 const char* ext,
mtklein748ca3b2015-01-15 10:56:12 -08001144 SkStream* data, size_t len,
mtklein62bd1a62015-01-27 14:46:26 -08001145 const SkBitmap* bitmap) {
mtklein409d4702016-02-29 07:38:01 -08001146 bool gammaCorrect = false;
1147 if (bitmap) {
Brian Osman7039f742016-11-01 15:56:16 -04001148 gammaCorrect = SkToBool(bitmap->info().colorSpace());
mtklein409d4702016-02-29 07:38:01 -08001149 }
1150
mtklein748ca3b2015-01-15 10:56:12 -08001151 JsonWriter::BitmapResult result;
djsollen54416de2015-04-03 07:24:48 -07001152 result.name = task.src->name();
mtklein3eed7dd2016-02-24 19:07:07 -08001153 result.config = task.sink.tag;
djsollen54416de2015-04-03 07:24:48 -07001154 result.sourceType = task.src.tag;
1155 result.sourceOptions = task.src.options;
1156 result.ext = ext;
mtklein409d4702016-02-29 07:38:01 -08001157 result.gammaCorrect = gammaCorrect;
djsollen54416de2015-04-03 07:24:48 -07001158 result.md5 = md5;
mtklein748ca3b2015-01-15 10:56:12 -08001159 JsonWriter::AddBitmapResult(result);
1160
mtkleinb0531a72015-04-07 13:38:48 -07001161 // If an MD5 is uninteresting, we want it noted in the JSON file,
1162 // but don't want to dump it out as a .png (or whatever ext is).
1163 if (gUninterestingHashes.contains(md5)) {
1164 return;
1165 }
1166
mtklein748ca3b2015-01-15 10:56:12 -08001167 const char* dir = FLAGS_writePath[0];
1168 if (0 == strcmp(dir, "@")) { // Needed for iOS.
1169 dir = FLAGS_resourcePath[0];
1170 }
1171 sk_mkdir(dir);
1172
1173 SkString path;
1174 if (FLAGS_nameByHash) {
1175 path = SkOSPath::Join(dir, result.md5.c_str());
1176 path.append(".");
1177 path.append(ext);
1178 if (sk_exists(path.c_str())) {
1179 return; // Content-addressed. If it exists already, we're done.
1180 }
1181 } else {
kkinnunen3e980c32015-12-23 01:33:00 -08001182 path = SkOSPath::Join(dir, task.sink.tag.c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001183 sk_mkdir(path.c_str());
msarett9e707a02015-09-01 14:57:57 -07001184 path = SkOSPath::Join(path.c_str(), task.src.tag.c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001185 sk_mkdir(path.c_str());
msarett9e707a02015-09-01 14:57:57 -07001186 if (strcmp(task.src.options.c_str(), "") != 0) {
1187 path = SkOSPath::Join(path.c_str(), task.src.options.c_str());
djsollen54416de2015-04-03 07:24:48 -07001188 sk_mkdir(path.c_str());
1189 }
mtklein748ca3b2015-01-15 10:56:12 -08001190 path = SkOSPath::Join(path.c_str(), task.src->name().c_str());
1191 path.append(".");
1192 path.append(ext);
1193 }
1194
mtklein748ca3b2015-01-15 10:56:12 -08001195 if (bitmap) {
mtkleina5114d72015-08-24 13:27:01 -07001196 if (!dump_png(*bitmap, path.c_str(), result.md5.c_str())) {
mtklein748ca3b2015-01-15 10:56:12 -08001197 fail(SkStringPrintf("Can't encode PNG to %s.\n", path.c_str()));
1198 return;
1199 }
1200 } else {
mtkleina5114d72015-08-24 13:27:01 -07001201 SkFILEWStream file(path.c_str());
1202 if (!file.isValid()) {
1203 fail(SkStringPrintf("Can't open %s for writing.\n", path.c_str()));
1204 return;
1205 }
mtklein748ca3b2015-01-15 10:56:12 -08001206 if (!file.writeStream(data, len)) {
1207 fail(SkStringPrintf("Can't write to %s.\n", path.c_str()));
1208 return;
1209 }
1210 }
1211 }
1212};
1213
mtklein748ca3b2015-01-15 10:56:12 -08001214/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1215
1216// Unit tests don't fit so well into the Src/Sink model, so we give them special treatment.
1217
mtklein21eaf3b2016-02-08 12:39:59 -08001218static SkTDArray<skiatest::Test> gParallelTests, gSerialTests;
mtklein748ca3b2015-01-15 10:56:12 -08001219
1220static void gather_tests() {
mtklein6c5fed22015-01-20 13:47:23 -08001221 if (!FLAGS_src.contains("tests")) {
mtklein748ca3b2015-01-15 10:56:12 -08001222 return;
1223 }
mtklein6393c062015-04-27 08:45:01 -07001224 for (const skiatest::TestRegistry* r = skiatest::TestRegistry::Head(); r; r = r->next()) {
1225 if (!in_shard()) {
1226 continue;
1227 }
halcanary87f3ba42015-01-20 09:30:20 -08001228 // Despite its name, factory() is returning a reference to
1229 // link-time static const POD data.
1230 const skiatest::Test& test = r->factory();
1231 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, test.name)) {
mtklein748ca3b2015-01-15 10:56:12 -08001232 continue;
1233 }
halcanary87f3ba42015-01-20 09:30:20 -08001234 if (test.needsGpu && gpu_supported()) {
mtklein21eaf3b2016-02-08 12:39:59 -08001235 (FLAGS_gpu_threading ? gParallelTests : gSerialTests).push(test);
halcanary87f3ba42015-01-20 09:30:20 -08001236 } else if (!test.needsGpu && FLAGS_cpu) {
mtklein21eaf3b2016-02-08 12:39:59 -08001237 gParallelTests.push(test);
mtklein82d28432015-01-15 12:46:02 -08001238 }
mtklein748ca3b2015-01-15 10:56:12 -08001239 }
1240}
1241
csmartdalton008b9d82017-02-22 12:00:42 -07001242static void run_test(skiatest::Test test, const GrContextOptions& grCtxOptions) {
halcanary87f3ba42015-01-20 09:30:20 -08001243 struct : public skiatest::Reporter {
mtklein36352bf2015-03-25 18:17:31 -07001244 void reportFailed(const skiatest::Failure& failure) override {
halcanary87f3ba42015-01-20 09:30:20 -08001245 fail(failure.toString());
1246 JsonWriter::AddTestFailure(failure);
1247 }
mtklein36352bf2015-03-25 18:17:31 -07001248 bool allowExtendedTest() const override {
halcanary87f3ba42015-01-20 09:30:20 -08001249 return FLAGS_pathOpsExtended;
1250 }
mtklein36352bf2015-03-25 18:17:31 -07001251 bool verbose() const override { return FLAGS_veryVerbose; }
halcanary87f3ba42015-01-20 09:30:20 -08001252 } reporter;
djsollen824996a2015-06-12 12:06:22 -07001253
mtklein3eed7dd2016-02-24 19:07:07 -08001254 if (!FLAGS_dryRun && !is_blacklisted("_", "tests", "_", test.name)) {
mtklein21eaf3b2016-02-08 12:39:59 -08001255 start("unit", "test", "", test.name);
csmartdalton008b9d82017-02-22 12:00:42 -07001256 GrContextFactory factory(grCtxOptions);
mtklein21eaf3b2016-02-08 12:39:59 -08001257 test.proc(&reporter, &factory);
mtklein748ca3b2015-01-15 10:56:12 -08001258 }
mtklein3eed7dd2016-02-24 19:07:07 -08001259 done("unit", "test", "", test.name);
mtklein748ca3b2015-01-15 10:56:12 -08001260}
1261
1262/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1263
caryclark83ca6282015-06-10 09:31:09 -07001264#define PORTABLE_FONT_PREFIX "Toy Liberation "
1265
mbocee6a9912016-05-31 11:42:36 -07001266static sk_sp<SkTypeface> create_from_name(const char familyName[], SkFontStyle style) {
caryclark83ca6282015-06-10 09:31:09 -07001267 if (familyName && strlen(familyName) > sizeof(PORTABLE_FONT_PREFIX)
1268 && !strncmp(familyName, PORTABLE_FONT_PREFIX, sizeof(PORTABLE_FONT_PREFIX) - 1)) {
caryclark1818acb2015-07-24 12:09:25 -07001269 return sk_tool_utils::create_portable_typeface(familyName, style);
caryclark83ca6282015-06-10 09:31:09 -07001270 }
halcanary96fcdcc2015-08-27 07:41:13 -07001271 return nullptr;
caryclark83ca6282015-06-10 09:31:09 -07001272}
1273
1274#undef PORTABLE_FONT_PREFIX
1275
mbocee6a9912016-05-31 11:42:36 -07001276extern sk_sp<SkTypeface> (*gCreateTypefaceDelegate)(const char [], SkFontStyle );
caryclark83ca6282015-06-10 09:31:09 -07001277
Mike Kleinbe28ee22017-02-06 12:46:20 -05001278int main(int argc, char** argv) {
1279 SkCommandLineFlags::Parse(argc, argv);
Mike Kleinadacaef2017-02-06 09:26:14 -05001280#if defined(SK_BUILD_FOR_IOS)
1281 cd_Documents();
1282#endif
bsalomon71de3532016-04-26 14:27:21 -07001283 setbuf(stdout, nullptr);
mtklein246ba3a2016-02-23 10:39:36 -08001284 setup_crash_handler();
mtkleinafae30a2016-02-24 12:28:32 -08001285
Yuqian Liba62b4a2016-12-14 13:46:53 -05001286 gSkUseAnalyticAA = FLAGS_analyticAA;
liyuqian38911a72016-10-04 11:23:22 -07001287
Yuqian Li550148b2017-01-13 10:13:13 -05001288 if (FLAGS_forceAnalyticAA) {
1289 gSkForceAnalyticAA = true;
1290 }
1291
mtkleina483da32016-03-17 12:53:36 -07001292 if (FLAGS_verbose) {
1293 gVLog = stderr;
1294 } else if (!FLAGS_writePath.isEmpty()) {
mtklein51c8cfc2016-03-11 12:59:09 -08001295 sk_mkdir(FLAGS_writePath[0]);
mtkleina1ce2162016-07-22 12:23:46 -07001296 gVLog = fopen(SkOSPath::Join(FLAGS_writePath[0], "verbose.log").c_str(), "w");
mtkleinc41fd922016-03-08 09:01:39 -08001297 }
1298
csmartdalton008b9d82017-02-22 12:00:42 -07001299 GrContextOptions grCtxOptions;
1300#if SK_SUPPORT_GPU
1301 grCtxOptions.fGpuPathRenderers = CollectGpuPathRenderersFromFlags();
1302#endif
1303
mtklein5286f022016-01-22 08:18:14 -08001304 JsonWriter::DumpJson(); // It's handy for the bots to assume this is ~never missing.
commit-bot@chromium.org39e8d932014-05-29 20:14:48 +00001305 SkAutoGraphics ag;
mtklein406654b2014-09-03 15:34:37 -07001306 SkTaskGroup::Enabler enabled(FLAGS_threads);
caryclark83ca6282015-06-10 09:31:09 -07001307 gCreateTypefaceDelegate = &create_from_name;
commit-bot@chromium.orga65e2fd2014-05-30 17:23:31 +00001308
halcanary7d571242016-02-24 17:59:16 -08001309 {
1310 SkString testResourcePath = GetResourcePath("color_wheel.png");
1311 SkFILEStream testResource(testResourcePath.c_str());
1312 if (!testResource.isValid()) {
mtkleinc41fd922016-03-08 09:01:39 -08001313 info("Some resources are missing. Do you need to set --resourcePath?\n");
halcanary7d571242016-02-24 17:59:16 -08001314 }
1315 }
mtklein62bd1a62015-01-27 14:46:26 -08001316 gather_gold();
borenet09ed4802015-04-03 14:15:33 -07001317 gather_uninteresting_hashes();
mtklein62bd1a62015-01-27 14:46:26 -08001318
scroggo86737142016-02-03 12:19:11 -08001319 if (!gather_srcs()) {
1320 return 1;
1321 }
csmartdalton008b9d82017-02-22 12:00:42 -07001322 if (!gather_sinks(grCtxOptions)) {
brianosman05c987c2016-05-09 13:42:16 -07001323 return 1;
1324 }
mtklein748ca3b2015-01-15 10:56:12 -08001325 gather_tests();
mtklein21eaf3b2016-02-08 12:39:59 -08001326 gPending = gSrcs.count() * gSinks.count() + gParallelTests.count() + gSerialTests.count();
mtkleinc41fd922016-03-08 09:01:39 -08001327 info("%d srcs * %d sinks + %d tests == %d tasks",
1328 gSrcs.count(), gSinks.count(), gParallelTests.count() + gSerialTests.count(), gPending);
mtklein748ca3b2015-01-15 10:56:12 -08001329
mtklein21eaf3b2016-02-08 12:39:59 -08001330 // Kick off as much parallel work as we can, making note of any serial work we'll need to do.
1331 SkTaskGroup parallel;
1332 SkTArray<Task> serial;
1333
1334 for (auto& sink : gSinks)
1335 for (auto& src : gSrcs) {
mtklein3eed7dd2016-02-24 19:07:07 -08001336 if (src->veto(sink->flags()) ||
1337 is_blacklisted(sink.tag.c_str(), src.tag.c_str(),
1338 src.options.c_str(), src->name().c_str())) {
mtkleinf10637f2016-06-10 13:56:35 -07001339 SkAutoMutexAcquire lock(gMutex);
mtklein3eed7dd2016-02-24 19:07:07 -08001340 gPending--;
1341 continue;
1342 }
1343
mtklein21eaf3b2016-02-08 12:39:59 -08001344 Task task(src, sink);
1345 if (src->serial() || sink->serial()) {
1346 serial.push_back(task);
1347 } else {
1348 parallel.add([task] { Task::Run(task); });
mtklein748ca3b2015-01-15 10:56:12 -08001349 }
commit-bot@chromium.org38aeb0f2014-02-26 23:01:57 +00001350 }
mtklein21eaf3b2016-02-08 12:39:59 -08001351 for (auto test : gParallelTests) {
csmartdalton008b9d82017-02-22 12:00:42 -07001352 parallel.add([test, grCtxOptions] { run_test(test, grCtxOptions); });
mtklein55e88b22015-01-21 15:50:13 -08001353 }
mtklein21eaf3b2016-02-08 12:39:59 -08001354
1355 // With the parallel work running, run serial tasks and tests here on main thread.
1356 for (auto task : serial) { Task::Run(task); }
csmartdalton008b9d82017-02-22 12:00:42 -07001357 for (auto test : gSerialTests) { run_test(test, grCtxOptions); }
mtklein21eaf3b2016-02-08 12:39:59 -08001358
1359 // Wait for any remaining parallel work to complete (including any spun off of serial tasks).
1360 parallel.wait();
mtkleincd50bca2016-01-05 06:20:20 -08001361 gDefinitelyThreadSafeWork.wait();
1362
mtkleinda884c42016-02-24 18:00:23 -08001363 // We'd better have run everything.
1364 SkASSERT(gPending == 0);
mtkleine027f172016-02-26 15:53:06 -08001365 // Make sure we've flushed all our results to disk.
1366 JsonWriter::DumpJson();
mtkleinda884c42016-02-24 18:00:23 -08001367
mtklein748ca3b2015-01-15 10:56:12 -08001368 // At this point we're back in single-threaded land.
caryclarkf53ce802015-06-15 06:48:30 -07001369 sk_tool_utils::release_portable_typefaces();
mtklein@google.comd36522d2013-10-16 13:02:15 +00001370
mtklein748ca3b2015-01-15 10:56:12 -08001371 if (gFailures.count() > 0) {
mtkleinc41fd922016-03-08 09:01:39 -08001372 info("Failures:\n");
mtklein748ca3b2015-01-15 10:56:12 -08001373 for (int i = 0; i < gFailures.count(); i++) {
mtkleinc41fd922016-03-08 09:01:39 -08001374 info("\t%s\n", gFailures[i].c_str());
mtklein748ca3b2015-01-15 10:56:12 -08001375 }
mtkleinc41fd922016-03-08 09:01:39 -08001376 info("%d failures\n", gFailures.count());
mtklein748ca3b2015-01-15 10:56:12 -08001377 return 1;
mtklein114c3cd2015-01-15 10:15:02 -08001378 }
mtkleinafae30a2016-02-24 12:28:32 -08001379
1380#ifdef SK_PDF_IMAGE_STATS
halcanary7a14b312015-10-01 07:28:13 -07001381 SkPDFImageDumpStats();
mtkleinafae30a2016-02-24 12:28:32 -08001382#endif // SK_PDF_IMAGE_STATS
1383
Herb Derby5a523fe2017-01-26 16:48:28 -05001384 SkGraphics::PurgeAllCaches();
mtkleinc41fd922016-03-08 09:01:39 -08001385 info("Finished!\n");
mtklein748ca3b2015-01-15 10:56:12 -08001386 return 0;
mtklein@google.comd36522d2013-10-16 13:02:15 +00001387}
jcgregorio3b27ade2014-11-13 08:06:40 -08001388
kkinnunen179a8f52015-11-20 13:32:24 -08001389// TODO: currently many GPU tests are declared outside SK_SUPPORT_GPU guards.
1390// Thus we export the empty RunWithGPUTestContexts when SK_SUPPORT_GPU=0.
1391namespace skiatest {
bsalomon758586c2016-04-06 14:02:39 -07001392
1393#if SK_SUPPORT_GPU
1394bool IsGLContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1395 return kOpenGL_GrBackend == GrContextFactory::ContextTypeBackend(type);
1396}
bsalomondc0fcd42016-04-11 14:21:33 -07001397bool IsVulkanContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1398 return kVulkan_GrBackend == GrContextFactory::ContextTypeBackend(type);
1399}
bsalomon758586c2016-04-06 14:02:39 -07001400bool IsRenderingGLContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1401 return IsGLContextType(type) && GrContextFactory::IsRenderingContext(type);
1402}
1403bool IsNullGLContextType(sk_gpu_test::GrContextFactory::ContextType type) {
1404 return type == GrContextFactory::kNullGL_ContextType;
1405}
1406#else
1407bool IsGLContextType(int) { return false; }
bsalomondc0fcd42016-04-11 14:21:33 -07001408bool IsVulkanContextType(int) { return false; }
bsalomon758586c2016-04-06 14:02:39 -07001409bool IsRenderingGLContextType(int) { return false; }
1410bool IsNullGLContextType(int) { return false; }
1411#endif
1412
1413void RunWithGPUTestContexts(GrContextTestFn* test, GrContextTypeFilterFn* contextTypeFilter,
bsalomonf2f1c172016-04-05 12:59:06 -07001414 Reporter* reporter, GrContextFactory* factory) {
kkinnunen179a8f52015-11-20 13:32:24 -08001415#if SK_SUPPORT_GPU
kkinnunen3e980c32015-12-23 01:33:00 -08001416
Brian Salomon6405e712017-03-20 08:54:16 -04001417#if defined(SK_BUILD_FOR_UNIX) || defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC)
1418 static constexpr auto kNativeGLType = GrContextFactory::kGL_ContextType;
1419#else
1420 static constexpr auto kNativeGLType = GrContextFactory::kGLES_ContextType;
1421#endif
1422
bsalomon758586c2016-04-06 14:02:39 -07001423 for (int typeInt = 0; typeInt < GrContextFactory::kContextTypeCnt; ++typeInt) {
1424 GrContextFactory::ContextType contextType = (GrContextFactory::ContextType) typeInt;
Brian Osmanaa2219c2016-12-05 10:12:17 -05001425 // Use "native" instead of explicitly trying OpenGL and OpenGL ES. Do not use GLES on
bsalomon758586c2016-04-06 14:02:39 -07001426 // desktop since tests do not account for not fixing http://skbug.com/2809
1427 if (contextType == GrContextFactory::kGL_ContextType ||
1428 contextType == GrContextFactory::kGLES_ContextType) {
Brian Salomon6405e712017-03-20 08:54:16 -04001429 if (contextType != kNativeGLType) {
bsalomon758586c2016-04-06 14:02:39 -07001430 continue;
1431 }
1432 }
csmartdaltone812d492017-02-21 12:36:05 -07001433 ContextInfo ctxInfo = factory->getContextInfo(contextType,
1434 GrContextFactory::ContextOverrides::kDisableNVPR);
Brian Osmanaa2219c2016-12-05 10:12:17 -05001435 if (contextTypeFilter && !(*contextTypeFilter)(contextType)) {
1436 continue;
1437 }
Greg Daniela5cb7812017-06-16 09:45:32 -04001438 ReporterContext ctx(reporter, SkString(GrContextFactory::ContextTypeName(contextType)));
bsalomon8b7451a2016-05-11 06:33:06 -07001439 if (ctxInfo.grContext()) {
bsalomonf2f1c172016-04-05 12:59:06 -07001440 (*test)(reporter, ctxInfo);
kkinnunen5219fd92015-12-10 06:28:13 -08001441 }
bsalomonf2f1c172016-04-05 12:59:06 -07001442 ctxInfo = factory->getContextInfo(contextType,
csmartdaltone812d492017-02-21 12:36:05 -07001443 GrContextFactory::ContextOverrides::kRequireNVPRSupport);
bsalomon8b7451a2016-05-11 06:33:06 -07001444 if (ctxInfo.grContext()) {
bsalomonf2f1c172016-04-05 12:59:06 -07001445 (*test)(reporter, ctxInfo);
kkinnunen179a8f52015-11-20 13:32:24 -08001446 }
1447 }
1448#endif
1449}
kkinnunen179a8f52015-11-20 13:32:24 -08001450} // namespace skiatest