FM, a dumber new testing tool
FM's a bit like DM, and a bit like the old GM tool, maybe closer to GM.
FM always does one serial run through of a list of GM, image, or .skp
sources (-s/--sources) into one drawing configuration, set at a high
level with -b/--backend, fine-tuned by flags like --ct, --at, --gamut,
--samples, etc.
FM prints all available GMs when run with no arguments, part of
how it integrates well with external parallelization like xargs:
out/fm | time xargs -n4 -P32 out/fm -b cpu ... -s
out/fm | time xargs -n32 -P8 out/fm -b gl ... -s
ls *.skp | xargs ... out/fm ... -s
...
TODO later:
vector backends: --backend pdf, svg, xps, skp
--source *.svg, *.json (Skottie)
Create/update a dm.json file
Change-Id: Idacbd2785deaf6f1d33674c66c4d984fa91dbd85
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/203520
Commit-Queue: Mike Klein <mtklein@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
diff --git a/tools/HashAndEncode.cpp b/tools/HashAndEncode.cpp
new file mode 100644
index 0000000..91814fc
--- /dev/null
+++ b/tools/HashAndEncode.cpp
@@ -0,0 +1,160 @@
+// Copyright 2019 Google LLC.
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+#include "HashAndEncode.h"
+#include "SkICC.h"
+#include "SkString.h"
+#include "png.h"
+
+static constexpr skcms_TransferFunction k2020_TF =
+ {2.22222f, 0.909672f, 0.0903276f, 0.222222f, 0.0812429f, 0, 0};
+
+static sk_sp<SkColorSpace> rec2020() {
+ return SkColorSpace::MakeRGB(k2020_TF, SkNamedGamut::kRec2020);
+}
+
+HashAndEncode::HashAndEncode(const SkBitmap& bitmap) : fSize(bitmap.info().dimensions()) {
+ skcms_AlphaFormat srcAlpha;
+ switch (bitmap.alphaType()) {
+ case kUnknown_SkAlphaType: SkASSERT(false); return;
+
+ case kOpaque_SkAlphaType:
+ case kUnpremul_SkAlphaType: srcAlpha = skcms_AlphaFormat_Unpremul; break;
+ case kPremul_SkAlphaType: srcAlpha = skcms_AlphaFormat_PremulAsEncoded; break;
+ }
+
+ skcms_PixelFormat srcFmt;
+ switch (bitmap.colorType()) {
+ case kUnknown_SkColorType: SkASSERT(false); return;
+
+ case kAlpha_8_SkColorType: srcFmt = skcms_PixelFormat_A_8; break;
+ case kRGB_565_SkColorType: srcFmt = skcms_PixelFormat_BGR_565; break;
+ case kARGB_4444_SkColorType: srcFmt = skcms_PixelFormat_ABGR_4444; break;
+ case kRGBA_8888_SkColorType: srcFmt = skcms_PixelFormat_RGBA_8888; break;
+ case kBGRA_8888_SkColorType: srcFmt = skcms_PixelFormat_BGRA_8888; break;
+ case kRGBA_1010102_SkColorType: srcFmt = skcms_PixelFormat_RGBA_1010102; break;
+ case kGray_8_SkColorType: srcFmt = skcms_PixelFormat_G_8; break;
+ case kRGBA_F16Norm_SkColorType: srcFmt = skcms_PixelFormat_RGBA_hhhh; break;
+ case kRGBA_F16_SkColorType: srcFmt = skcms_PixelFormat_RGBA_hhhh; break;
+ case kRGBA_F32_SkColorType: srcFmt = skcms_PixelFormat_RGBA_ffff; break;
+
+ case kRGB_888x_SkColorType: srcFmt = skcms_PixelFormat_RGBA_8888;
+ srcAlpha = skcms_AlphaFormat_Opaque; break;
+ case kRGB_101010x_SkColorType: srcFmt = skcms_PixelFormat_RGBA_1010102;
+ srcAlpha = skcms_AlphaFormat_Opaque; break;
+ }
+
+ skcms_ICCProfile srcProfile = *skcms_sRGB_profile();
+ if (auto cs = bitmap.colorSpace()) {
+ cs->toProfile(&srcProfile);
+ }
+
+ // Our common format that can represent anything we draw and encode as a PNG:
+ // - 16-bit big-endian RGBA
+ // - unpremul
+ // - Rec. 2020 gamut and transfer function
+ skcms_PixelFormat dstFmt = skcms_PixelFormat_RGBA_16161616BE;
+ skcms_AlphaFormat dstAlpha = skcms_AlphaFormat_Unpremul;
+ skcms_ICCProfile dstProfile;
+ rec2020()->toProfile(&dstProfile);
+
+ int N = fSize.width() * fSize.height();
+ fPixels.reset(new uint64_t[N]);
+
+ if (!skcms_Transform(bitmap.getPixels(), srcFmt, srcAlpha, &srcProfile,
+ fPixels.get(), dstFmt, dstAlpha, &dstProfile, N)) {
+ SkASSERT(false);
+ fPixels.reset(nullptr);
+ }
+}
+
+void HashAndEncode::write(SkWStream* st) const {
+ st->write(&fSize, sizeof(fSize));
+ if (const uint64_t* px = fPixels.get()) {
+ st->write(px, sizeof(*px) * fSize.width() * fSize.height());
+ }
+
+ // N.B. changing salt will change the hash of all images produced by DM,
+ // and will cause tens of thousands of new images to be uploaded to Gold.
+ int salt = 1;
+ st->write(&salt, sizeof(salt));
+}
+
+bool HashAndEncode::writePngTo(const char* path,
+ const char* md5,
+ CommandLineFlags::StringArray key,
+ CommandLineFlags::StringArray properties) const {
+ if (!fPixels) {
+ return false;
+ }
+
+ FILE* f = fopen(path, "wb");
+ if (!f) {
+ return false;
+ }
+
+ png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
+ if (!png) {
+ fclose(f);
+ return false;
+ }
+
+ png_infop info = png_create_info_struct(png);
+ if (!info) {
+ png_destroy_write_struct(&png, &info);
+ fclose(f);
+ return false;
+ }
+
+ SkString description;
+ description.append("Key: ");
+ for (int i = 0; i < key.count(); i++) {
+ description.appendf("%s ", key[i]);
+ }
+ description.append("Properties: ");
+ for (int i = 0; i < properties.count(); i++) {
+ description.appendf("%s ", properties[i]);
+ }
+ description.appendf("MD5: %s", md5);
+
+ png_text text[2];
+ text[0].key = (png_charp)"Author";
+ text[0].text = (png_charp)"DM unified Rec.2020";
+ text[0].compression = PNG_TEXT_COMPRESSION_NONE;
+ text[1].key = (png_charp)"Description";
+ text[1].text = (png_charp)description.c_str();
+ text[1].compression = PNG_TEXT_COMPRESSION_NONE;
+ png_set_text(png, info, text, SK_ARRAY_COUNT(text));
+
+ png_init_io(png, f);
+ png_set_IHDR(png, info, (png_uint_32)fSize.width()
+ , (png_uint_32)fSize.height()
+ , 16/*bits per channel*/
+ , PNG_COLOR_TYPE_RGB_ALPHA
+ , PNG_INTERLACE_NONE
+ , PNG_COMPRESSION_TYPE_DEFAULT
+ , PNG_FILTER_TYPE_DEFAULT);
+
+ // Fastest encoding and decoding, at slight file size cost is no filtering, compression 1.
+ png_set_filter(png, PNG_FILTER_TYPE_BASE, PNG_FILTER_NONE);
+ // TODO(mtklein): set back to 1 after all the bots have cycled through new images / hashes?
+ png_set_compression_level(png, 9);
+
+ static const sk_sp<SkData> profile = SkWriteICCProfile(k2020_TF, SkNamedGamut::kRec2020);
+ png_set_iCCP(png, info,
+ "Rec.2020",
+ 0/*compression type... no idea what options are available here*/,
+ (png_const_bytep)profile->data(),
+ (png_uint_32) profile->size());
+
+ png_write_info(png, info);
+ for (int y = 0; y < fSize.height(); y++) {
+ png_write_row(png, (png_bytep)(fPixels.get() + y*fSize.width()));
+ }
+ png_write_end(png, info);
+
+ png_destroy_write_struct(&png, &info);
+ fclose(f);
+ return true;
+}
+