Add a DM flag to limit the types of Codec decodes

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 "SkCommonFlags.h"
 #include "SkCommonFlagsConfig.h"
 #include "SkFontMgr.h"
-#include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkMD5.h"
 #include "SkMutex.h"
 #include "SkOSFile.h"
 #include "SkSpinlock.h"
 #include "SkTHash.h"
 #include "SkTaskGroup.h"
 #include "SkThreadUtils.h"
 #include "Test.h"
 #include "Timer.h"
@@ skipping 27 matching lines @@
         "'--blacklist gpu skp _ _ 8888 gm _ aarects' will also blacklist the aarects GM on 8888.");
 
 DEFINE_string2(readPath, r, "", "If set check for equality with golden results in this directory.");
 
 DEFINE_string(uninterestingHashesFile, "",
         "File containing a list of uninteresting hashes. If a result hashes to something in "
         "this list, no image is written for that result.");
 
 DEFINE_int32(shards, 1, "We're splitting source data into this many shards.");
 DEFINE_int32(shard,  0, "Which shard do I run?");
+DEFINE_bool(simpleCodec, false, "Only decode images to native scale");

[scroggo, 2016/02/25 17:08:36]

Alternatively, we can set this to true as the default, and update dm_flags.py to
set it to false. When running locally, I often just want to verify that decoding
worked as I expected for the normal case. Gold will help us sort out the rest,
but I hate searching through all those folders to find the basic one I want.

(FWIW, this CL cuts us down to three folders per config. I could cut it down to
only decoding to unpremul when simpleCodec is true, which cuts us down to one.)

[msarett, 2016/02/25 17:47:37]

Acknowledged.

 
-__SK_FORCE_IMAGE_DECODER_LINKING;
 using namespace DM;
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
 static SkTArray<SkString> gFailures;
 
 static void fail(const SkString& err) {
     SkAutoMutexAcquire lock(gFailuresMutex);
     SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
@@ skipping 152 matching lines @@
         !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,
         SkAlphaType dstAlphaType, float scale) {
+    if (FLAGS_simpleCodec) {
+        if (mode != CodecSrc::kCodec_Mode || dstColorType != CodecSrc::kGetFromCanvas_DstColorType
+                || scale != 1.0f)
+            // Only decode in the simple case.
+            return;
+    }
     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 96 matching lines @@
         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);
@@ skipping 57 matching lines @@
                             kOpaque_SkAlphaType != alphaType) {
                         continue;
                     }
 
                     push_codec_src(path, mode, colorType, alphaType, scale);
                 }
             }
         }
     }
 
+    if (FLAGS_simpleCodec) {
+        return;
+    }
+
     // 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)) {
@@ skipping 159 matching lines @@
         }
     }
 
     SkTArray<SkString> images;
     if (!CollectImages(&images)) {
         return false;
     }
 
     for (auto image : images) {
         push_codec_srcs(image);
+        if (FLAGS_simpleCodec) {
+            continue;
+        }
+
         const char* ext = strrchr(image.c_str(), '.');
         if (ext && brd_supported(ext+1)) {
             push_brd_srcs(image);
         }
     }
 
     return true;
 }
 
 static void push_sink(const SkCommandLineConfig& config, Sink* s) {
@@ skipping 648 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