Update Subset benches to support interlacing and fix bugs

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
@@ skipping 483 matching lines @@
     }
 
     if (!target->init(info, bench)) {
         delete target;
         return nullptr;
     }
     return target;
 }
 
 /*
+ * We only run our subset benches on files that are supported by BitmapRegionDecoder:
+ * i.e. PNG, JPEG, and WEBP. We do *not* test WEBP when using codec, since we do not
+ * have a scanline decoder for WEBP, which is necessary for running the subset bench.
+ * (Another bench must be used to test WEBP, which decodes subsets natively.)
+ */
+static bool run_subset_bench(const SkString& path, bool useCodec) {
+    static const char* const exts[] = {
+        "jpg", "jpeg", "png",
+        "JPG", "JPEG", "PNG",
+    };
+
+    for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
+        if (path.endsWith(exts[i])) {
+            return true;
+        }
+    }
+
+    return !useCodec && (path.endsWith("webp") || path.endsWith("WEBP"));

[msarett, 2015/10/07 20:06:08]

It occurs to me that we've done very little to benchmark webp subset decodes. 
I'm guessing that we probably won't see any surprises since our implementation
is so similar to SkImageDecoder?

[scroggo, 2015/10/07 20:09:10]

Yes. I do think it's worth benchmarking in general, but it shouldn't hold up
switching to SkCodec.

+}
+
+/*
  * Returns true if set up for a subset decode succeeds, false otherwise
  * If the set-up succeeds, the width and height parameters will be set
  */
 static bool valid_subset_bench(const SkString& path, SkColorType colorType, bool useCodec,
         int* width, int* height) {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
     SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
 
     // Check that we can create a codec or image decoder.
     if (useCodec) {
@@ skipping 346 matching lines @@
             }
             fCurrentColorType = 0;
             fCurrentImage++;
         }
 
         // Run the SubsetBenches
         bool useCodecOpts[] = { true, false };
         while (fUseCodec < 2) {
             bool useCodec = useCodecOpts[fUseCodec];
             while (fCurrentSubsetImage < fImages.count()) {
+                const SkString& path = fImages[fCurrentSubsetImage];
+                if (!run_subset_bench(path, useCodec)) {
+                    fCurrentSubsetImage++;
+                    continue;
+                }
                 while (fCurrentColorType < fColorTypes.count()) {
-                    const SkString& path = fImages[fCurrentSubsetImage];
                     SkColorType colorType = fColorTypes[fCurrentColorType];
                     while (fCurrentSubsetType <= kLast_SubsetType) {
                         int width = 0;
                         int height = 0;
                         int currentSubsetType = fCurrentSubsetType++;
                         if (valid_subset_bench(path, colorType, useCodec, &width, &height)) {
                             switch (currentSubsetType) {
                                 case kTopLeft_SubsetType:
                                     return new SubsetSingleBench(path, colorType, width/3,
                                             height/3, 0, 0, useCodec);
@@ skipping 410 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif