change benchmark to use surfaces instead of devices to specify its backends

bench/benchmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "BenchTimer.h"
 #include "ResultsWriter.h"
 #include "SkBenchLogger.h"
 #include "SkBenchmark.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
+#include "SkData.h"
 #include "SkDeferredCanvas.h"
 #include "SkGraphics.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkString.h"
+#include "SkSurface.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextFactory.h"
 #include "GrRenderTarget.h"
 #include "SkGpuDevice.h"
 #include "gl/GrGLDefines.h"
 #else
 class GrContext;
 #endif // SK_SUPPORT_GPU
 
 #include <limits>
 
 enum BenchMode {
     kNormal_BenchMode,
     kDeferred_BenchMode,
     kDeferredSilent_BenchMode,
     kRecord_BenchMode,
     kPictureRecord_BenchMode
 };
 const char* BenchMode_Name[] = {
     "normal", "deferred", "deferredSilent", "record", "picturerecord"
 };
 
 static const char kDefaultsConfigStr[] = "defaults";
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void erase(SkBitmap& bm) {
-    if (bm.config() == SkBitmap::kA8_Config) {
-        bm.eraseColor(SK_ColorTRANSPARENT);
-    } else {
-        bm.eraseColor(SK_ColorWHITE);
-    }
-}
-
 class Iter {
 public:
     Iter() : fBench(BenchRegistry::Head()) {}
 
     SkBenchmark* next() {
         if (fBench) {
             BenchRegistry::Factory f = fBench->factory();
             fBench = fBench->next();
             return f();
         }
@@ skipping 25 matching lines @@
             case ' ':
             case ':':
                 path->writable_str()[i] = '-';
                 break;
             default:
                 break;
         }
     }
 }
 
 static void saveFile(const char name[], const char config[], const char dir[],

[mtklein, 2014/02/03 21:34:43]

This would make a bit more conceptual sense if it took the const SkImage&
instead of the source surface.

[reed1, 2014/02/03 21:39:48]

Not sure why. I am saving the state of the surface to a file. I *could* snapshot
an image, or I *could* draw the surface into an offscreen bitmap, or ...

[mtklein, 2014/02/03 21:47:32]

Yeah, that's sort of why it made more sense to me to take an SkImage.  We can do
almost anything to the surface that you pass in here, but there's less that can
be done to a const SkImage.

-                     const SkBitmap& bm) {
-    SkBitmap copy;
-    if (!bm.copyTo(&copy, SkBitmap::kARGB_8888_Config)) {
+                     SkSurface* surface) {
+    SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+    if (NULL == image.get()) {
         return;
     }
 
-    if (bm.config() == SkBitmap::kA8_Config) {
-        // turn alpha into gray-scale
-        size_t size = copy.getSize() >> 2;
-        SkPMColor* p = copy.getAddr32(0, 0);
-        for (size_t i = 0; i < size; i++) {
-            int c = (*p >> SK_A32_SHIFT) & 0xFF;
-            c = 255 - c;
-            c |= (c << 24) | (c << 16) | (c << 8);
-            *p++ = c | (SK_A32_MASK << SK_A32_SHIFT);
-        }
+    SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100));
+    if (NULL == data.get()) {
+        return;
     }
 
     SkString filename;
     make_filename(name, &filename);
     filename.appendf("_%s.png", config);
     SkString path = SkOSPath::SkPathJoin(dir, filename.c_str());
     ::remove(path.c_str());
-    SkImageEncoder::EncodeFile(path.c_str(), copy, SkImageEncoder::kPNG_Type, 100);
+
+    SkFILEWStream   stream(filename.c_str());
+    stream.write(data->data(), data->size());
 }
 
 static void performClip(SkCanvas* canvas, int w, int h) {
     SkRect r;
 
     r.set(SkIntToScalar(10), SkIntToScalar(10),
           SkIntToScalar(w*2/3), SkIntToScalar(h*2/3));
     canvas->clipRect(r, SkRegion::kIntersect_Op);
 
     r.set(SkIntToScalar(w/3), SkIntToScalar(h/3),
@@ skipping 13 matching lines @@
 static void performScale(SkCanvas* canvas, int w, int h) {
     const SkScalar x = SkIntToScalar(w) / 2;
     const SkScalar y = SkIntToScalar(h) / 2;
 
     canvas->translate(x, y);
     // just enough so we can't take the sprite case
     canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
     canvas->translate(-x, -y);
 }
 
-static SkBaseDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
-                                 SkBenchmark::Backend backend, int sampleCount, GrContext* context) {
-    SkBaseDevice* device = NULL;
-    SkBitmap bitmap;
-    bitmap.setConfig(config, size.fX, size.fY);
+static SkSurface* make_surface(SkColorType colorType, const SkIPoint& size,
+                               SkBenchmark::Backend backend, int sampleCount,
+                               GrContext* context) {
+    SkSurface* surface = NULL;
+    SkImageInfo info = SkImageInfo::Make(size.fX, size.fY, colorType,
+                                         kPremul_SkAlphaType);
 
     switch (backend) {
         case SkBenchmark::kRaster_Backend:
-            bitmap.allocPixels();
-            erase(bitmap);
-            device = SkNEW_ARGS(SkBitmapDevice, (bitmap));
+            surface = SkSurface::NewRaster(info);
+            surface->getCanvas()->clear(SK_ColorWHITE);
             break;
 #if SK_SUPPORT_GPU
         case SkBenchmark::kGPU_Backend: {
-            GrTextureDesc desc;
-            desc.fConfig = kSkia8888_GrPixelConfig;
-            desc.fFlags = kRenderTarget_GrTextureFlagBit;
-            desc.fWidth = size.fX;
-            desc.fHeight = size.fY;
-            desc.fSampleCnt = sampleCount;
-            SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
-            if (!texture) {
-                return NULL;
-            }
-            device = SkNEW_ARGS(SkGpuDevice, (context, texture.get()));
+            surface = SkSurface::NewRenderTarget(context, info, sampleCount);
             break;
         }
 #endif
         case SkBenchmark::kPDF_Backend:
         default:
             SkDEBUGFAIL("unsupported");
     }
-    return device;
+    return surface;
 }
 
 #if SK_SUPPORT_GPU
 GrContextFactory gContextFactory;
 typedef GrContextFactory::GLContextType GLContextType;
 static const GLContextType kNative = GrContextFactory::kNative_GLContextType;
 static const GLContextType kNVPR   = GrContextFactory::kNVPR_GLContextType;
 #if SK_ANGLE
 static const GLContextType kANGLE  = GrContextFactory::kANGLE_GLContextType;
 #endif
 static const GLContextType kDebug  = GrContextFactory::kDebug_GLContextType;
 static const GLContextType kNull   = GrContextFactory::kNull_GLContextType;
 #else
 typedef int GLContextType;
 static const GLContextType kNative = 0, kANGLE = 0, kDebug = 0, kNull = 0;
 #endif
 
 #ifdef SK_DEBUG
 static const bool kIsDebug = true;
 #else
 static const bool kIsDebug = false;
 #endif
 
 static const struct Config {
-    SkBitmap::Config    config;
+    SkColorType         fColorType;
     const char*         name;
     int                 sampleCount;
     SkBenchmark::Backend backend;
     GLContextType       contextType;
     bool                runByDefault;
 } gConfigs[] = {
-    { SkBitmap::kNo_Config,        "NONRENDERING", 0, SkBenchmark::kNonRendering_Backend, kNative, true},
-    { SkBitmap::kARGB_8888_Config, "8888",         0, SkBenchmark::kRaster_Backend,       kNative, true},
-    { SkBitmap::kRGB_565_Config,   "565",          0, SkBenchmark::kRaster_Backend,       kNative, true},
+    { kPMColor_SkColorType, "NONRENDERING", 0, SkBenchmark::kNonRendering_Backend, kNative, true},
+    { kPMColor_SkColorType, "8888",         0, SkBenchmark::kRaster_Backend,       kNative, true},
+    { kRGB_565_SkColorType, "565",          0, SkBenchmark::kRaster_Backend,       kNative, true},
 #if SK_SUPPORT_GPU
-    { SkBitmap::kARGB_8888_Config, "GPU",          0, SkBenchmark::kGPU_Backend,          kNative, true},
-    { SkBitmap::kARGB_8888_Config, "MSAA4",        4, SkBenchmark::kGPU_Backend,          kNative, false},
-    { SkBitmap::kARGB_8888_Config, "MSAA16",      16, SkBenchmark::kGPU_Backend,          kNative, false},
-    { SkBitmap::kARGB_8888_Config, "NVPRMSAA4",    4, SkBenchmark::kGPU_Backend,          kNVPR,   true},
-    { SkBitmap::kARGB_8888_Config, "NVPRMSAA16",  16, SkBenchmark::kGPU_Backend,          kNVPR,   false},
+    { kPMColor_SkColorType, "GPU",          0, SkBenchmark::kGPU_Backend,          kNative, true},
+    { kPMColor_SkColorType, "MSAA4",        4, SkBenchmark::kGPU_Backend,          kNative, false},
+    { kPMColor_SkColorType, "MSAA16",      16, SkBenchmark::kGPU_Backend,          kNative, false},
+    { kPMColor_SkColorType, "NVPRMSAA4",    4, SkBenchmark::kGPU_Backend,          kNVPR,   true},
+    { kPMColor_SkColorType, "NVPRMSAA16",  16, SkBenchmark::kGPU_Backend,          kNVPR,   false},
 #if SK_ANGLE
-    { SkBitmap::kARGB_8888_Config, "ANGLE",        0, SkBenchmark::kGPU_Backend,          kANGLE,  true},
+    { kPMColor_SkColorType, "ANGLE",        0, SkBenchmark::kGPU_Backend,          kANGLE,  true},
 #endif // SK_ANGLE
-    { SkBitmap::kARGB_8888_Config, "Debug",        0, SkBenchmark::kGPU_Backend,          kDebug,  kIsDebug},
-    { SkBitmap::kARGB_8888_Config, "NULLGPU",      0, SkBenchmark::kGPU_Backend,          kNull,   true},
+    { kPMColor_SkColorType, "Debug",        0, SkBenchmark::kGPU_Backend,          kDebug,  kIsDebug},
+    { kPMColor_SkColorType, "NULLGPU",      0, SkBenchmark::kGPU_Backend,          kNull,   true},
 #endif // SK_SUPPORT_GPU
 };
 
 DEFINE_string(outDir, "", "If given, image of each bench will be put in outDir.");
 DEFINE_string(timers, "cg", "Timers to display. "
               "Options: w(all) W(all, truncated) c(pu) C(pu, truncated) g(pu)");
 
 DEFINE_bool(rotate, false,  "Rotate canvas before bench run?");
 DEFINE_bool(scale,  false,  "Scale canvas before bench run?");
 DEFINE_bool(clip,   false,  "Clip canvas before bench run?");
@@ skipping 235 matching lines @@
 #if SK_SUPPORT_GPU
             SkGLContextHelper* glContext = NULL;
             if (SkBenchmark::kGPU_Backend == config.backend) {
                 context = gContextFactory.get(config.contextType);
                 if (NULL == context) {
                     continue;
                 }
                 glContext = gContextFactory.getGLContext(config.contextType);
             }
 #endif
-            SkAutoTUnref<SkBaseDevice> device;
+
             SkAutoTUnref<SkCanvas> canvas;
             SkPicture recordFrom, recordTo;
             const SkIPoint dim = bench->getSize();
 
             const SkPicture::RecordingFlags kRecordFlags =
                 SkPicture::kUsePathBoundsForClip_RecordingFlag;
 
+            SkAutoTUnref<SkSurface> surface;
             if (SkBenchmark::kNonRendering_Backend != config.backend) {
-                device.reset(make_device(config.config,
-                                         dim,
-                                         config.backend,
-                                         config.sampleCount,
-                                         context));
-                if (!device.get()) {
+                surface.reset(make_surface(config.fColorType,
+                                           dim,
+                                           config.backend,
+                                           config.sampleCount,
+                                           context));
+                if (!surface.get()) {
                     logger.logError(SkStringPrintf(
                         "Device creation failure for config %s. Will skip.\n", config.name));
                     continue;
                 }
 
                 switch(benchMode) {
                     case kDeferredSilent_BenchMode:
                     case kDeferred_BenchMode:
-                        canvas.reset(SkDeferredCanvas::Create(device.get()));
+                        canvas.reset(SkDeferredCanvas::Create(surface.get()));
                         break;
                     case kRecord_BenchMode:
                         canvas.reset(SkRef(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
                         break;
                     case kPictureRecord_BenchMode:
                         bench->draw(1, recordFrom.beginRecording(dim.fX, dim.fY, kRecordFlags));
                         recordFrom.endRecording();
                         canvas.reset(SkRef(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
                         break;
                     case kNormal_BenchMode:
-                        canvas.reset(new SkCanvas(device.get()));
+                        canvas.reset(SkRef(surface->getCanvas()));
                         break;
                     default:
                         SkASSERT(false);
                 }
             }
 
             if (NULL != canvas) {
                 canvas->clear(SK_ColorWHITE);
                 if (FLAGS_clip)   {   performClip(canvas, dim.fX, dim.fY); }
                 if (FLAGS_scale)  {  performScale(canvas, dim.fX, dim.fY); }
@@ skipping 117 matching lines @@
                 if (FLAGS_verbose) { SkDebugf("%.3g ", current); }
                 converged = HasConverged(previous, current, timer.fWall);
                 previous = current;
             } while (!kIsDebug && !converged);
             if (FLAGS_verbose) { SkDebugf("\n"); }
 
             if (FLAGS_outDir.count() && SkBenchmark::kNonRendering_Backend != config.backend) {
                 saveFile(bench->getName(),
                          config.name,
                          FLAGS_outDir[0],
-                         device->accessBitmap(false));
+                         surface);
             }
 
             if (kIsDebug) {
                 // Let's not mislead ourselves by looking at Debug build bench times!
                 continue;
             }
 
             // Normalize to ms per 1000 iterations.
             const double normalize = 1000.0 / loopsPerIter;
             const struct { char shortName; const char* longName; double ms; } times[] = {
@@ skipping 16 matching lines @@
     gContextFactory.destroyContexts();
 #endif
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif