Add color correction benchmark - with comparison to qcms

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 "ColorCodecBench.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"
@@ skipping 524 matching lines @@
 public:
     BenchmarkStream() : fBenches(BenchRegistry::Head())
                       , fGMs(skiagm::GMRegistry::Head())
                       , fCurrentRecording(0)
                       , fCurrentScale(0)
                       , fCurrentSKP(0)
                       , fCurrentUseMPD(0)
                       , fCurrentCodec(0)
                       , fCurrentAndroidCodec(0)
                       , fCurrentBRDImage(0)
+                      , fCurrentColorImage(0)
                       , fCurrentColorType(0)
                       , fCurrentAlphaType(0)
                       , fCurrentSubsetType(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");
@@ skipping 24 matching lines @@
 
         if (FLAGS_mpd) {
             fUseMPDs.push_back() = true;
         }
         fUseMPDs.push_back() = false;
 
         // Prepare the images for decoding
         if (!CollectImages(FLAGS_images, &fImages)) {
             exit(1);
         }
+        if (!CollectImages(FLAGS_colorImages, &fColorImages)) {
+            exit(1);
+        }
 
         // Choose the candidate color types for image decoding
         const SkColorType colorTypes[] =
             { kN32_SkColorType,
               kRGB_565_SkColorType,
               kAlpha_8_SkColorType,
               kIndex_8_SkColorType,
               kGray_8_SkColorType };
         fColorTypes.reset(colorTypes, SK_ARRAY_COUNT(colorTypes));
     }
@@ skipping 295 matching lines @@
                     }
                     fCurrentSubsetType = 0;
                     fCurrentSampleSize++;
                 }
                 fCurrentSampleSize = 0;
                 fCurrentColorType++;
             }
             fCurrentColorType = 0;
         }
 
+        while (fCurrentColorImage < fColorImages.count()) {
+            fSourceType = "colorimage";
+            fBenchType = "skcolorcodec";
+            const SkString& path = fColorImages[fCurrentColorImage];
+            fCurrentColorImage++;
+            sk_sp<SkData> encoded = SkData::MakeFromFileName(path.c_str());
+            if (encoded) {
+                return new ColorCodecBench(SkOSPath::Basename(path.c_str()).c_str(),
+                                           std::move(encoded));
+            } else {
+                SkDebugf("Could not read file %s.\n", path.c_str());
+            }
+        }
+
         return nullptr;
     }
 
     void fillCurrentOptions(ResultsWriter* log) const {
         log->configOption("source_type", fSourceType);
         log->configOption("bench_type",  fBenchType);
         if (0 == strcmp(fSourceType, "skp")) {
             log->configOption("clip",
                     SkStringPrintf("%d %d %d %d", fClip.fLeft, fClip.fTop,
                                                   fClip.fRight, fClip.fBottom).c_str());
@@ skipping 23 matching lines @@
         kLastSingle_SubsetType  = kBottomRight_SubsetType,
     };
 
     const BenchRegistry* fBenches;
     const skiagm::GMRegistry* fGMs;
     SkIRect            fClip;
     SkTArray<SkScalar> fScales;
     SkTArray<SkString> fSKPs;
     SkTArray<bool>     fUseMPDs;
     SkTArray<SkString> fImages;
+    SkTArray<SkString> fColorImages;
     SkTArray<SkColorType, true> fColorTypes;
     SkScalar           fZoomMax;
     double             fZoomPeriodMs;
 
     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 fCurrentColorImage;
     int fCurrentColorType;
     int fCurrentAlphaType;
     int fCurrentSubsetType;
     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() {
@@ skipping 277 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif