Add an SkImageGeneratorCG

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 230 matching lines @@
             break;
         case CodecSrc::kStripe_Mode:
             folder.append("stripe");
             break;
         case CodecSrc::kCroppedScanline_Mode:
             folder.append("crop");
             break;
         case CodecSrc::kSubset_Mode:
             folder.append("codec_subset");
             break;
-        case CodecSrc::kGen_Mode:
-            folder.append("gen");
-            break;
     }
 
     switch (dstColorType) {
         case CodecSrc::kGrayscale_Always_DstColorType:
             folder.append("_kGray8");
             break;
         case CodecSrc::kIndex8_Always_DstColorType:
             folder.append("_kIndex8");
             break;
         default:
@@ skipping 60 matching lines @@
     }
 
     if (1 != sampleSize) {
         folder.appendf("_%.3f", 1.0f / (float) sampleSize);
     }
 
     AndroidCodecSrc* src = new AndroidCodecSrc(path, mode, dstColorType, dstAlphaType, sampleSize);
     push_src("image", folder, src);
 }
 
+static void push_image_gen_src(Path path, ImageGenSrc::Mode mode, SkAlphaType alphaType, bool isGpu) {

[scroggo, 2016/03/07 13:04:30]

nit: 100 chars

[msarett, 2016/03/08 23:20:17]

Done.

+    SkString folder;
+    switch (mode) {
+        case ImageGenSrc::kCodec_Mode:
+            folder.append("gen_codec");
+            break;
+        case ImageGenSrc::kCG_Mode:
+            folder.append("gen_cg");
+            break;
+    }
+
+    if (isGpu) {
+        folder.append("_gpu");
+    } else {
+        switch (alphaType) {
+            case kOpaque_SkAlphaType:
+                folder.append("_opaque");
+                break;
+            case kPremul_SkAlphaType:
+                folder.append("_premul");
+                break;
+            case kUnpremul_SkAlphaType:
+                folder.append("_unpremul");
+                break;
+            default:
+                break;
+        }
+    }
+
+    ImageGenSrc* src = new ImageGenSrc(path, mode, alphaType, isGpu);
+    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));
     if (nullptr == codec.get()) {
         SkDebugf("Couldn't create codec for %s.", path.c_str());
         return;
     }
 
     // Native Scales
     // TODO (msarett): Implement scaling tests for SkImageDecoder in order to compare with these
     //                 tests.  SkImageDecoder supports downscales by integer factors.
     // SkJpegCodec natively supports scaling to: 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875
     const float nativeScales[] = { 0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.750f, 0.875f, 1.0f };
 
     SkTArray<CodecSrc::Mode> nativeModes;
     nativeModes.push_back(CodecSrc::kCodec_Mode);
     nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
-    nativeModes.push_back(CodecSrc::kGen_Mode);
     switch (codec->getEncodedFormat()) {
         case SkEncodedFormat::kJPEG_SkEncodedFormat:
             nativeModes.push_back(CodecSrc::kScanline_Mode);
             nativeModes.push_back(CodecSrc::kStripe_Mode);
             nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
             break;
         case SkEncodedFormat::kWEBP_SkEncodedFormat:
             nativeModes.push_back(CodecSrc::kSubset_Mode);
             break;
         case SkEncodedFormat::kRAW_SkEncodedFormat:
@@ skipping 21 matching lines @@
     }
 
     SkTArray<SkAlphaType> alphaModes;
     alphaModes.push_back(kPremul_SkAlphaType);
     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,
-                               codec->getInfo().alphaType(), 1.0f);
-            }
-            continue;
-        }
-
         for (float scale : nativeScales) {
             for (CodecSrc::DstColorType colorType : colorTypes) {
                 for (SkAlphaType alphaType : alphaModes) {
                     // Only test kCroppedScanline_Mode when the alpha type is opaque.  The test is
                     // slow and won't be interestingly different with different alpha types.
                     if (CodecSrc::kCroppedScanline_Mode == mode &&
                             kOpaque_SkAlphaType != alphaType) {
                         continue;
                     }
 
@@ skipping 25 matching lines @@
             for (SkAlphaType alphaType : alphaModes) {
                 push_android_codec_src(path, AndroidCodecSrc::kFullImage_Mode, colorType,
                         alphaType, sampleSize);
                 if (subset) {
                     push_android_codec_src(path, AndroidCodecSrc::kDivisor_Mode, colorType,
                             alphaType, sampleSize);
                 }
             }
         }
     }
+
+    // Push image generator GPU test.
+    // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
+    if (kGray_8_SkColorType != codec->getInfo().colorType()) {
+        push_image_gen_src(path, ImageGenSrc::kCodec_Mode, codec->getInfo().alphaType(), true);
+    }
+
+    // Push image generator CPU tests.
+    for (SkAlphaType alphaType : alphaModes) {
+        push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+        if (kWEBP_SkEncodedFormat != codec->getEncodedFormat() &&
+            kWBMP_SkEncodedFormat != codec->getEncodedFormat() &&
+            kUnpremul_SkAlphaType != alphaType)
+        {
+            push_image_gen_src(path, ImageGenSrc::kCG_Mode, alphaType, false);
+        }
+#endif
+    }
 }
 
 static bool brd_color_type_supported(SkBitmapRegionDecoder::Strategy strategy,
         CodecSrc::DstColorType dstColorType) {
     switch (strategy) {
         case SkBitmapRegionDecoder::kCanvas_Strategy:
             if (CodecSrc::kGetFromCanvas_DstColorType == dstColorType) {
                 return true;
             }
             return false;
@@ skipping 828 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