Add AndroidCodecBench to time scaled decodes

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"
 
+#include "AndroidCodecBench.h"
 #include "Benchmark.h"
 #include "BitmapRegionDecoderBench.h"
 #include "CodecBench.h"
 #include "CodecBenchPriv.h"
 #include "CrashHandler.h"
 #include "GMBench.h"
 #include "ProcStats.h"
 #include "ResultsWriter.h"
 #include "RecordingBench.h"
 #include "SKPAnimationBench.h"
 #include "SKPBench.h"
 #include "Stats.h"
 
+#include "SkAndroidCodec.h"
 #include "SkBitmapRegionDecoder.h"
 #include "SkBBoxHierarchy.h"
 #include "SkCanvas.h"
 #include "SkCodec.h"
 #include "SkCommonFlags.h"
 #include "SkCommonFlagsConfig.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkOSFile.h"
@@ skipping 504 matching lines @@
 
 class BenchmarkStream {
 public:
     BenchmarkStream() : fBenches(BenchRegistry::Head())
                       , fGMs(skiagm::GMRegistry::Head())
                       , fCurrentRecording(0)
                       , fCurrentScale(0)
                       , fCurrentSKP(0)
                       , fCurrentUseMPD(0)
                       , fCurrentCodec(0)
+                      , fCurrentAndroidCodec(0)
                       , fCurrentBRDImage(0)
                       , fCurrentColorType(0)
                       , fCurrentAlphaType(0)
                       , fCurrentSubsetType(0)
                       , fCurrentBRDStrategy(0)
-                      , fCurrentBRDSampleSize(0)
+                      , fCurrentSampleSize(0)
                       , fCurrentAnimSKP(0) {
         for (int i = 0; i < FLAGS_skps.count(); i++) {
             if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
                 fSKPs.push_back() = FLAGS_skps[i];
             } else {
                 SkOSFile::Iter it(FLAGS_skps[i], ".skp");
                 SkString path;
                 while (it.next(&path)) {
                     fSKPs.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
                 }
@@ skipping 225 matching lines @@
                         break;
                     default:
                         // This represents some sort of failure.
                         SkASSERT(false);
                         break;
                 }
             }
             fCurrentColorType = 0;
         }
 
+        // Run AndroidCodecBenches
+        const int sampleSizes[] = { 2, 4, 8 };
+        for (; fCurrentAndroidCodec < fImages.count(); fCurrentAndroidCodec++) {
+            fSourceType = "image";
+            fBenchType = "skandroidcodec";
+
+            const SkString& path = fImages[fCurrentAndroidCodec];
+            if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
+                continue;
+            }
+            SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
+            SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
+            if (!codec) {
+                // Nothing to time.
+                SkDebugf("Cannot find codec for %s\n", path.c_str());
+                continue;
+            }
+
+            while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
+                int sampleSize = sampleSizes[fCurrentSampleSize];
+                fCurrentSampleSize++;
+                if (10 * sampleSize > SkTMin(codec->getInfo().width(), codec->getInfo().height())) {
+                    // Avoid benchmarking scaled decodes of already small images.
+                    break;
+                }
+
+                return new AndroidCodecBench(SkOSPath::Basename(path.c_str()), encoded, sampleSize);
+            }
+            fCurrentSampleSize = 0;
+        }
+
         // Run the BRDBenches
         // We will benchmark multiple BRD strategies.
         static const struct {
             SkBitmapRegionDecoder::Strategy    fStrategy;
             const char*                        fName;
         } strategies[] = {
             { 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 brdSampleSizes[] = { 1, 2, 4, 8, 16 };
         const uint32_t minOutputSize = 512;
         for (; fCurrentBRDImage < fImages.count(); fCurrentBRDImage++) {
             const SkString& path = fImages[fCurrentBRDImage];
             if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
                 continue;
             }
             while (fCurrentBRDStrategy < (int) SK_ARRAY_COUNT(strategies)) {
                 fSourceType = "image";
                 fBenchType = strategies[fCurrentBRDStrategy].fName;
 
                 const SkBitmapRegionDecoder::Strategy strategy =
                         strategies[fCurrentBRDStrategy].fStrategy;
 
                 while (fCurrentColorType < fColorTypes.count()) {
-                    while (fCurrentBRDSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
+                    while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
                         while (fCurrentSubsetType <= kLastSingle_SubsetType) {
 
-
                             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
                             const SkColorType colorType = fColorTypes[fCurrentColorType];
-                            uint32_t sampleSize = sampleSizes[fCurrentBRDSampleSize];
+                            uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
                             int currentSubsetType = fCurrentSubsetType++;
 
                             int width = 0;
                             int height = 0;
                             if (!valid_brd_bench(encoded.get(), strategy, colorType, sampleSize,
                                     minOutputSize, &width, &height)) {
                                 break;
                             }
 
                             SkString basename = SkOSPath::Basename(path.c_str());
@@ skipping 25 matching lines @@
                                             height - subsetSize, subsetSize, subsetSize);
                                     break;
                                 default:
                                     SkASSERT(false);
                             }
 
                             return new BitmapRegionDecoderBench(basename.c_str(), encoded.get(),
                                     strategy, colorType, sampleSize, subset);
                         }
                         fCurrentSubsetType = 0;
-                        fCurrentBRDSampleSize++;
+                        fCurrentSampleSize++;
                     }
-                    fCurrentBRDSampleSize = 0;
+                    fCurrentSampleSize = 0;
                     fCurrentColorType++;
                 }
                 fCurrentColorType = 0;
                 fCurrentBRDStrategy++;
             }
             fCurrentBRDStrategy = 0;
         }
 
         return nullptr;
     }
@@ skipping 44 matching lines @@
 
     double fSKPBytes, fSKPOps;
 
     const char* fSourceType;  // What we're benching: bench, GM, SKP, ...
     const char* fBenchType;   // How we bench it: micro, recording, playback, ...
     int fCurrentRecording;
     int fCurrentScale;
     int fCurrentSKP;
     int fCurrentUseMPD;
     int fCurrentCodec;
+    int fCurrentAndroidCodec;
     int fCurrentBRDImage;
     int fCurrentColorType;
     int fCurrentAlphaType;
     int fCurrentSubsetType;
     int fCurrentBRDStrategy;
-    int fCurrentBRDSampleSize;
+    int fCurrentSampleSize;
     int fCurrentAnimSKP;
 };
 
 // Some runs (mostly, Valgrind) are so slow that the bot framework thinks we've hung.
 // This prints something every once in a while so that it knows we're still working.
 static void start_keepalive() {
     struct Loop {
         static void forever(void*) {
             for (;;) {
                 static const int kSec = 1200;
@@ skipping 269 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif