Delete dead subset benches from nanobench

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 481 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.)
+ * i.e. PNG, JPEG, and WEBP. We do *not* test WEBP, 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 bool run_subset_bench(const SkString& path) {
     static const char* const exts[] = {
-        "jpg", "jpeg",
-        "JPG", "JPEG",
+        "jpg", "jpeg", "png",
+        "JPG", "JPEG", "PNG",
     };
 
-    if (useCodec || FLAGS_jpgBuildTileIndex) {
-        for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
-            if (path.endsWith(exts[i])) {
-                return true;
-            }
+    for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
+        if (path.endsWith(exts[i])) {
+            return true;
         }
     }
 
-    // Test png in SkCodec, and optionally on SkImageDecoder. SkImageDecoder is
-    // disabled by default because it leaks memory.
-    // https://bug.skia.org/4360
-    if ((useCodec || FLAGS_pngBuildTileIndex) && (path.endsWith("png") || path.endsWith("PNG"))) {

[scroggo, 2015/11/10 22:13:17]

Please remove FLAGS_pngBuildTileIndex and FLAGS_jpegBuildTileIndex

[msarett, 2015/11/10 22:37:25]

Done.

-        return true;
-    }
-
-    if (!useCodec && (path.endsWith("webp") || path.endsWith("WEBP"))) {
-        return true;
-    }
-
     return false;
 }
 
 /*
  * 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,
+static bool valid_subset_bench(const SkString& path, SkColorType colorType,
         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) {
-        SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
-        if (nullptr == codec) {
-            SkDebugf("Could not create codec for %s.  Skipping bench.\n", path.c_str());
-            return false;
-        }
+    // Check that we can create a codec.
+    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
+    if (nullptr == codec) {
+        SkDebugf("Could not create codec for %s.  Skipping bench.\n", path.c_str());
+        return false;
+    }
 
-        // These will be initialized by SkCodec if the color type is kIndex8 and
-        // unused otherwise.
-        SkPMColor colors[256];
-        int colorCount;
-        const SkImageInfo info = codec->getInfo().makeColorType(colorType);
-        if (codec->startScanlineDecode(info, nullptr, colors, &colorCount) != SkCodec::kSuccess)
-        {
-            SkDebugf("Could not create scanline decoder for %s with color type %s.  "
-                    "Skipping bench.\n", path.c_str(), color_type_to_str(colorType));
-            return false;
-        }
-        *width = info.width();
-        *height = info.height();
-    } else {
-        SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream));
-        if (nullptr == decoder) {
-            SkDebugf("Could not create decoder for %s.  Skipping bench.\n", path.c_str());
-            return false;
-        }
-        //FIXME: See https://bug.skia.org/3921
-        if (kIndex_8_SkColorType == colorType || kGray_8_SkColorType == colorType) {
-            SkDebugf("Cannot use image subset decoder for %s with color type %s.  "
-                    "Skipping bench.\n", path.c_str(), color_type_to_str(colorType));
-            return false;
-        }
-        if (!decoder->buildTileIndex(stream.detach(), width, height)) {
-            SkDebugf("Could not build tile index for %s.  Skipping bench.\n", path.c_str());
-            return false;
-        }
+    // These will be initialized by SkCodec if the color type is kIndex8 and
+    // unused otherwise.
+    SkPMColor colors[256];
+    int colorCount;
+    const SkImageInfo info = codec->getInfo().makeColorType(colorType);
+    if (codec->startScanlineDecode(info, nullptr, colors, &colorCount) != SkCodec::kSuccess)
+    {
+        SkDebugf("Could not create scanline decoder for %s with color type %s.  "
+                "Skipping bench.\n", path.c_str(), color_type_to_str(colorType));
+        return false;
     }
+    *width = info.width();
+    *height = info.height();
 
     // Check if the image is large enough for a meaningful subset benchmark.
     if (*width <= 512 && *height <= 512) {
         // This should not print a message since it is not an error.
         return false;
     }
 
     return true;
 }
 
 static bool valid_brd_bench(SkData* encoded, SkBitmapRegionDecoder::Strategy strategy,
         SkColorType colorType, uint32_t sampleSize, uint32_t minOutputSize, int* width,
         int* height) {
     SkAutoTDelete<SkBitmapRegionDecoder> brd(
             SkBitmapRegionDecoder::Create(encoded, strategy));
     if (nullptr == brd.get()) {
         // This is indicates that subset decoding is not supported for a particular image format.
         return false;
     }
 
     SkBitmap bitmap;
     if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, brd->width(), brd->height()),
             1, colorType, false)) {
         return false;
     }
-    if (colorType != bitmap.colorType()) {
-        // This indicates that conversion to the requested color type is not supported for the
-        // particular image.
-        return false;
-    }
 
     if (sampleSize * minOutputSize > (uint32_t) brd->width() || sampleSize * minOutputSize >
             (uint32_t) brd->height()) {
         // This indicates that the image is not large enough to decode a
         // minOutputSize x minOutputSize subset at the given sampleSize.
         return false;
     }
 
     // Set the image width and height.  The calling code will use this to choose subsets to decode.
     *width = brd->width();
@@ skipping 270 matching lines @@
                         colorType, SkImageDecoder::kDecodePixels_Mode)
                         && bitmap.colorType() == colorType) {
                     return new DecodingBench(path, colorType);
                 }
             }
             fCurrentColorType = 0;
             fCurrentImage++;
         }
 
         // Run the SubsetBenches
-        bool useCodecOpts[] = { true, false };
-        while (fUseCodec < 2) {
-            bool useCodec = useCodecOpts[fUseCodec];
+        while (fCurrentSubsetImage < fImages.count()) {
             fSourceType = "image";
-            fBenchType = useCodec ? "skcodec" : "skimagedecoder";
-            while (fCurrentSubsetImage < fImages.count()) {
-                const SkString& path = fImages[fCurrentSubsetImage];
-                if (!run_subset_bench(path, useCodec)) {
-                    fCurrentSubsetImage++;
-                    continue;
+            fBenchType = "skcodec";
+            const SkString& path = fImages[fCurrentSubsetImage];
+            if (!run_subset_bench(path)) {
+                fCurrentSubsetImage++;
+                continue;
+            }
+            while (fCurrentColorType < fColorTypes.count()) {
+                SkColorType colorType = fColorTypes[fCurrentColorType];
+                while (fCurrentSubsetType <= kLast_SubsetType) {
+                    int width = 0;
+                    int height = 0;
+                    int currentSubsetType = fCurrentSubsetType++;
+                    if (valid_subset_bench(path, colorType, &width, &height)) {
+                        switch (currentSubsetType) {
+                            case kTopLeft_SubsetType:
+                                return new SubsetSingleBench(path, colorType, width/3,
+                                        height/3, 0, 0);
+                            case kTopRight_SubsetType:
+                                return new SubsetSingleBench(path, colorType, width/3,
+                                        height/3, 2*width/3, 0);
+                            case kMiddle_SubsetType:
+                                return new SubsetSingleBench(path, colorType, width/3,
+                                        height/3, width/3, height/3);
+                            case kBottomLeft_SubsetType:
+                                return new SubsetSingleBench(path, colorType, width/3,
+                                        height/3, 0, 2*height/3);
+                            case kBottomRight_SubsetType:
+                                return new SubsetSingleBench(path, colorType, width/3,
+                                        height/3, 2*width/3, 2*height/3);
+                            case kTranslate_SubsetType:
+                                return new SubsetTranslateBench(path, colorType, 512, 512);
+                            case kZoom_SubsetType:
+                                return new SubsetZoomBench(path, colorType, 512, 512);
+                        }
+                    } else {
+                        break;
+                    }
                 }
-                while (fCurrentColorType < fColorTypes.count()) {
-                    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);
-                                case kTopRight_SubsetType:
-                                    return new SubsetSingleBench(path, colorType, width/3,
-                                            height/3, 2*width/3, 0, useCodec);
-                                case kMiddle_SubsetType:
-                                    return new SubsetSingleBench(path, colorType, width/3,
-                                            height/3, width/3, height/3, useCodec);
-                                case kBottomLeft_SubsetType:
-                                    return new SubsetSingleBench(path, colorType, width/3,
-                                            height/3, 0, 2*height/3, useCodec);
-                                case kBottomRight_SubsetType:
-                                    return new SubsetSingleBench(path, colorType, width/3,
-                                            height/3, 2*width/3, 2*height/3, useCodec);
-                                case kTranslate_SubsetType:
-                                    return new SubsetTranslateBench(path, colorType, 512, 512,
-                                            useCodec);
-                                case kZoom_SubsetType:
-                                    return new SubsetZoomBench(path, colorType, 512, 512,
-                                            useCodec);
-                            }
-                        } else {
-                            break;
-                        }
-                    }
-                    fCurrentSubsetType = 0;
-                    fCurrentColorType++;
-                }
-                fCurrentColorType = 0;
-                fCurrentSubsetImage++;
+                fCurrentSubsetType = 0;
+                fCurrentColorType++;
             }
-            fCurrentSubsetImage = 0;
-            fUseCodec++;
+            fCurrentColorType = 0;
+            fCurrentSubsetImage++;
         }
 
         // Run the BRDBenches
         // We will benchmark multiple BRD strategies.
         static const struct {
             SkBitmapRegionDecoder::Strategy    fStrategy;
-            const char*                                 fName;
+            const char*                        fName;
         } strategies[] = {
-            { SkBitmapRegionDecoder::kOriginal_Strategy,    "BRD" },
-            { SkBitmapRegionDecoder::kCanvas_Strategy,      "BRD_canvas" },
+            { SkBitmapRegionDecoder::kCanvas_Strategy,       "BRD_canvas" },
             { SkBitmapRegionDecoder::kAndroidCodec_Strategy, "BRD_android_codec" },
         };
 
         // We intend to create benchmarks that model the use cases in
         // android/libraries/social/tiledimage.  In this library, an image is decoded in 512x512
         // tiles.  The image can be translated freely, so the location of a tile may be anywhere in
         // the image.  For that reason, we will benchmark decodes in five representative locations
         // in the image.  Additionally, this use case utilizes power of two scaling, so we will
         // test on power of two sample sizes.  The output tile is always 512x512, so, when a
         // sampleSize is used, the size of the subset that is decoded is always
         // (sampleSize*512)x(sampleSize*512).
         // There are a few good reasons to only test on power of two sample sizes at this time:
         //     JPEG decodes using kOriginal_Strategy are broken for non-powers of two.
         //         https://bug.skia.org/4319
         //     All use cases we are aware of only scale by powers of two.
         //     PNG decodes use the indicated sampling strategy regardless of the sample size, so
         //         these tests are sufficient to provide good coverage of our scaling options.
         const uint32_t sampleSizes[] = { 1, 2, 4, 8, 16, 32, 64 };
         const uint32_t minOutputSize = 512;
         while (fCurrentBRDImage < fImages.count()) {
             while (fCurrentBRDStrategy < (int) SK_ARRAY_COUNT(strategies)) {
                 fSourceType = "image";
                 fBenchType = strategies[fCurrentBRDStrategy].fName;
 
                 const SkString& path = fImages[fCurrentBRDImage];
                 const SkBitmapRegionDecoder::Strategy strategy =
                         strategies[fCurrentBRDStrategy].fStrategy;
 
-                if (SkBitmapRegionDecoder::kOriginal_Strategy == strategy) {
-                    // Disable png and jpeg for SkImageDecoder:
-                    if (!FLAGS_jpgBuildTileIndex) {
-                        if (path.endsWith("JPEG") || path.endsWith("JPG") ||
-                            path.endsWith("jpeg") || path.endsWith("jpg"))
-                        {
-                            fCurrentBRDStrategy++;
-                            continue;
-                        }
-                    }
-                    if (!FLAGS_pngBuildTileIndex) {
-                        if (path.endsWith("PNG") || path.endsWith("png")) {
-                            fCurrentBRDStrategy++;
-                            continue;
-                        }
-                    }
-                }
-
                 while (fCurrentColorType < fColorTypes.count()) {
                     while (fCurrentBRDSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
                         while (fCurrentSubsetType <= kLastSingle_SubsetType) {
 
 
                             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
                             const SkColorType colorType = fColorTypes[fCurrentColorType];
                             uint32_t sampleSize = sampleSizes[fCurrentBRDSampleSize];
                             int currentSubsetType = fCurrentSubsetType++;
 
@@ skipping 317 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif