Renable image benchmarking

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 94 matching lines @@
 DEFINE_string(scales, "1.0", "Space-separated scales for SKPs.");
 DEFINE_string(zoom, "1.0,0", "Comma-separated zoomMax,zoomPeriodMs factors for a periodic SKP zoom "
                              "function that ping-pongs between 1.0 and zoomMax.");
 DEFINE_bool(bbh, true, "Build a BBH for SKPs?");
 DEFINE_bool(mpd, true, "Use MultiPictureDraw for the SKPs?");
 DEFINE_bool(loopSKP, true, "Loop SKPs like we do for micro benches?");
 DEFINE_int32(flushEvery, 10, "Flush --outResultsFile every Nth run.");
 DEFINE_bool(resetGpuContext, true, "Reset the GrContext before running each test.");
 DEFINE_bool(gpuStats, false, "Print GPU stats after each gpu benchmark?");
 DEFINE_bool(pngBuildTileIndex, false, "If supported, use png buildTileIndex/decodeSubset.");
+DEFINE_bool(jpgBuildTileIndex, false, "If supported, use jpg buildTileIndex/decodeSubset.");
 
 static SkString humanize(double ms) {
     if (FLAGS_verbose) return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
     return HumanizeMs(ms);
 }
 #define HUMANIZE(ms) humanize(ms).c_str()
 
 bool Target::init(SkImageInfo info, Benchmark* bench) {
     if (Benchmark::kRaster_Backend == config.backend) {
         this->surface.reset(SkSurface::NewRaster(info));
@@ skipping 381 matching lines @@
  * 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",
         "JPG", "JPEG",
     };
 
-    for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
-        if (path.endsWith(exts[i])) {
-            return true;
+    if (useCodec || FLAGS_jpgBuildTileIndex) {
+        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.
     // skbug.com/4360
     if ((useCodec || FLAGS_pngBuildTileIndex) && (path.endsWith("png") || path.endsWith("PNG"))) {
         return true;
     }
 
@@ skipping 447 matching lines @@
         //         skbug.com/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 };
         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 SkBitmapRegionDecoderInterface::Strategy strategy =
+                        strategies[fCurrentBRDStrategy].fStrategy;
+
+                if (SkBitmapRegionDecoderInterface::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) {
-                            const SkString& path = fImages[fCurrentBRDImage];
-                            const SkBitmapRegionDecoderInterface::Strategy strategy =
-                                    strategies[fCurrentBRDStrategy].fStrategy;
+
+
                             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
                             const SkColorType colorType = fColorTypes[fCurrentColorType];
                             uint32_t sampleSize = sampleSizes[fCurrentBRDSampleSize];
                             int currentSubsetType = fCurrentSubsetType++;
 
                             int width = 0;
                             int height = 0;
                             if (!valid_brd_bench(encoded.get(), strategy, colorType, sampleSize,
                                     minOutputSize, &width, &height)) {
                                 break;
@@ skipping 336 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif