Add bench for image encodes

bench/EncoderBench.cpp

Index: bench/EncoderBench.cpp
diff --git a/bench/EncoderBench.cpp b/bench/EncoderBench.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..baa678e9234319ab9ccc8fa6f87d4ff7a21938f0
--- /dev/null
+++ b/bench/EncoderBench.cpp
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Benchmark.h"
+#include "Resources.h"
+#include "SkBitmap.h"
+#include "SkData.h"
+#include "SkImageEncoder.h"
+
+class EncodeBench : public Benchmark {
+public:
+    EncodeBench(const char* filename, SkImageEncoder::Type type, int quality)
+        : fFilename(filename)
+        , fType(type)
+        , fQuality(quality)
+    {
+        // Set the name of the bench
+        SkString name("Encode_");
+        name.append(filename);
+        name.append("_");
+        switch (type) {
+            case SkImageEncoder::kJPEG_Type:
+                name.append("JPEG");
+                break;
+            case SkImageEncoder::kPNG_Type:
+                name.append("PNG");
+                break;
+            case SkImageEncoder::kWEBP_Type:
+                name.append("WEBP");
+                break;
+            default:
+                name.append("Unknown");
+                break;
+        }
+        
+        fName = name;
+    }
+
+    bool isSuitableFor(Backend backend) override { return backend == kNonRendering_Backend; }
+    
+    const char* onGetName() override { return fName.c_str(); }
+    
+    void onPreDraw(SkCanvas*) override {
+#ifdef SK_DEBUG
+        bool result =
+#endif
+        GetResourceAsBitmap(fFilename, &fBitmap);
+        SkASSERT(result);
+    }
+
+    void onDraw(int loops, SkCanvas*) override {
+        for (int i = 0; i < loops; i++) {
+            SkAutoTUnref<SkData> data(SkImageEncoder::EncodeData(fBitmap, fType, fQuality));
+            SkASSERT(data);
+        }
+    }
+
+private:
+    const char*          fFilename;
+    SkImageEncoder::Type fType;

[scroggo, 2016/04/14 13:43:59]

nit: Many of these variables could be const.

[msarett, 2016/04/18 17:25:06]

Done.

+    int                  fQuality;
+    SkString             fName;
+    SkBitmap             fBitmap;
+};
+
+
+// The Android Photos app uses a quality of 90 on JPEG encodes
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kJPEG_Type, 90));

[scroggo, 2016/04/14 13:43:59]

Would it be interesting to use more than one image? Maybe that should be a TODO?

[msarett, 2016/04/18 17:25:06]

I think so.  I don't quite understand it well enough to know what types of
images might be interesting though.

It's easy enough to add another image here.  I'll go ahead and do that.  Or do
you think we should run this on a whole set of images like we do for CodecBench?
 If we do that, I think we should add a separate directory on gsutil for images
to test encoding with (rather than test on ALL of them).

[scroggo, 2016/04/18 17:53:49]

I'm not sure. I definitely think this is a good start. To answer that question,
I think we really need to learn more about encoding. What makes it take a
different path? I could imagine caring about alpha (since we may have
premultiplied the alpha, which is not what an encoder wants), but that is not
relevant for encoding to JPEG.

Using different images seems somewhat misleading. For example, we might have two
images that look (more or less) the same but are encoded differently. Once we
decode them to SkImages, encoding them to JPEG should be the same. So what might
be more interesting is to just draw (exercising features that are relevant) and
time the encode. But given that Photos (the app that really cares here) is
starting with JPEGs, using a JPEG is a reasonable thing to start with. Maybe we
should be starting with an actual camera photo?

+// PNG encodes are lossless so quality should be ignored
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kPNG_Type, 90));
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kWEBP_Type, 90));

[scroggo, 2016/04/14 13:43:59]

Do they also use 90 for quality on WEBP encodes? Do they use WEBP to encode?

[msarett, 2016/04/18 17:25:06]

The jpeg info is from judds' comment on the bug:

Background: A big part of the reason why Glide makes image loading feel fast is
that Glide caches downsampled and cropped images to disk (JPEG, quality 90).
We've had a few reports of quality issues (usually tinting and banding) for
these re-compressed images (https://github.com/bumptech/glide/issues/1069,
https://github.com/bumptech/glide/issues/515, b/21891795).
https://buganizer.corp.google.com/u/0/issues/28161384

I doubt that they use webp encoding, though I'm not sure.  I'm adding a TODO to
find the appropriate quality mode to bench webp encodes.