Add flag to bench/render pictures

tools/PictureRenderingFlags.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "PictureRenderingFlags.h"
 
 #include "CopyTilesRenderer.h"
@@ skipping 61 matching lines @@
 DEFINE_string2(readPath, r, "", "skp files or directories of skp files to process.");
 DEFINE_double(scale, 1, "Set the scale factor.");
 DEFINE_string(tiles, "", "Used with --mode copyTile to specify number of tiles per larger tile "
               "in the x and y directions.");
 DEFINE_string(viewport, "", "width height: Set the viewport.");
 #if SK_SUPPORT_GPU
 DEFINE_string(gpuAPI, "", "Force use of specific gpu API.  Using \"gl\" "
               "forces OpenGL API. Using \"gles\" forces OpenGL ES API. "
               "Defaults to empty string, which selects the API native to the "
               "system.");
+DEFINE_bool(gpuCompressAlphaMasks, false, "Compress masks generated from falling back to "
+                                          "software path rendering.");
 #endif
 
 sk_tools::PictureRenderer* parseRenderer(SkString& error, PictureTool tool) {
     error.reset();
 
     bool useTiles = false;
     const char* widthString = NULL;
     const char* heightString = NULL;
     bool isPowerOf2Mode = false;
     bool isCopyMode = false;
     const char* mode = NULL;
     bool gridSupported = false;
 
+#if SK_SUPPORT_GPU
+    GrContext::Options grContextOpts;
+    grContextOpts.fDrawPathToCompressedTexture = FLAGS_gpuCompressAlphaMasks;
+  #define RENDERER_ARGS (grContextOpts)
+#else
+  #define RENDERER_ARGS ()
+#endif
+
     SkAutoTUnref<sk_tools::PictureRenderer> renderer;
     if (FLAGS_mode.count() >= 1) {
         mode = FLAGS_mode[0];
         if (0 == strcmp(mode, "record")) {
-            renderer.reset(SkNEW(sk_tools::RecordPictureRenderer));
+            renderer.reset(SkNEW_ARGS(sk_tools::RecordPictureRenderer, RENDERER_ARGS));
             gridSupported = true;
         } else if (0 == strcmp(mode, "tile") || 0 == strcmp(mode, "pow2tile")
                    || 0 == strcmp(mode, "copyTile")) {
             useTiles = true;
 
             if (0 == strcmp(mode, "pow2tile")) {
                 isPowerOf2Mode = true;
             } else if (0 == strcmp(mode, "copyTile")) {
                 isCopyMode = true;
             } else {
                 gridSupported = true;
             }
 
             if (FLAGS_mode.count() < 2) {
                 error.printf("Missing width for --mode %s\n", mode);
                 return NULL;
             }
 
             widthString = FLAGS_mode[1];
             if (FLAGS_mode.count() < 3) {
                 error.printf("Missing height for --mode %s\n", mode);
                 return NULL;
             }
 
             heightString = FLAGS_mode[2];
         } else if (0 == strcmp(mode, "playbackCreation") && kBench_PictureTool == tool) {
-            renderer.reset(SkNEW(sk_tools::PlaybackCreationRenderer));
+            renderer.reset(SkNEW_ARGS(sk_tools::PlaybackCreationRenderer, RENDERER_ARGS));
             gridSupported = true;
         // undocumented
         } else if (0 == strcmp(mode, "gatherPixelRefs") && kBench_PictureTool == tool) {
+#if SK_SUPPORT_GPU
+            renderer.reset(sk_tools::CreateGatherPixelRefsRenderer(grContextOpts));
+#else
             renderer.reset(sk_tools::CreateGatherPixelRefsRenderer());
+#endif
         } else if (0 == strcmp(mode, "rerecord") && kRender_PictureTool == tool) {
-            renderer.reset(SkNEW(sk_tools::RecordPictureRenderer));
+            renderer.reset(SkNEW_ARGS(sk_tools::RecordPictureRenderer, RENDERER_ARGS));
         // Allow 'mode' to be set to 'simple', but do not create a renderer, so we can
         // ensure that pipe does not override a mode besides simple. The renderer will
         // be created below.
         } else if (0 == strcmp(mode, "simple")) {
             gridSupported = true;
         } else {
             error.printf("%s is not a valid mode for --mode\n", mode);
             return NULL;
         }
     }
@@ skipping 17 matching lines @@
             if (xTiles != -1 && yTiles != -1) {
                 x = xTiles;
                 y = yTiles;
                 if (x <= 0 || y <= 0) {
                     error.printf("--tiles must be given values > 0\n");
                     return NULL;
                 }
             } else {
                 x = y = 4;
             }
+#if SK_SUPPORT_GPU
+            tiledRenderer.reset(SkNEW_ARGS(sk_tools::CopyTilesRenderer, (grContextOpts, x, y)));
+#else
             tiledRenderer.reset(SkNEW_ARGS(sk_tools::CopyTilesRenderer, (x, y)));
+#endif
         } else {
-            tiledRenderer.reset(SkNEW(sk_tools::TiledPictureRenderer));
+            tiledRenderer.reset(SkNEW_ARGS(sk_tools::TiledPictureRenderer, RENDERER_ARGS));
         }
 
         if (isPowerOf2Mode) {
             int minWidth = atoi(widthString);
             if (!SkIsPow2(minWidth) || minWidth < 0) {
                 SkString err;
                 error.printf("-mode %s must be given a width"
                              " value that is a power of two\n", mode);
                 return NULL;
             }
@@ skipping 40 matching lines @@
             error.printf("Pipe rendering is currently not compatible with tiling.\n"
                          "Turning off pipe.\n");
         }
 
     } else { // useTiles
         if (FLAGS_pipe) {
             if (renderer != NULL) {
                 error.printf("Pipe is incompatible with other modes.\n");
                 return NULL;
             }
-            renderer.reset(SkNEW(sk_tools::PipePictureRenderer));
+            renderer.reset(SkNEW_ARGS(sk_tools::PipePictureRenderer, RENDERER_ARGS));
         }
     }
 
     if (NULL == renderer) {
-        renderer.reset(SkNEW(sk_tools::SimplePictureRenderer));
+        renderer.reset(SkNEW_ARGS(sk_tools::SimplePictureRenderer, RENDERER_ARGS));
     }
 
     if (FLAGS_viewport.count() > 0) {
         if (FLAGS_viewport.count() != 2) {
             error.printf("--viewport requires a width and a height.\n");
             return NULL;
         }
         SkISize viewport;
         viewport.fWidth = atoi(FLAGS_viewport[0]);
         viewport.fHeight = atoi(FLAGS_viewport[1]);
@@ skipping 104 matching lines @@
         if (FLAGS_pipe && sk_tools::PictureRenderer::kNone_BBoxHierarchyType != bbhType) {
             error.printf("--pipe and --bbh cannot be used together\n");
             return NULL;
         }
     }
     renderer->setBBoxHierarchyType(bbhType);
     renderer->setScaleFactor(SkDoubleToScalar(FLAGS_scale));
 
     return renderer.detach();
 }