DM: support --config {f16,srgb}

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
 #include "ProcStats.h"
 #include "Resources.h"
 #include "SkBBHFactory.h"
 #include "SkChecksum.h"
 #include "SkCodec.h"
+#include "SkColorPriv.h"
 #include "SkCommonFlags.h"
 #include "SkCommonFlagsConfig.h"
 #include "SkFontMgr.h"
 #include "SkGraphics.h"
+#include "SkHalf.h"
 #include "SkMD5.h"
 #include "SkMutex.h"
 #include "SkOSFile.h"
+#include "SkPM4fPriv.h"
 #include "SkSpinlock.h"
 #include "SkTHash.h"
 #include "SkTaskGroup.h"
 #include "SkThreadUtils.h"
 #include "Test.h"
 #include "Timer.h"
 #include "sk_tool_utils.h"
 
 #ifdef SK_PDF_IMAGE_STATS
 extern void SkPDFImageDumpStats();
@@ skipping 659 matching lines @@
 
 #define SINK(t, sink, ...) if (config->getBackend().equals(t)) { return new sink(__VA_ARGS__); }
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     SINK("hwui",           HWUISink);
 #endif
 
     if (FLAGS_cpu) {
         SINK("565",  RasterSink, kRGB_565_SkColorType);
         SINK("8888", RasterSink, kN32_SkColorType);
+        SINK("srgb", RasterSink, kN32_SkColorType, kSRGB_SkColorProfileType);
+        SINK("f16",  RasterSink, kRGBA_F16_SkColorType);
         SINK("pdf",  PDFSink, "Pdfium");
         SINK("pdf_poppler",  PDFSink, "Poppler");
         SINK("skp",  SKPSink);
         SINK("svg",  SVGSink);
         SINK("null", NullSink);
         SINK("xps",  XPSSink);
     }
 #undef SINK
     return nullptr;
 }
@@ skipping 57 matching lines @@
         }
         if (sink) {
             push_sink(config, sink);
         }
     }
 }
 
 static bool dump_png(SkBitmap bitmap, const char* path, const char* md5) {
     const int w = bitmap.width(),
               h = bitmap.height();
+    // PNG wants unpremultiplied 8-bit RGBA pixels (16-bit could work fine too).
+    // We leave the gamma of these bytes unspecified, to continue the status quo,
+    // which we think generally is to interpret them as sRGB.
 
-    // First get the bitmap into N32 color format.  The next step will work only there.
-    if (bitmap.colorType() != kN32_SkColorType) {
-        SkBitmap n32;
-        if (!bitmap.copyTo(&n32, kN32_SkColorType)) {
+    SkAutoTMalloc<uint32_t> rgba(w*h);
+
+    if (bitmap.  colorType() ==  kN32_SkColorType &&
+        bitmap.profileType() == kSRGB_SkColorProfileType) {
+        // These are premul sRGB 8-bit pixels in SkPMColor order.
+        // We want unpremul sRGB 8-bit pixels in RGBA order.  We'll get there via floats.
+        bitmap.lockPixels();
+        auto px = (const uint32_t*)bitmap.getPixels();
+        if (!px) {
             return false;
         }
-        bitmap = n32;
-    }
+        for (int i = 0; i < w*h; i++) {
+            Sk4f fs = Sk4f_fromS32(px[i]);         // Convert up to linear floats.
+        #if defined(SK_PMCOLOR_IS_BGRA)
+            fs = SkNx_shuffle<2,1,0,3>(fs);        // Shuffle to RGBA, if not there already.
+        #endif
+            float invA = 1.0f / fs[3];
+            fs = fs * Sk4f(invA, invA, invA, 1);   // Unpremultiply.
+            rgba[i] = Sk4f_toS32(fs);              // Pack down to sRGB bytes.
+        }
 
-    // Convert our N32 bitmap into unpremul RGBA for libpng.
-    SkAutoTMalloc<uint32_t> rgba(w*h);
-    if (!bitmap.readPixels(SkImageInfo::Make(w,h, kRGBA_8888_SkColorType, kUnpremul_SkAlphaType),
-                           rgba, 4*w, 0,0)) {
-        return false;
+    } else if (bitmap.colorType() == kRGBA_F16_SkColorType) {
+        // These are premul linear half-float pixels in RGBA order.
+        // We want unpremul sRGB 8-bit pixels in RGBA order.  We'll get there via floats.
+        bitmap.lockPixels();
+        auto px = (const uint64_t*)bitmap.getPixels();
+        if (!px) {
+            return false;
+        }
+        for (int i = 0; i < w*h; i++) {
+            Sk4f fs = SkHalfToFloat_01(px[i]);    // Convert up to linear floats.
+            float invA = 1.0f / fs[3];
+            fs = fs * Sk4f(invA, invA, invA, 1);  // Unpremultiply.
+            rgba[i] = Sk4f_toS32(fs);             // Pack down to sRGB bytes.
+        }
+
+
+    } else {
+        // We "should" gamma correct in here but we don't.
+        // We want Gold to show exactly what our clients are seeing, broken gamma.
+
+        // Convert smaller formats up to premul linear 8-bit (in SkPMColor order).
+        if (bitmap.colorType() != kN32_SkColorType) {
+            SkBitmap n32;
+            if (!bitmap.copyTo(&n32, kN32_SkColorType)) {
+                return false;
+            }
+            bitmap = n32;
+        }
+
+        // Convert premul linear 8-bit to unpremul linear 8-bit RGBA.
+        if (!bitmap.readPixels(SkImageInfo::Make(w,h, kRGBA_8888_SkColorType,
+                                                      kUnpremul_SkAlphaType),
+                               rgba, 4*w, 0,0)) {
+            return false;
+        }
     }
 
     // We don't need bitmap anymore.  Might as well drop our ref.
     bitmap.reset();
 
     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) {
@@ skipping 480 matching lines @@
                                                            Reporter* reporter,
                                                            GrContextFactory* factory);
 } // namespace skiatest
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif