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 26 matching lines @@
             case ':':
                 path->writable_str()[i] = '-';
                 break;
             default:
                 break;
         }
     }
 }
 
 static void saveFile(const char name[], const char config[], const char dir[],
-                     const SkBitmap& bm) {
-    SkBitmap copy;
-    if (!bm.copyTo(&copy, SkBitmap::kARGB_8888_Config)) {
+                     const SkImage* image) {
+    SkAutoTUnref<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100));
+    if (NULL == data.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);
-        }
-    }
-
     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 114 matching lines @@
 
                 const double current = timer.fWall / loopsPerIter;
                 if (FLAGS_verbose && current > previous) { SkDebugf("↑"); }
                 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));
+                SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
+                if (image.get()) {
+                    saveFile(bench->getName(), config.name, FLAGS_outDir[0],
+                             image);
+                }
             }
 
             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