1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "dm/DMJsonWriter.h"
9 #include "dm/DMSrcSink.h"
10 #include "include/codec/SkCodec.h"
11 #include "include/core/SkBBHFactory.h"
12 #include "include/core/SkColorPriv.h"
13 #include "include/core/SkColorSpace.h"
14 #include "include/core/SkData.h"
15 #include "include/core/SkDocument.h"
16 #include "include/core/SkFontMgr.h"
17 #include "include/core/SkGraphics.h"
18 #include "include/ports/SkTypeface_win.h"
19 #include "include/private/SkChecksum.h"
20 #include "include/private/SkHalf.h"
21 #include "include/private/SkSpinlock.h"
22 #include "include/private/SkTHash.h"
23 #include "src/core/SkColorSpacePriv.h"
24 #include "src/core/SkLeanWindows.h"
25 #include "src/core/SkMD5.h"
26 #include "src/core/SkOSFile.h"
27 #include "src/core/SkTaskGroup.h"
28 #include "src/utils/SkOSPath.h"
29 #include "tests/Test.h"
30 #include "tools/AutoreleasePool.h"
31 #include "tools/HashAndEncode.h"
32 #include "tools/ProcStats.h"
33 #include "tools/Resources.h"
34 #include "tools/ToolUtils.h"
35 #include "tools/flags/CommonFlags.h"
36 #include "tools/flags/CommonFlagsConfig.h"
37 #include "tools/ios_utils.h"
38 #include "tools/trace/ChromeTracingTracer.h"
39 #include "tools/trace/EventTracingPriv.h"
40 #include "tools/trace/SkDebugfTracer.h"
41
42 #include <vector>
43
44 #include <stdlib.h>
45
46 #ifndef SK_BUILD_FOR_WIN
47 #include <unistd.h>
48 #endif
49
50 #if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_HAS_HEIF_LIBRARY)
51 #include <binder/IPCThreadState.h>
52 #endif
53
54 extern bool gSkForceRasterPipelineBlitter;
55
56 static DEFINE_string(src, "tests gm skp image", "Source types to test.");
57 static DEFINE_bool(nameByHash, false,
58 "If true, write to FLAGS_writePath[0]/<hash>.png instead of "
59 "to FLAGS_writePath[0]/<config>/<sourceType>/<sourceOptions>/<name>.png");
60 static DEFINE_bool2(pathOpsExtended, x, false, "Run extended pathOps tests.");
61 static DEFINE_string(matrix, "1 0 0 1",
62 "2x2 scale+skew matrix to apply or upright when using "
63 "'matrix' or 'upright' in config.");
64 static DEFINE_bool(gpu_threading, false, "Allow GPU work to run on multiple threads?");
65
66 static DEFINE_string(blacklist, "",
67 "Space-separated config/src/srcOptions/name quadruples to blacklist. "
68 "'_' matches anything. '~' negates the match. 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.\n"
71 "'--blacklist ~8888 svg _ svgparse_' blocks non-8888 SVGs that contain \"svgparse_\" in "
72 "the name.");
73
74 static DEFINE_string2(readPath, r, "",
75 "If set check for equality with golden results in this directory.");
76 DEFINE_string2(writePath, w, "", "If set, write bitmaps here as .pngs.");
77
78
79 static DEFINE_string(uninterestingHashesFile, "",
80 "File containing a list of uninteresting hashes. If a result hashes to something in "
81 "this list, no image is written for that result.");
82
83 static DEFINE_int(shards, 1, "We're splitting source data into this many shards.");
84 static DEFINE_int(shard, 0, "Which shard do I run?");
85
86 static DEFINE_string(mskps, "", "Directory to read mskps from, or a single mskp file.");
87 static DEFINE_bool(forceRasterPipeline, false, "sets gSkForceRasterPipelineBlitter");
88
89 static DEFINE_string(bisect, "",
90 "Pair of: SKP file to bisect, followed by an l/r bisect trail string (e.g., 'lrll'). The "
91 "l/r trail specifies which half to keep at each step of a binary search through the SKP's "
92 "paths. An empty string performs no bisect. Only the SkPaths are bisected; all other draws "
93 "are thrown out. This is useful for finding a reduced repo case for path drawing bugs.");
94
95 static DEFINE_bool(ignoreSigInt, false, "ignore SIGINT signals during test execution");
96
97 static DEFINE_string(dont_write, "", "File extensions to skip writing to --writePath."); // See skia:6821
98
99 static DEFINE_bool(checkF16, false, "Ensure that F16Norm pixels are clamped.");
100
101 static DEFINE_string(colorImages, "",
102 "List of images and/or directories to decode with color correction. "
103 "A directory with no images is treated as a fatal error.");
104
105 static DEFINE_bool2(veryVerbose, V, false, "tell individual tests to be verbose.");
106
107 static DEFINE_bool(cpu, true, "master switch for running CPU-bound work.");
108 static DEFINE_bool(gpu, true, "master switch for running GPU-bound work.");
109
110 static DEFINE_bool(dryRun, false,
111 "just print the tests that would be run, without actually running them.");
112
113 static DEFINE_string(images, "",
114 "List of images and/or directories to decode. A directory with no images"
115 " is treated as a fatal error.");
116
117 static DEFINE_bool(simpleCodec, false,
118 "Runs of a subset of the codec tests, "
119 "with no scaling or subsetting, always using the canvas color type.");
120
121 static DEFINE_string2(match, m, nullptr,
122 "[~][^]substring[$] [...] of name to run.\n"
123 "Multiple matches may be separated by spaces.\n"
124 "~ causes a matching name to always be skipped\n"
125 "^ requires the start of the name to match\n"
126 "$ requires the end of the name to match\n"
127 "^ and $ requires an exact match\n"
128 "If a name does not match any list entry,\n"
129 "it is skipped unless some list entry starts with ~");
130
131 static DEFINE_bool2(quiet, q, false, "if true, don't print status updates.");
132 static DEFINE_bool2(verbose, v, false, "enable verbose output from the test driver.");
133
134 static DEFINE_string(skps, "skps", "Directory to read skps from.");
135 static DEFINE_string(lotties, "lotties", "Directory to read (Bodymovin) jsons from.");
136 static DEFINE_string(svgs, "", "Directory to read SVGs from, or a single SVG file.");
137
138 static DEFINE_int_2(threads, j, -1,
139 "Run threadsafe tests on a threadpool with this many extra threads, "
140 "defaulting to one extra thread per core.");
141
142 static DEFINE_string(key, "",
143 "Space-separated key/value pairs to add to JSON identifying this builder.");
144 static DEFINE_string(properties, "",
145 "Space-separated key/value pairs to add to JSON identifying this run.");
146
147
148 #if defined(__MSVC_RUNTIME_CHECKS)
149 #include <rtcapi.h>
RuntimeCheckErrorFunc(int errorType,const char * filename,int linenumber,const char * moduleName,const char * fmt,...)150 int RuntimeCheckErrorFunc(int errorType, const char* filename, int linenumber,
151 const char* moduleName, const char* fmt, ...) {
152 va_list args;
153 va_start(args, fmt);
154 vfprintf(stderr, fmt, args);
155 va_end(args);
156
157 SkDebugf("Line #%d\nFile: %s\nModule: %s\n",
158 linenumber, filename ? filename : "Unknown", moduleName ? moduleName : "Unknwon");
159 return 1;
160 }
161 #endif
162
163 using namespace DM;
164 using sk_gpu_test::GrContextFactory;
165 using sk_gpu_test::GLTestContext;
166 using sk_gpu_test::ContextInfo;
167
168 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
169
rec2020()170 static sk_sp<SkColorSpace> rec2020() {
171 return SkColorSpace::MakeRGB(SkNamedTransferFn::kRec2020, SkNamedGamut::kRec2020);
172 }
173
174 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
175
176 static FILE* gVLog;
177
178 template <typename... Args>
vlog(const char * fmt,Args &&...args)179 static void vlog(const char* fmt, Args&&... args) {
180 if (gVLog) {
181 fprintf(gVLog, fmt, args...);
182 fflush(gVLog);
183 }
184 }
185
186 template <typename... Args>
info(const char * fmt,Args &&...args)187 static void info(const char* fmt, Args&&... args) {
188 vlog(fmt, args...);
189 if (!FLAGS_quiet) {
190 printf(fmt, args...);
191 }
192 }
info(const char * fmt)193 static void info(const char* fmt) {
194 if (!FLAGS_quiet) {
195 printf("%s", fmt); // Clang warns printf(fmt) is insecure.
196 }
197 }
198
199 static SkTArray<SkString> gFailures;
200
fail(const SkString & err)201 static void fail(const SkString& err) {
202 static SkSpinlock mutex;
203 SkAutoSpinlock lock(mutex);
204 SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
205 gFailures.push_back(err);
206 }
207
208 struct Running {
209 SkString id;
210 SkThreadID thread;
211
dumpRunning212 void dump() const {
213 info("\t%s\n", id.c_str());
214 }
215 };
216
dump_json()217 static void dump_json() {
218 if (!FLAGS_writePath.isEmpty()) {
219 JsonWriter::DumpJson(FLAGS_writePath[0], FLAGS_key, FLAGS_properties);
220 }
221 }
222
223 // We use a spinlock to make locking this in a signal handler _somewhat_ safe.
224 static SkSpinlock gMutex;
225 static int gPending;
226 static SkTArray<Running> gRunning;
227
done(const char * config,const char * src,const char * srcOptions,const char * name)228 static void done(const char* config, const char* src, const char* srcOptions, const char* name) {
229 SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
230 vlog("done %s\n", id.c_str());
231 int pending;
232 {
233 SkAutoSpinlock lock(gMutex);
234 for (int i = 0; i < gRunning.count(); i++) {
235 if (gRunning[i].id == id) {
236 gRunning.removeShuffle(i);
237 break;
238 }
239 }
240 pending = --gPending;
241 }
242
243 // We write out dm.json file and print out a progress update every once in a while.
244 // Notice this also handles the final dm.json and progress update when pending == 0.
245 if (pending % 500 == 0) {
246 dump_json();
247
248 int curr = sk_tools::getCurrResidentSetSizeMB(),
249 peak = sk_tools::getMaxResidentSetSizeMB();
250
251 SkAutoSpinlock lock(gMutex);
252 info("\n%dMB RAM, %dMB peak, %d queued, %d active:\n",
253 curr, peak, gPending - gRunning.count(), gRunning.count());
254 for (auto& task : gRunning) {
255 task.dump();
256 }
257 }
258 }
259
start(const char * config,const char * src,const char * srcOptions,const char * name)260 static void start(const char* config, const char* src, const char* srcOptions, const char* name) {
261 SkString id = SkStringPrintf("%s %s %s %s", config, src, srcOptions, name);
262 vlog("start %s\n", id.c_str());
263 SkAutoSpinlock lock(gMutex);
264 gRunning.push_back({id,SkGetThreadID()});
265 }
266
find_culprit()267 static void find_culprit() {
268 // Assumes gMutex is locked.
269 SkThreadID thisThread = SkGetThreadID();
270 for (auto& task : gRunning) {
271 if (task.thread == thisThread) {
272 info("Likely culprit:\n");
273 task.dump();
274 }
275 }
276 }
277
278 #if defined(SK_BUILD_FOR_WIN)
crash_handler(EXCEPTION_POINTERS * e)279 static LONG WINAPI crash_handler(EXCEPTION_POINTERS* e) {
280 static const struct {
281 const char* name;
282 DWORD code;
283 } kExceptions[] = {
284 #define _(E) {#E, E}
285 _(EXCEPTION_ACCESS_VIOLATION),
286 _(EXCEPTION_BREAKPOINT),
287 _(EXCEPTION_INT_DIVIDE_BY_ZERO),
288 _(EXCEPTION_STACK_OVERFLOW),
289 // TODO: more?
290 #undef _
291 };
292
293 SkAutoSpinlock lock(gMutex);
294
295 const DWORD code = e->ExceptionRecord->ExceptionCode;
296 info("\nCaught exception %u", code);
297 for (const auto& exception : kExceptions) {
298 if (exception.code == code) {
299 info(" %s", exception.name);
300 }
301 }
302 info(", was running:\n");
303 for (auto& task : gRunning) {
304 task.dump();
305 }
306 find_culprit();
307 fflush(stdout);
308
309 // Execute default exception handler... hopefully, exit.
310 return EXCEPTION_EXECUTE_HANDLER;
311 }
312
setup_crash_handler()313 static void setup_crash_handler() {
314 SetUnhandledExceptionFilter(crash_handler);
315 }
316 #else
317 #include <signal.h>
318 #if !defined(SK_BUILD_FOR_ANDROID)
319 #include <execinfo.h>
320
321 #endif
322
max_of()323 static constexpr int max_of() { return 0; }
324 template <typename... Rest>
max_of(int x,Rest...rest)325 static constexpr int max_of(int x, Rest... rest) {
326 return x > max_of(rest...) ? x : max_of(rest...);
327 }
328
329 static void (*previous_handler[max_of(SIGABRT,SIGBUS,SIGFPE,SIGILL,SIGSEGV,SIGTERM)+1])(int);
330
crash_handler(int sig)331 static void crash_handler(int sig) {
332 SkAutoSpinlock lock(gMutex);
333
334 info("\nCaught signal %d [%s] (%dMB RAM, peak %dMB), was running:\n",
335 sig, strsignal(sig),
336 sk_tools::getCurrResidentSetSizeMB(), sk_tools::getMaxResidentSetSizeMB());
337
338 for (auto& task : gRunning) {
339 task.dump();
340 }
341 find_culprit();
342
343 #if !defined(SK_BUILD_FOR_ANDROID)
344 void* stack[64];
345 int count = backtrace(stack, SK_ARRAY_COUNT(stack));
346 char** symbols = backtrace_symbols(stack, count);
347 info("\nStack trace:\n");
348 for (int i = 0; i < count; i++) {
349 info(" %s\n", symbols[i]);
350 }
351 #endif
352 fflush(stdout);
353
354 if (sig == SIGINT && FLAGS_ignoreSigInt) {
355 info("Ignoring signal %d because of --ignoreSigInt.\n"
356 "This is probably a sign the bot is overloaded with work.\n", sig);
357 } else {
358 signal(sig, previous_handler[sig]);
359 raise(sig);
360 }
361 }
362
setup_crash_handler()363 static void setup_crash_handler() {
364 const int kSignals[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGINT, SIGSEGV, SIGTERM };
365 for (int sig : kSignals) {
366 previous_handler[sig] = signal(sig, crash_handler);
367 }
368 }
369 #endif
370
371 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
372
373 struct Gold : public SkString {
GoldGold374 Gold() : SkString("") {}
GoldGold375 Gold(const SkString& sink, const SkString& src,
376 const SkString& srcOptions, const SkString& name,
377 const SkString& md5)
378 : SkString("") {
379 this->append(sink);
380 this->append(src);
381 this->append(srcOptions);
382 this->append(name);
383 this->append(md5);
384 }
385 struct Hash {
operator ()Gold::Hash386 uint32_t operator()(const Gold& g) const {
387 return SkGoodHash()((const SkString&)g);
388 }
389 };
390 };
391 static SkTHashSet<Gold, Gold::Hash> gGold;
392
add_gold(JsonWriter::BitmapResult r)393 static void add_gold(JsonWriter::BitmapResult r) {
394 gGold.add(Gold(r.config, r.sourceType, r.sourceOptions, r.name, r.md5));
395 }
396
gather_gold()397 static void gather_gold() {
398 if (!FLAGS_readPath.isEmpty()) {
399 SkString path(FLAGS_readPath[0]);
400 path.append("/dm.json");
401 if (!JsonWriter::ReadJson(path.c_str(), add_gold)) {
402 fail(SkStringPrintf("Couldn't read %s for golden results.", path.c_str()));
403 }
404 }
405 }
406
407 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
408
409 #if defined(SK_BUILD_FOR_WIN)
410 static const char* kNewline = "\r\n";
411 #else
412 static const char* kNewline = "\n";
413 #endif
414
415 static SkTHashSet<SkString> gUninterestingHashes;
416
gather_uninteresting_hashes()417 static void gather_uninteresting_hashes() {
418 if (!FLAGS_uninterestingHashesFile.isEmpty()) {
419 sk_sp<SkData> data(SkData::MakeFromFileName(FLAGS_uninterestingHashesFile[0]));
420 if (!data) {
421 info("WARNING: unable to read uninteresting hashes from %s\n",
422 FLAGS_uninterestingHashesFile[0]);
423 return;
424 }
425
426 // Copy to a string to make sure SkStrSplit has a terminating \0 to find.
427 SkString contents((const char*)data->data(), data->size());
428
429 SkTArray<SkString> hashes;
430 SkStrSplit(contents.c_str(), kNewline, &hashes);
431 for (const SkString& hash : hashes) {
432 gUninterestingHashes.add(hash);
433 }
434 info("FYI: loaded %d distinct uninteresting hashes from %d lines\n",
435 gUninterestingHashes.count(), hashes.count());
436 }
437 }
438
439 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
440
441 struct TaggedSrc : public std::unique_ptr<Src> {
442 SkString tag;
443 SkString options;
444 };
445
446 struct TaggedSink : public std::unique_ptr<Sink> {
447 SkString tag;
448 };
449
450 static const bool kMemcpyOK = true;
451
452 static SkTArray<TaggedSrc, kMemcpyOK> gSrcs;
453 static SkTArray<TaggedSink, kMemcpyOK> gSinks;
454
in_shard()455 static bool in_shard() {
456 static int N = 0;
457 return N++ % FLAGS_shards == FLAGS_shard;
458 }
459
push_src(const char * tag,ImplicitString options,Src * s)460 static void push_src(const char* tag, ImplicitString options, Src* s) {
461 std::unique_ptr<Src> src(s);
462 if (in_shard() && FLAGS_src.contains(tag) &&
463 !CommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
464 TaggedSrc& s = gSrcs.push_back();
465 s.reset(src.release());
466 s.tag = tag;
467 s.options = options;
468 }
469 }
470
push_codec_src(Path path,CodecSrc::Mode mode,CodecSrc::DstColorType dstColorType,SkAlphaType dstAlphaType,float scale)471 static void push_codec_src(Path path, CodecSrc::Mode mode, CodecSrc::DstColorType dstColorType,
472 SkAlphaType dstAlphaType, float scale) {
473 if (FLAGS_simpleCodec) {
474 const bool simple = CodecSrc::kCodec_Mode == mode || CodecSrc::kAnimated_Mode == mode;
475 if (!simple || dstColorType != CodecSrc::kGetFromCanvas_DstColorType || scale != 1.0f) {
476 // Only decode in the simple case.
477 return;
478 }
479 }
480 SkString folder;
481 switch (mode) {
482 case CodecSrc::kCodec_Mode:
483 folder.append("codec");
484 break;
485 case CodecSrc::kCodecZeroInit_Mode:
486 folder.append("codec_zero_init");
487 break;
488 case CodecSrc::kScanline_Mode:
489 folder.append("scanline");
490 break;
491 case CodecSrc::kStripe_Mode:
492 folder.append("stripe");
493 break;
494 case CodecSrc::kCroppedScanline_Mode:
495 folder.append("crop");
496 break;
497 case CodecSrc::kSubset_Mode:
498 folder.append("codec_subset");
499 break;
500 case CodecSrc::kAnimated_Mode:
501 folder.append("codec_animated");
502 break;
503 }
504
505 switch (dstColorType) {
506 case CodecSrc::kGrayscale_Always_DstColorType:
507 folder.append("_kGray8");
508 break;
509 case CodecSrc::kNonNative8888_Always_DstColorType:
510 folder.append("_kNonNative");
511 break;
512 default:
513 break;
514 }
515
516 switch (dstAlphaType) {
517 case kPremul_SkAlphaType:
518 folder.append("_premul");
519 break;
520 case kUnpremul_SkAlphaType:
521 folder.append("_unpremul");
522 break;
523 default:
524 break;
525 }
526
527 if (1.0f != scale) {
528 folder.appendf("_%.3f", scale);
529 }
530
531 CodecSrc* src = new CodecSrc(path, mode, dstColorType, dstAlphaType, scale);
532 push_src("image", folder, src);
533 }
534
push_android_codec_src(Path path,CodecSrc::DstColorType dstColorType,SkAlphaType dstAlphaType,int sampleSize)535 static void push_android_codec_src(Path path, CodecSrc::DstColorType dstColorType,
536 SkAlphaType dstAlphaType, int sampleSize) {
537 SkString folder;
538 folder.append("scaled_codec");
539
540 switch (dstColorType) {
541 case CodecSrc::kGrayscale_Always_DstColorType:
542 folder.append("_kGray8");
543 break;
544 case CodecSrc::kNonNative8888_Always_DstColorType:
545 folder.append("_kNonNative");
546 break;
547 default:
548 break;
549 }
550
551 switch (dstAlphaType) {
552 case kPremul_SkAlphaType:
553 folder.append("_premul");
554 break;
555 case kUnpremul_SkAlphaType:
556 folder.append("_unpremul");
557 break;
558 default:
559 break;
560 }
561
562 if (1 != sampleSize) {
563 folder.appendf("_%.3f", 1.0f / (float) sampleSize);
564 }
565
566 AndroidCodecSrc* src = new AndroidCodecSrc(path, dstColorType, dstAlphaType, sampleSize);
567 push_src("image", folder, src);
568 }
569
push_image_gen_src(Path path,ImageGenSrc::Mode mode,SkAlphaType alphaType,bool isGpu)570 static void push_image_gen_src(Path path, ImageGenSrc::Mode mode, SkAlphaType alphaType, bool isGpu)
571 {
572 SkString folder;
573 switch (mode) {
574 case ImageGenSrc::kCodec_Mode:
575 folder.append("gen_codec");
576 break;
577 case ImageGenSrc::kPlatform_Mode:
578 folder.append("gen_platform");
579 break;
580 }
581
582 if (isGpu) {
583 folder.append("_gpu");
584 } else {
585 switch (alphaType) {
586 case kOpaque_SkAlphaType:
587 folder.append("_opaque");
588 break;
589 case kPremul_SkAlphaType:
590 folder.append("_premul");
591 break;
592 case kUnpremul_SkAlphaType:
593 folder.append("_unpremul");
594 break;
595 default:
596 break;
597 }
598 }
599
600 ImageGenSrc* src = new ImageGenSrc(path, mode, alphaType, isGpu);
601 push_src("image", folder, src);
602 }
603
push_brd_src(Path path,CodecSrc::DstColorType dstColorType,BRDSrc::Mode mode,uint32_t sampleSize)604 static void push_brd_src(Path path, CodecSrc::DstColorType dstColorType, BRDSrc::Mode mode,
605 uint32_t sampleSize) {
606 SkString folder("brd_android_codec");
607 switch (mode) {
608 case BRDSrc::kFullImage_Mode:
609 break;
610 case BRDSrc::kDivisor_Mode:
611 folder.append("_divisor");
612 break;
613 default:
614 SkASSERT(false);
615 return;
616 }
617
618 switch (dstColorType) {
619 case CodecSrc::kGetFromCanvas_DstColorType:
620 break;
621 case CodecSrc::kGrayscale_Always_DstColorType:
622 folder.append("_kGray");
623 break;
624 default:
625 SkASSERT(false);
626 return;
627 }
628
629 if (1 != sampleSize) {
630 folder.appendf("_%.3f", 1.0f / (float) sampleSize);
631 }
632
633 BRDSrc* src = new BRDSrc(path, mode, dstColorType, sampleSize);
634 push_src("image", folder, src);
635 }
636
push_brd_srcs(Path path,bool gray)637 static void push_brd_srcs(Path path, bool gray) {
638 if (gray) {
639 // Only run grayscale to one sampleSize and Mode. Though interesting
640 // to test grayscale, it should not reveal anything across various
641 // sampleSizes and Modes
642 // Arbitrarily choose Mode and sampleSize.
643 push_brd_src(path, CodecSrc::kGrayscale_Always_DstColorType,
644 BRDSrc::kFullImage_Mode, 2);
645 }
646
647 // Test on a variety of sampleSizes, making sure to include:
648 // - 2, 4, and 8, which are natively supported by jpeg
649 // - multiples of 2 which are not divisible by 4 (analogous for 4)
650 // - larger powers of two, since BRD clients generally use powers of 2
651 // We will only produce output for the larger sizes on large images.
652 const uint32_t sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 24, 32, 64 };
653
654 const BRDSrc::Mode modes[] = { BRDSrc::kFullImage_Mode, BRDSrc::kDivisor_Mode, };
655
656 for (uint32_t sampleSize : sampleSizes) {
657 for (BRDSrc::Mode mode : modes) {
658 push_brd_src(path, CodecSrc::kGetFromCanvas_DstColorType, mode, sampleSize);
659 }
660 }
661 }
662
push_codec_srcs(Path path)663 static void push_codec_srcs(Path path) {
664 sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
665 if (!encoded) {
666 info("Couldn't read %s.", path.c_str());
667 return;
668 }
669 std::unique_ptr<SkCodec> codec = SkCodec::MakeFromData(encoded);
670 if (nullptr == codec.get()) {
671 info("Couldn't create codec for %s.", path.c_str());
672 return;
673 }
674
675 // native scaling is only supported by WEBP and JPEG
676 bool supportsNativeScaling = false;
677
678 SkTArray<CodecSrc::Mode> nativeModes;
679 nativeModes.push_back(CodecSrc::kCodec_Mode);
680 nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
681 switch (codec->getEncodedFormat()) {
682 case SkEncodedImageFormat::kJPEG:
683 nativeModes.push_back(CodecSrc::kScanline_Mode);
684 nativeModes.push_back(CodecSrc::kStripe_Mode);
685 nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
686 supportsNativeScaling = true;
687 break;
688 case SkEncodedImageFormat::kWEBP:
689 nativeModes.push_back(CodecSrc::kSubset_Mode);
690 supportsNativeScaling = true;
691 break;
692 case SkEncodedImageFormat::kDNG:
693 break;
694 default:
695 nativeModes.push_back(CodecSrc::kScanline_Mode);
696 break;
697 }
698
699 SkTArray<CodecSrc::DstColorType> colorTypes;
700 colorTypes.push_back(CodecSrc::kGetFromCanvas_DstColorType);
701 colorTypes.push_back(CodecSrc::kNonNative8888_Always_DstColorType);
702 switch (codec->getInfo().colorType()) {
703 case kGray_8_SkColorType:
704 colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
705 break;
706 default:
707 break;
708 }
709
710 SkTArray<SkAlphaType> alphaModes;
711 alphaModes.push_back(kPremul_SkAlphaType);
712 if (codec->getInfo().alphaType() != kOpaque_SkAlphaType) {
713 alphaModes.push_back(kUnpremul_SkAlphaType);
714 }
715
716 for (CodecSrc::Mode mode : nativeModes) {
717 for (CodecSrc::DstColorType colorType : colorTypes) {
718 for (SkAlphaType alphaType : alphaModes) {
719 // Only test kCroppedScanline_Mode when the alpha type is premul. The test is
720 // slow and won't be interestingly different with different alpha types.
721 if (CodecSrc::kCroppedScanline_Mode == mode &&
722 kPremul_SkAlphaType != alphaType) {
723 continue;
724 }
725
726 push_codec_src(path, mode, colorType, alphaType, 1.0f);
727
728 // Skip kNonNative on different native scales. It won't be interestingly
729 // different.
730 if (supportsNativeScaling &&
731 CodecSrc::kNonNative8888_Always_DstColorType == colorType) {
732 // Native Scales
733 // SkJpegCodec natively supports scaling to the following:
734 for (auto scale : { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f }) {
735 push_codec_src(path, mode, colorType, alphaType, scale);
736 }
737 }
738 }
739 }
740 }
741
742 {
743 std::vector<SkCodec::FrameInfo> frameInfos = codec->getFrameInfo();
744 if (frameInfos.size() > 1) {
745 for (auto dstCT : { CodecSrc::kNonNative8888_Always_DstColorType,
746 CodecSrc::kGetFromCanvas_DstColorType }) {
747 for (auto at : { kUnpremul_SkAlphaType, kPremul_SkAlphaType }) {
748 push_codec_src(path, CodecSrc::kAnimated_Mode, dstCT, at, 1.0f);
749 }
750 }
751 }
752
753 }
754
755 if (FLAGS_simpleCodec) {
756 return;
757 }
758
759 const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
760
761 for (int sampleSize : sampleSizes) {
762 for (CodecSrc::DstColorType colorType : colorTypes) {
763 for (SkAlphaType alphaType : alphaModes) {
764 // We can exercise all of the kNonNative support code in the swizzler with just a
765 // few sample sizes. Skip the rest.
766 if (CodecSrc::kNonNative8888_Always_DstColorType == colorType && sampleSize > 3) {
767 continue;
768 }
769
770 push_android_codec_src(path, colorType, alphaType, sampleSize);
771 }
772 }
773 }
774
775 const char* ext = strrchr(path.c_str(), '.');
776 if (ext) {
777 ext++;
778
779 static const char* const rawExts[] = {
780 "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
781 "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
782 };
783 for (const char* rawExt : rawExts) {
784 if (0 == strcmp(rawExt, ext)) {
785 // RAW is not supported by image generator (skbug.com/5079) or BRD.
786 return;
787 }
788 }
789
790 static const char* const brdExts[] = {
791 "jpg", "jpeg", "png", "webp",
792 "JPG", "JPEG", "PNG", "WEBP",
793 };
794 for (const char* brdExt : brdExts) {
795 if (0 == strcmp(brdExt, ext)) {
796 bool gray = codec->getInfo().colorType() == kGray_8_SkColorType;
797 push_brd_srcs(path, gray);
798 break;
799 }
800 }
801 }
802
803 // Push image generator GPU test.
804 push_image_gen_src(path, ImageGenSrc::kCodec_Mode, codec->getInfo().alphaType(), true);
805
806 // Push image generator CPU tests.
807 for (SkAlphaType alphaType : alphaModes) {
808 push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
809
810 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
811 if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
812 SkEncodedImageFormat::kWBMP != codec->getEncodedFormat() &&
813 kUnpremul_SkAlphaType != alphaType)
814 {
815 push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
816 }
817 #elif defined(SK_BUILD_FOR_WIN)
818 if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
819 SkEncodedImageFormat::kWBMP != codec->getEncodedFormat())
820 {
821 push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
822 }
823 #endif
824 }
825 }
826
827 template <typename T>
gather_file_srcs(const CommandLineFlags::StringArray & flags,const char * ext,const char * src_name=nullptr)828 void gather_file_srcs(const CommandLineFlags::StringArray& flags,
829 const char* ext,
830 const char* src_name = nullptr) {
831 if (!src_name) {
832 // With the exception of Lottie files, the source name is the extension.
833 src_name = ext;
834 }
835
836 for (int i = 0; i < flags.count(); i++) {
837 const char* path = flags[i];
838 if (sk_isdir(path)) {
839 SkOSFile::Iter it(path, ext);
840 for (SkString file; it.next(&file); ) {
841 push_src(src_name, "", new T(SkOSPath::Join(path, file.c_str())));
842 }
843 } else {
844 push_src(src_name, "", new T(path));
845 }
846 }
847 }
848
gather_srcs()849 static bool gather_srcs() {
850 for (skiagm::GMFactory f : skiagm::GMRegistry::Range()) {
851 push_src("gm", "", new GMSrc(f));
852 }
853
854 gather_file_srcs<SKPSrc>(FLAGS_skps, "skp");
855 gather_file_srcs<MSKPSrc>(FLAGS_mskps, "mskp");
856 #if defined(SK_ENABLE_SKOTTIE)
857 gather_file_srcs<SkottieSrc>(FLAGS_lotties, "json", "lottie");
858 #endif
859 #if defined(SK_XML)
860 gather_file_srcs<SVGSrc>(FLAGS_svgs, "svg");
861 #endif
862 if (!FLAGS_bisect.isEmpty()) {
863 // An empty l/r trail string will draw all the paths.
864 push_src("bisect", "",
865 new BisectSrc(FLAGS_bisect[0], FLAGS_bisect.count() > 1 ? FLAGS_bisect[1] : ""));
866 }
867
868 SkTArray<SkString> images;
869 if (!CollectImages(FLAGS_images, &images)) {
870 return false;
871 }
872
873 for (auto image : images) {
874 push_codec_srcs(image);
875 }
876
877 SkTArray<SkString> colorImages;
878 if (!CollectImages(FLAGS_colorImages, &colorImages)) {
879 return false;
880 }
881
882 for (auto colorImage : colorImages) {
883 push_src("colorImage", "decode_native", new ColorCodecSrc(colorImage, false));
884 push_src("colorImage", "decode_to_dst", new ColorCodecSrc(colorImage, true));
885 }
886
887 return true;
888 }
889
push_sink(const SkCommandLineConfig & config,Sink * s)890 static void push_sink(const SkCommandLineConfig& config, Sink* s) {
891 std::unique_ptr<Sink> sink(s);
892
893 // Try a simple Src as a canary. If it fails, skip this sink.
894 struct : public Src {
895 Error draw(SkCanvas* c) const override {
896 c->drawRect(SkRect::MakeWH(1,1), SkPaint());
897 return "";
898 }
899 SkISize size() const override { return SkISize::Make(16, 16); }
900 Name name() const override { return "justOneRect"; }
901 } justOneRect;
902
903 SkBitmap bitmap;
904 SkDynamicMemoryWStream stream;
905 SkString log;
906 Error err = sink->draw(justOneRect, &bitmap, &stream, &log);
907 if (err.isFatal()) {
908 info("Could not run %s: %s\n", config.getTag().c_str(), err.c_str());
909 exit(1);
910 }
911
912 TaggedSink& ts = gSinks.push_back();
913 ts.reset(sink.release());
914 ts.tag = config.getTag();
915 }
916
rgb_to_gbr()917 static sk_sp<SkColorSpace> rgb_to_gbr() {
918 return SkColorSpace::MakeSRGB()->makeColorSpin();
919 }
920
create_sink(const GrContextOptions & grCtxOptions,const SkCommandLineConfig * config)921 static Sink* create_sink(const GrContextOptions& grCtxOptions, const SkCommandLineConfig* config) {
922 if (FLAGS_gpu) {
923 if (const SkCommandLineConfigGpu* gpuConfig = config->asConfigGpu()) {
924 GrContextFactory::ContextType contextType = gpuConfig->getContextType();
925 GrContextFactory::ContextOverrides contextOverrides = gpuConfig->getContextOverrides();
926 GrContextFactory testFactory(grCtxOptions);
927 if (!testFactory.get(contextType, contextOverrides)) {
928 info("WARNING: can not create GPU context for config '%s'. "
929 "GM tests will be skipped.\n", gpuConfig->getTag().c_str());
930 return nullptr;
931 }
932 if (gpuConfig->getTestThreading()) {
933 SkASSERT(!gpuConfig->getTestPersistentCache());
934 return new GPUThreadTestingSink(
935 contextType, contextOverrides, gpuConfig->getSurfType(),
936 gpuConfig->getSamples(), gpuConfig->getUseDIText(),
937 gpuConfig->getColorType(), gpuConfig->getAlphaType(),
938 sk_ref_sp(gpuConfig->getColorSpace()), FLAGS_gpu_threading, grCtxOptions);
939 } else if (gpuConfig->getTestPersistentCache()) {
940 return new GPUPersistentCacheTestingSink(
941 contextType, contextOverrides, gpuConfig->getSurfType(),
942 gpuConfig->getSamples(), gpuConfig->getUseDIText(),
943 gpuConfig->getColorType(), gpuConfig->getAlphaType(),
944 sk_ref_sp(gpuConfig->getColorSpace()), FLAGS_gpu_threading, grCtxOptions,
945 gpuConfig->getTestPersistentCache());
946 } else {
947 return new GPUSink(contextType, contextOverrides, gpuConfig->getSurfType(),
948 gpuConfig->getSamples(), gpuConfig->getUseDIText(),
949 gpuConfig->getColorType(), gpuConfig->getAlphaType(),
950 sk_ref_sp(gpuConfig->getColorSpace()), FLAGS_gpu_threading,
951 grCtxOptions);
952 }
953 }
954 }
955 if (const SkCommandLineConfigSvg* svgConfig = config->asConfigSvg()) {
956 int pageIndex = svgConfig->getPageIndex();
957 return new SVGSink(pageIndex);
958 }
959
960 #define SINK(t, sink, ...) if (config->getBackend().equals(t)) return new sink(__VA_ARGS__)
961
962 if (FLAGS_cpu) {
963 SINK("g8", RasterSink, kGray_8_SkColorType);
964 SINK("565", RasterSink, kRGB_565_SkColorType);
965 SINK("4444", RasterSink, kARGB_4444_SkColorType);
966 SINK("8888", RasterSink, kN32_SkColorType);
967 SINK("rgba", RasterSink, kRGBA_8888_SkColorType);
968 SINK("bgra", RasterSink, kBGRA_8888_SkColorType);
969 SINK("rgbx", RasterSink, kRGB_888x_SkColorType);
970 SINK("1010102", RasterSink, kRGBA_1010102_SkColorType);
971 SINK("101010x", RasterSink, kRGB_101010x_SkColorType);
972 SINK("pdf", PDFSink, false, SK_ScalarDefaultRasterDPI);
973 SINK("skp", SKPSink);
974 SINK("svg", SVGSink);
975 SINK("null", NullSink);
976 SINK("xps", XPSSink);
977 SINK("pdfa", PDFSink, true, SK_ScalarDefaultRasterDPI);
978 SINK("pdf300", PDFSink, false, 300);
979 SINK("jsdebug", DebugSink);
980
981 // Configs relevant to color management testing (and 8888 for reference).
982
983 // 'narrow' has a gamut narrower than sRGB, and different transfer function.
984 auto narrow = SkColorSpace::MakeRGB(SkNamedTransferFn::k2Dot2, gNarrow_toXYZD50),
985 srgb = SkColorSpace::MakeSRGB(),
986 srgbLinear = SkColorSpace::MakeSRGBLinear(),
987 p3 = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDCIP3);
988
989 SINK( "f16", RasterSink, kRGBA_F16_SkColorType, srgbLinear);
990 SINK( "srgb", RasterSink, kRGBA_8888_SkColorType, srgb );
991 SINK( "esrgb", RasterSink, kRGBA_F16_SkColorType, srgb );
992 SINK( "esgbr", RasterSink, kRGBA_F16_SkColorType, rgb_to_gbr());
993 SINK( "narrow", RasterSink, kRGBA_8888_SkColorType, narrow );
994 SINK( "enarrow", RasterSink, kRGBA_F16_SkColorType, narrow );
995 SINK( "p3", RasterSink, kRGBA_8888_SkColorType, p3 );
996 SINK( "ep3", RasterSink, kRGBA_F16_SkColorType, p3 );
997 SINK( "rec2020", RasterSink, kRGBA_8888_SkColorType, rec2020() );
998 SINK("erec2020", RasterSink, kRGBA_F16_SkColorType, rec2020() );
999
1000 SINK("f16norm", RasterSink, kRGBA_F16Norm_SkColorType, srgb);
1001
1002 SINK( "f32", RasterSink, kRGBA_F32_SkColorType, srgbLinear);
1003 }
1004 #undef SINK
1005 return nullptr;
1006 }
1007
create_via(const SkString & tag,Sink * wrapped)1008 static Sink* create_via(const SkString& tag, Sink* wrapped) {
1009 #define VIA(t, via, ...) if (tag.equals(t)) return new via(__VA_ARGS__)
1010 #ifdef TEST_VIA_SVG
1011 VIA("svg", ViaSVG, wrapped);
1012 #endif
1013 VIA("serialize", ViaSerialization, wrapped);
1014 VIA("pic", ViaPicture, wrapped);
1015 VIA("tiles", ViaTiles, 256, 256, nullptr, wrapped);
1016 VIA("tiles_rt", ViaTiles, 256, 256, new SkRTreeFactory, wrapped);
1017
1018 VIA("ddl", ViaDDL, 1, 3, wrapped);
1019 VIA("ddl2", ViaDDL, 2, 3, wrapped);
1020
1021 if (FLAGS_matrix.count() == 4) {
1022 SkMatrix m;
1023 m.reset();
1024 m.setScaleX((SkScalar)atof(FLAGS_matrix[0]));
1025 m.setSkewX ((SkScalar)atof(FLAGS_matrix[1]));
1026 m.setSkewY ((SkScalar)atof(FLAGS_matrix[2]));
1027 m.setScaleY((SkScalar)atof(FLAGS_matrix[3]));
1028 VIA("matrix", ViaMatrix, m, wrapped);
1029 VIA("upright", ViaUpright, m, wrapped);
1030 }
1031
1032 #undef VIA
1033 return nullptr;
1034 }
1035
gather_sinks(const GrContextOptions & grCtxOptions,bool defaultConfigs)1036 static bool gather_sinks(const GrContextOptions& grCtxOptions, bool defaultConfigs) {
1037 SkCommandLineConfigArray configs;
1038 ParseConfigs(FLAGS_config, &configs);
1039 AutoreleasePool pool;
1040 for (int i = 0; i < configs.count(); i++) {
1041 const SkCommandLineConfig& config = *configs[i];
1042 Sink* sink = create_sink(grCtxOptions, &config);
1043 if (sink == nullptr) {
1044 info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
1045 config.getTag().c_str());
1046 continue;
1047 }
1048
1049 const SkTArray<SkString>& parts = config.getViaParts();
1050 for (int j = parts.count(); j-- > 0;) {
1051 const SkString& part = parts[j];
1052 Sink* next = create_via(part, sink);
1053 if (next == nullptr) {
1054 info("Skipping config %s: Don't understand '%s'.\n", config.getTag().c_str(),
1055 part.c_str());
1056 delete sink;
1057 sink = nullptr;
1058 break;
1059 }
1060 sink = next;
1061 }
1062 if (sink) {
1063 push_sink(config, sink);
1064 }
1065 }
1066
1067 // If no configs were requested (just running tests, perhaps?), then we're okay.
1068 if (configs.count() == 0 ||
1069 // If we're using the default configs, we're okay.
1070 defaultConfigs ||
1071 // Otherwise, make sure that all specified configs have become sinks.
1072 configs.count() == gSinks.count()) {
1073 return true;
1074 }
1075 return false;
1076 }
1077
match(const char * needle,const char * haystack)1078 static bool match(const char* needle, const char* haystack) {
1079 if ('~' == needle[0]) {
1080 return !match(needle + 1, haystack);
1081 }
1082 if (0 == strcmp("_", needle)) {
1083 return true;
1084 }
1085 return nullptr != strstr(haystack, needle);
1086 }
1087
is_blacklisted(const char * sink,const char * src,const char * srcOptions,const char * name)1088 static bool is_blacklisted(const char* sink, const char* src,
1089 const char* srcOptions, const char* name) {
1090 for (int i = 0; i < FLAGS_blacklist.count() - 3; i += 4) {
1091 if (match(FLAGS_blacklist[i+0], sink) &&
1092 match(FLAGS_blacklist[i+1], src) &&
1093 match(FLAGS_blacklist[i+2], srcOptions) &&
1094 match(FLAGS_blacklist[i+3], name)) {
1095 return true;
1096 }
1097 }
1098 return false;
1099 }
1100
1101 // Even when a Task Sink reports to be non-threadsafe (e.g. GPU), we know things like
1102 // .png encoding are definitely thread safe. This lets us offload that work to CPU threads.
1103 static SkTaskGroup gDefinitelyThreadSafeWork;
1104
1105 // The finest-grained unit of work we can run: draw a single Src into a single Sink,
1106 // report any errors, and perhaps write out the output: a .png of the bitmap, or a raw stream.
1107 struct Task {
TaskTask1108 Task(const TaggedSrc& src, const TaggedSink& sink) : src(src), sink(sink) {}
1109 const TaggedSrc& src;
1110 const TaggedSink& sink;
1111
RunTask1112 static void Run(const Task& task) {
1113 AutoreleasePool pool;
1114 SkString name = task.src->name();
1115
1116 SkString log;
1117 if (!FLAGS_dryRun) {
1118 SkBitmap bitmap;
1119 SkDynamicMemoryWStream stream;
1120 start(task.sink.tag.c_str(), task.src.tag.c_str(),
1121 task.src.options.c_str(), name.c_str());
1122 Error err = task.sink->draw(*task.src, &bitmap, &stream, &log);
1123 if (!log.isEmpty()) {
1124 info("%s %s %s %s:\n%s\n", task.sink.tag.c_str()
1125 , task.src.tag.c_str()
1126 , task.src.options.c_str()
1127 , name.c_str()
1128 , log.c_str());
1129 }
1130 if (!err.isEmpty()) {
1131 if (err.isFatal()) {
1132 fail(SkStringPrintf("%s %s %s %s: %s",
1133 task.sink.tag.c_str(),
1134 task.src.tag.c_str(),
1135 task.src.options.c_str(),
1136 name.c_str(),
1137 err.c_str()));
1138 } else {
1139 done(task.sink.tag.c_str(), task.src.tag.c_str(),
1140 task.src.options.c_str(), name.c_str());
1141 return;
1142 }
1143 }
1144
1145 // We're likely switching threads here, so we must capture by value, [=] or [foo,bar].
1146 SkStreamAsset* data = stream.detachAsStream().release();
1147 gDefinitelyThreadSafeWork.add([task,name,bitmap,data]{
1148 std::unique_ptr<SkStreamAsset> ownedData(data);
1149
1150 std::unique_ptr<HashAndEncode> hashAndEncode;
1151
1152 SkString md5;
1153 if (!FLAGS_writePath.isEmpty() || !FLAGS_readPath.isEmpty()) {
1154 SkMD5 hash;
1155 if (data->getLength()) {
1156 hash.writeStream(data, data->getLength());
1157 data->rewind();
1158 } else {
1159 hashAndEncode.reset(new HashAndEncode(bitmap));
1160 hashAndEncode->write(&hash);
1161 }
1162 SkMD5::Digest digest = hash.finish();
1163 for (int i = 0; i < 16; i++) {
1164 md5.appendf("%02x", digest.data[i]);
1165 }
1166 }
1167
1168 if (!FLAGS_readPath.isEmpty() &&
1169 !gGold.contains(Gold(task.sink.tag, task.src.tag,
1170 task.src.options, name, md5))) {
1171 fail(SkStringPrintf("%s not found for %s %s %s %s in %s",
1172 md5.c_str(),
1173 task.sink.tag.c_str(),
1174 task.src.tag.c_str(),
1175 task.src.options.c_str(),
1176 name.c_str(),
1177 FLAGS_readPath[0]));
1178 }
1179
1180 if (!FLAGS_writePath.isEmpty()) {
1181 const char* ext = task.sink->fileExtension();
1182 if (ext && !FLAGS_dont_write.contains(ext)) {
1183 if (data->getLength()) {
1184 WriteToDisk(task, md5, ext, data, data->getLength(), nullptr, nullptr);
1185 SkASSERT(bitmap.drawsNothing());
1186 } else if (!bitmap.drawsNothing()) {
1187 WriteToDisk(task, md5, ext, nullptr, 0, &bitmap, hashAndEncode.get());
1188 }
1189 }
1190 }
1191
1192 SkPixmap pm;
1193 if (FLAGS_checkF16 && bitmap.colorType() == kRGBA_F16Norm_SkColorType &&
1194 bitmap.peekPixels(&pm)) {
1195 bool unclamped = false;
1196 for (int y = 0; y < pm.height() && !unclamped; ++y)
1197 for (int x = 0; x < pm.width() && !unclamped; ++x) {
1198 Sk4f rgba = SkHalfToFloat_finite_ftz(*pm.addr64(x, y));
1199 float a = rgba[3];
1200 if (a > 1.0f || (rgba < 0.0f).anyTrue() || (rgba > a).anyTrue()) {
1201 SkDebugf("[%s] F16Norm pixel [%d, %d] unclamped: (%g, %g, %g, %g)\n",
1202 name.c_str(), x, y, rgba[0], rgba[1], rgba[2], rgba[3]);
1203 unclamped = true;
1204 }
1205 }
1206 }
1207 });
1208 }
1209 done(task.sink.tag.c_str(), task.src.tag.c_str(), task.src.options.c_str(), name.c_str());
1210 }
1211
identify_gamutTask1212 static SkString identify_gamut(SkColorSpace* cs) {
1213 if (!cs) {
1214 return SkString("untagged");
1215 }
1216
1217 skcms_Matrix3x3 gamut;
1218 if (cs->toXYZD50(&gamut)) {
1219 auto eq = [](skcms_Matrix3x3 x, skcms_Matrix3x3 y) {
1220 for (int i = 0; i < 3; i++)
1221 for (int j = 0; j < 3; j++) {
1222 if (x.vals[i][j] != y.vals[i][j]) { return false; }
1223 }
1224 return true;
1225 };
1226
1227 if (eq(gamut, SkNamedGamut::kSRGB )) { return SkString("sRGB"); }
1228 if (eq(gamut, SkNamedGamut::kAdobeRGB)) { return SkString("Adobe"); }
1229 if (eq(gamut, SkNamedGamut::kDCIP3 )) { return SkString("P3"); }
1230 if (eq(gamut, SkNamedGamut::kRec2020 )) { return SkString("2020"); }
1231 if (eq(gamut, SkNamedGamut::kXYZ )) { return SkString("XYZ"); }
1232 if (eq(gamut, gNarrow_toXYZD50 )) { return SkString("narrow"); }
1233 return SkString("other");
1234 }
1235 return SkString("non-XYZ");
1236 }
1237
identify_transfer_fnTask1238 static SkString identify_transfer_fn(SkColorSpace* cs) {
1239 if (!cs) {
1240 return SkString("untagged");
1241 }
1242
1243 skcms_TransferFunction tf;
1244 if (cs->isNumericalTransferFn(&tf)) {
1245 auto eq = [](skcms_TransferFunction x, skcms_TransferFunction y) {
1246 return x.g == y.g
1247 && x.a == y.a
1248 && x.b == y.b
1249 && x.c == y.c
1250 && x.d == y.d
1251 && x.e == y.e
1252 && x.f == y.f;
1253 };
1254
1255 if (tf.a == 1 && tf.b == 0 && tf.c == 0 && tf.d == 0 && tf.e == 0 && tf.f == 0) {
1256 return SkStringPrintf("gamma %.3g", tf.g);
1257 }
1258 if (eq(tf, SkNamedTransferFn::kSRGB )) { return SkString("sRGB"); }
1259 if (eq(tf, SkNamedTransferFn::kRec2020)) { return SkString("2020"); }
1260 return SkStringPrintf("%.3g %.3g %.3g %.3g %.3g %.3g %.3g",
1261 tf.g, tf.a, tf.b, tf.c, tf.d, tf.e, tf.f);
1262 }
1263 return SkString("non-numeric");
1264 }
1265
WriteToDiskTask1266 static void WriteToDisk(const Task& task,
1267 SkString md5,
1268 const char* ext,
1269 SkStream* data, size_t len,
1270 const SkBitmap* bitmap,
1271 const HashAndEncode* hashAndEncode) {
1272
1273 JsonWriter::BitmapResult result;
1274 result.name = task.src->name();
1275 result.config = task.sink.tag;
1276 result.sourceType = task.src.tag;
1277 result.sourceOptions = task.src.options;
1278 result.ext = ext;
1279 result.md5 = md5;
1280 if (bitmap) {
1281 result.gamut = identify_gamut (bitmap->colorSpace());
1282 result.transferFn = identify_transfer_fn (bitmap->colorSpace());
1283 result.colorType = ToolUtils::colortype_name (bitmap->colorType());
1284 result.alphaType = ToolUtils::alphatype_name (bitmap->alphaType());
1285 result.colorDepth = ToolUtils::colortype_depth(bitmap->colorType());
1286 }
1287 JsonWriter::AddBitmapResult(result);
1288
1289 // If an MD5 is uninteresting, we want it noted in the JSON file,
1290 // but don't want to dump it out as a .png (or whatever ext is).
1291 if (gUninterestingHashes.contains(md5)) {
1292 return;
1293 }
1294
1295 const char* dir = FLAGS_writePath[0];
1296 SkString resources = GetResourcePath();
1297 if (0 == strcmp(dir, "@")) { // Needed for iOS.
1298 dir = resources.c_str();
1299 }
1300 sk_mkdir(dir);
1301
1302 SkString path;
1303 if (FLAGS_nameByHash) {
1304 path = SkOSPath::Join(dir, result.md5.c_str());
1305 path.append(".");
1306 path.append(ext);
1307 if (sk_exists(path.c_str())) {
1308 return; // Content-addressed. If it exists already, we're done.
1309 }
1310 } else {
1311 path = SkOSPath::Join(dir, task.sink.tag.c_str());
1312 sk_mkdir(path.c_str());
1313 path = SkOSPath::Join(path.c_str(), task.src.tag.c_str());
1314 sk_mkdir(path.c_str());
1315 if (strcmp(task.src.options.c_str(), "") != 0) {
1316 path = SkOSPath::Join(path.c_str(), task.src.options.c_str());
1317 sk_mkdir(path.c_str());
1318 }
1319 path = SkOSPath::Join(path.c_str(), task.src->name().c_str());
1320 path.append(".");
1321 path.append(ext);
1322 }
1323
1324 if (bitmap) {
1325 SkASSERT(hashAndEncode);
1326 if (!hashAndEncode->writePngTo(path.c_str(),
1327 result.md5.c_str(),
1328 FLAGS_key,
1329 FLAGS_properties)) {
1330 fail(SkStringPrintf("Can't encode PNG to %s.\n", path.c_str()));
1331 return;
1332 }
1333 } else {
1334 SkFILEWStream file(path.c_str());
1335 if (!file.isValid()) {
1336 fail(SkStringPrintf("Can't open %s for writing.\n", path.c_str()));
1337 return;
1338 }
1339 if (!file.writeStream(data, len)) {
1340 fail(SkStringPrintf("Can't write to %s.\n", path.c_str()));
1341 return;
1342 }
1343 }
1344 }
1345 };
1346
1347 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1348
1349 // Unit tests don't fit so well into the Src/Sink model, so we give them special treatment.
1350
1351 static SkTDArray<skiatest::Test> gParallelTests, gSerialTests;
1352
gather_tests()1353 static void gather_tests() {
1354 if (!FLAGS_src.contains("tests")) {
1355 return;
1356 }
1357 for (const skiatest::Test& test : skiatest::TestRegistry::Range()) {
1358 if (!in_shard()) {
1359 continue;
1360 }
1361 if (CommandLineFlags::ShouldSkip(FLAGS_match, test.name)) {
1362 continue;
1363 }
1364 if (test.needsGpu && FLAGS_gpu) {
1365 (FLAGS_gpu_threading ? gParallelTests : gSerialTests).push_back(test);
1366 } else if (!test.needsGpu && FLAGS_cpu) {
1367 gParallelTests.push_back(test);
1368 }
1369 }
1370 }
1371
run_test(skiatest::Test test,const GrContextOptions & grCtxOptions)1372 static void run_test(skiatest::Test test, const GrContextOptions& grCtxOptions) {
1373 struct : public skiatest::Reporter {
1374 void reportFailed(const skiatest::Failure& failure) override {
1375 fail(failure.toString());
1376 }
1377 bool allowExtendedTest() const override {
1378 return FLAGS_pathOpsExtended;
1379 }
1380 bool verbose() const override { return FLAGS_veryVerbose; }
1381 } reporter;
1382
1383 if (!FLAGS_dryRun && !is_blacklisted("_", "tests", "_", test.name)) {
1384 AutoreleasePool pool;
1385 GrContextOptions options = grCtxOptions;
1386 test.modifyGrContextOptions(&options);
1387
1388 skiatest::ReporterContext ctx(&reporter, SkString(test.name));
1389 start("unit", "test", "", test.name);
1390 test.run(&reporter, options);
1391 }
1392 done("unit", "test", "", test.name);
1393 }
1394
1395 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
1396
main(int argc,char ** argv)1397 int main(int argc, char** argv) {
1398 #if defined(__MSVC_RUNTIME_CHECKS)
1399 _RTC_SetErrorFunc(RuntimeCheckErrorFunc);
1400 #endif
1401 #if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_HAS_HEIF_LIBRARY)
1402 android::ProcessState::self()->startThreadPool();
1403 #endif
1404 CommandLineFlags::Parse(argc, argv);
1405
1406 initializeEventTracingForTools();
1407
1408 #if !defined(SK_BUILD_FOR_GOOGLE3) && defined(SK_BUILD_FOR_IOS)
1409 cd_Documents();
1410 #endif
1411 setbuf(stdout, nullptr);
1412 setup_crash_handler();
1413
1414 ToolUtils::SetDefaultFontMgr();
1415 SetAnalyticAAFromCommonFlags();
1416
1417 if (FLAGS_forceRasterPipeline) {
1418 gSkForceRasterPipelineBlitter = true;
1419 }
1420
1421 // The bots like having a verbose.log to upload, so always touch the file even if --verbose.
1422 if (!FLAGS_writePath.isEmpty()) {
1423 sk_mkdir(FLAGS_writePath[0]);
1424 gVLog = fopen(SkOSPath::Join(FLAGS_writePath[0], "verbose.log").c_str(), "w");
1425 }
1426 if (FLAGS_verbose) {
1427 gVLog = stderr;
1428 }
1429
1430 GrContextOptions grCtxOptions;
1431 SetCtxOptionsFromCommonFlags(&grCtxOptions);
1432
1433 dump_json(); // It's handy for the bots to assume this is ~never missing.
1434
1435 SkAutoGraphics ag;
1436 SkTaskGroup::Enabler enabled(FLAGS_threads);
1437
1438 if (nullptr == GetResourceAsData("images/color_wheel.png")) {
1439 info("Some resources are missing. Do you need to set --resourcePath?\n");
1440 }
1441 gather_gold();
1442 gather_uninteresting_hashes();
1443
1444 if (!gather_srcs()) {
1445 return 1;
1446 }
1447 // TODO(dogben): This is a bit ugly. Find a cleaner way to do this.
1448 bool defaultConfigs = true;
1449 for (int i = 0; i < argc; i++) {
1450 static const char* kConfigArg = "--config";
1451 if (strcmp(argv[i], kConfigArg) == 0) {
1452 defaultConfigs = false;
1453 break;
1454 }
1455 }
1456 if (!gather_sinks(grCtxOptions, defaultConfigs)) {
1457 return 1;
1458 }
1459 gather_tests();
1460 gPending = gSrcs.count() * gSinks.count() + gParallelTests.count() + gSerialTests.count();
1461 info("%d srcs * %d sinks + %d tests == %d tasks\n",
1462 gSrcs.count(), gSinks.count(), gParallelTests.count() + gSerialTests.count(), gPending);
1463
1464 // Kick off as much parallel work as we can, making note of any serial work we'll need to do.
1465 SkTaskGroup parallel;
1466 SkTArray<Task> serial;
1467
1468 for (auto& sink : gSinks)
1469 for (auto& src : gSrcs) {
1470 if (src->veto(sink->flags()) ||
1471 is_blacklisted(sink.tag.c_str(), src.tag.c_str(),
1472 src.options.c_str(), src->name().c_str())) {
1473 SkAutoSpinlock lock(gMutex);
1474 gPending--;
1475 continue;
1476 }
1477
1478 Task task(src, sink);
1479 if (src->serial() || sink->serial()) {
1480 serial.push_back(task);
1481 } else {
1482 parallel.add([task] { Task::Run(task); });
1483 }
1484 }
1485 for (auto test : gParallelTests) {
1486 parallel.add([test, grCtxOptions] { run_test(test, grCtxOptions); });
1487 }
1488
1489 // With the parallel work running, run serial tasks and tests here on main thread.
1490 for (auto task : serial) { Task::Run(task); }
1491 for (auto test : gSerialTests) { run_test(test, grCtxOptions); }
1492
1493 // Wait for any remaining parallel work to complete (including any spun off of serial tasks).
1494 parallel.wait();
1495 gDefinitelyThreadSafeWork.wait();
1496
1497 // At this point we're back in single-threaded land.
1498
1499 // We'd better have run everything.
1500 SkASSERT(gPending == 0);
1501 // Make sure we've flushed all our results to disk.
1502 dump_json();
1503
1504 if (gFailures.count() > 0) {
1505 info("Failures:\n");
1506 for (int i = 0; i < gFailures.count(); i++) {
1507 info("\t%s\n", gFailures[i].c_str());
1508 }
1509 info("%d failures\n", gFailures.count());
1510 // A non-zero return code does not make it to Swarming
1511 // An abort does.
1512 #ifdef SK_BUILD_FOR_IOS
1513 SK_ABORT("There were failures!");
1514 #endif
1515 return 1;
1516 }
1517
1518 SkGraphics::PurgeAllCaches();
1519 info("Finished!\n");
1520
1521 return 0;
1522 }
1523
