Support decoding opaque to *premul

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"
@@ skipping 207 matching lines @@
         FLAGS_src.contains(tag.c_str()) &&
         !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
         TaggedSrc& s = gSrcs.push_back();
         s.reset(src.detach());
         s.tag = tag;
         s.options = options;
     }
 }
 
 static void push_codec_src(Path path, CodecSrc::Mode mode, CodecSrc::DstColorType dstColorType,
-        float scale) {
+        SkAlphaType dstAlphaType, float scale) {
     SkString folder;
     switch (mode) {
         case CodecSrc::kCodec_Mode:
             folder.append("codec");
             break;
         case CodecSrc::kCodecZeroInit_Mode:
             folder.append("codec_zero_init");
             break;
         case CodecSrc::kScanline_Mode:
             folder.append("scanline");
@@ skipping 13 matching lines @@
         case CodecSrc::kGrayscale_Always_DstColorType:
             folder.append("_kGray8");
             break;
         case CodecSrc::kIndex8_Always_DstColorType:
             folder.append("_kIndex8");
             break;
         default:
             break;
     }
 
+    switch (dstAlphaType) {
+        case kOpaque_SkAlphaType:
+            folder.append("_opaque");

[scroggo, 2016/01/29 17:19:54]

I think you have in the past considered such an extension and decided against it
(maybe that was in nanobench). This is a little wordy, especially if we only
have _premul and not _opaque. I could write some more code that would only do it
when needed, but it would be a little messier.

[msarett, 2016/01/29 19:17:05]

I think this is good.  IMO it provides useful information when used in this
context.

+            break;
+        case kPremul_SkAlphaType:
+            folder.append("_premul");
+            break;
+        default:
+            break;
+    }
+
     if (1.0f != scale) {
         folder.appendf("_%.3f", scale);
     }
 
-    CodecSrc* src = new CodecSrc(path, mode, dstColorType, scale);
+    CodecSrc* src = new CodecSrc(path, mode, dstColorType, dstAlphaType, scale);
     push_src("image", folder, src);
 }
 
 static void push_android_codec_src(Path path, AndroidCodecSrc::Mode mode,
-        CodecSrc::DstColorType dstColorType, int sampleSize) {
+        CodecSrc::DstColorType dstColorType, SkAlphaType dstAlphaType, int sampleSize) {
     SkString folder;
     switch (mode) {
         case AndroidCodecSrc::kFullImage_Mode:
             folder.append("scaled_codec");
             break;
         case AndroidCodecSrc::kDivisor_Mode:
             folder.append("scaled_codec_divisor");
             break;
     }
 
     switch (dstColorType) {
         case CodecSrc::kGrayscale_Always_DstColorType:
             folder.append("_kGray8");
             break;
         case CodecSrc::kIndex8_Always_DstColorType:
             folder.append("_kIndex8");
             break;
         default:
             break;
     }
 
+    switch (dstAlphaType) {
+        case kOpaque_SkAlphaType:
+            folder.append("_opaque");
+            break;
+        case kPremul_SkAlphaType:
+            folder.append("_premul");
+            break;
+        default:
+            break;
+    }
+
     if (1 != sampleSize) {
         folder.appendf("_%.3f", 1.0f / (float) sampleSize);
     }
 
-    AndroidCodecSrc* src = new AndroidCodecSrc(path, mode, dstColorType, sampleSize);
+    AndroidCodecSrc* src = new AndroidCodecSrc(path, mode, dstColorType, dstAlphaType, sampleSize);
     push_src("image", folder, src);
 }
 
 static void push_codec_srcs(Path path) {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
     if (!encoded) {
         SkDebugf("Couldn't read %s.", path.c_str());
         return;
     }
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
@@ skipping 29 matching lines @@
             colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
             colorTypes[1] = CodecSrc::kIndex8_Always_DstColorType;
             numColorTypes = 2;
             break;
         default:
             colorTypes[0] = CodecSrc::kGetFromCanvas_DstColorType;
             numColorTypes = 1;
             break;
     }
 
+    SkTArray<SkAlphaType> alphaModes;
+    alphaModes.push_back(kPremul_SkAlphaType);
+    // FIXME: Currently we cannot draw unpremultiplied sources. skbug.com/3338 and skbug.com/3339
+    // alphaModes.push_back(kUnpremul_SkAlphaType);
+    if (codec->getInfo().alphaType() == kOpaque_SkAlphaType) {
+        alphaModes.push_back(kOpaque_SkAlphaType);
+    }
 
     for (CodecSrc::Mode mode : nativeModes) {
         // SkCodecImageGenerator only runs for the default colorType
         // recommended by SkCodec.  There is no need to generate multiple
         // tests for different colorTypes.
         // TODO (msarett): Add scaling support to SkCodecImageGenerator.
         if (CodecSrc::kGen_Mode == mode) {
             // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
             if (kGray_8_SkColorType != codec->getInfo().colorType()) {
-                push_codec_src(path, mode, CodecSrc::kGetFromCanvas_DstColorType, 1.0f);
+                push_codec_src(path, mode, CodecSrc::kGetFromCanvas_DstColorType,
+                               codec->getInfo().alphaType(), 1.0f);

[scroggo, 2016/01/29 17:19:54]

This will be ignored, besides appending the suffix.

[msarett, 2016/01/29 19:17:05]

Acknowledged.

             }
             continue;
         }
 
         for (float scale : nativeScales) {
             for (uint32_t i = 0; i < numColorTypes; i++) {
-                push_codec_src(path, mode, colorTypes[i], scale);
+                for (SkAlphaType alphaType : alphaModes) {
+                    push_codec_src(path, mode, colorTypes[i], alphaType, scale);
+                }
             }
         }
     }
 
     // https://bug.skia.org/4428
     bool subset = false;
     // The following image types are supported by BitmapRegionDecoder,
     // so we will test full image decodes and subset decodes.
     static const char* const exts[] = {
         "jpg", "jpeg", "png", "webp",
         "JPG", "JPEG", "PNG", "WEBP",
     };
     for (const char* ext : exts) {
         if (path.endsWith(ext)) {
             subset = true;
             break;
         }
     }
 
     const int sampleSizes[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
     for (int sampleSize : sampleSizes) {
         for (uint32_t i = 0; i < numColorTypes; i++) {
-            push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorTypes[i],
-                    sampleSize);
-            if (subset) {
-                push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorTypes[i],
-                        sampleSize);
+            for (SkAlphaType alphaType : alphaModes) {
+                push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorTypes[i],
+                        alphaType, sampleSize);
+                if (subset) {
+                    push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorTypes[i],
+                            alphaType, sampleSize);
+                }
             }
         }
     }
 }
 
 static bool brd_color_type_supported(SkBitmapRegionDecoder::Strategy strategy,
         CodecSrc::DstColorType dstColorType) {
     switch (strategy) {
         case SkBitmapRegionDecoder::kCanvas_Strategy:
             if (CodecSrc::kGetFromCanvas_DstColorType == dstColorType) {
@@ skipping 859 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