tools/render_pictures_main.cpp

   1 /*
   2  * Copyright 2012 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkBitmap.h"
   9 #include "SkCanvas.h"
  10 #include "SkDevice.h"
  11 #include "SkGraphics.h"
  12 #include "SkMath.h"
  13 #include "SkOSFile.h"
  14 #include "SkPicture.h"
  15 #include "SkStream.h"
  16 #include "SkString.h"
  17 #include "SkTArray.h"
  18 #include "PictureRenderer.h"
  19 #include "picture_utils.h"
  20
  21 static void usage(const char* argv0) {
  22     SkDebugf("SkPicture rendering tool\n");
  23     SkDebugf("\n"
  24 "Usage: \n"
  25 "     %s <input>... <outputDir> \n"
  26 "     [--mode pipe | pow2tile minWidth height[%] | simple\n"
  27 "         | tile width[%] height[%]]\n"
  28 "     [--device bitmap"
  29 #if SK_SUPPORT_GPU
  30 " | gpu"
  31 #endif
  32 "]"
  33 , argv0);
  34     SkDebugf("\n\n");
  35     SkDebugf(
  36 "     input:     A list of directories and files to use as input. Files are\n"
  37 "                expected to have the .skp extension.\n\n");
  38     SkDebugf(
  39 "     outputDir: directory to write the rendered images.\n\n");
  40     SkDebugf(
  41 "     --mode pipe | pow2tile minWidth height[%] | simple\n"
  42 "          | tile width[%] height[%]: Run in the corresponding mode.\n"
  43 "                                     Default is simple.\n");
  44     SkDebugf(
  45 "                     pipe, Render using a SkGPipe.\n");
  46     SkDebugf(
  47 "                     pow2tile minWidth height[%], Creates tiles with widths\n"
  48 "                                                  that are all a power of two\n"
  49 "                                                  such that they minimize the\n"
  50 "                                                  amount of wasted tile space.\n"
  51 "                                                  minWidth is the minimum width\n"
  52 "                                                  of these tiles and must be a\n"
  53 "                                                  power of two. A simple render\n"
  54 "                                                  is done with these tiles.\n");
  55     SkDebugf(
  56 "                     simple, Render using the default rendering method.\n");
  57     SkDebugf(
  58 "                     tile width[%] height[%], Do a simple render using tiles\n"
  59 "                                              with the given dimensions.\n");
  60     SkDebugf("\n");
  61     SkDebugf(
  62 "     --device bitmap"
  63 #if SK_SUPPORT_GPU
  64 " | gpu"
  65 #endif
  66 ": Use the corresponding device. Default is bitmap.\n");
  67     SkDebugf(
  68 "                     bitmap, Render to a bitmap.\n");
  69 #if SK_SUPPORT_GPU
  70     SkDebugf(
  71 "                     gpu, Render to the GPU.\n");
  72 #endif
  73 }
  74
  75 static void make_output_filepath(SkString* path, const SkString& dir,
  76                                  const SkString& name) {
  77     sk_tools::make_filepath(path, dir, name);
  78     // Remove ".skp"
  79     path->remove(path->size() - 4, 4);
  80 }
  81
  82 static bool render_picture(const SkString& inputPath, const SkString& outputDir,
  83                            sk_tools::PictureRenderer& renderer) {
  84     SkString inputFilename;
  85     sk_tools::get_basename(&inputFilename, inputPath);
  86
  87     SkFILEStream inputStream;
  88     inputStream.setPath(inputPath.c_str());
  89     if (!inputStream.isValid()) {
  90         SkDebugf("Could not open file %s\n", inputPath.c_str());
  91         return false;
  92     }
  93
  94     bool success = false;
  95     SkPicture picture(&inputStream, &success);
  96     if (!success) {
  97         SkDebugf("Could not read an SkPicture from %s\n", inputPath.c_str());
  98         return false;
  99     }
 100
 101     SkDebugf("drawing... [%i %i] %s\n", picture.width(), picture.height(),
 102              inputPath.c_str());
 103
 104     renderer.init(&picture);
 105
 106     SkString outputPath;
 107     make_output_filepath(&outputPath, outputDir, inputFilename);
 108
 109     success = renderer.render(&outputPath);
 110     if (!success) {
 111         SkDebugf("Could not write to file %s\n", outputPath.c_str());
 112     }
 113
 114     renderer.resetState();
 115
 116     renderer.end();
 117     return success;
 118 }
 119
 120 static int process_input(const SkString& input, const SkString& outputDir,
 121                           sk_tools::PictureRenderer& renderer) {
 122     SkOSFile::Iter iter(input.c_str(), "skp");
 123     SkString inputFilename;
 124     int failures = 0;
 125     if (iter.next(&inputFilename)) {
 126         do {
 127             SkString inputPath;
 128             sk_tools::make_filepath(&inputPath, input, inputFilename);
 129             if (!render_picture(inputPath, outputDir, renderer)) {
 130                 ++failures;
 131             }
 132         } while(iter.next(&inputFilename));
 133     } else if (SkStrEndsWith(input.c_str(), ".skp")) {
 134         SkString inputPath(input);
 135         if (!render_picture(inputPath, outputDir, renderer)) {
 136             ++failures;
 137         }
 138     } else {
 139         SkString warning;
 140         warning.printf("Warning: skipping %s\n", input.c_str());
 141         SkDebugf(warning.c_str());
 142     }
 143     return failures;
 144 }
 145
 146 static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs,
 147                               sk_tools::PictureRenderer*& renderer){
 148     const char* argv0 = argv[0];
 149     char* const* stop = argv + argc;
 150
 151     sk_tools::PictureRenderer::SkDeviceTypes deviceType =
 152         sk_tools::PictureRenderer::kBitmap_DeviceType;
 153
 154     for (++argv; argv < stop; ++argv) {
 155         if (0 == strcmp(*argv, "--mode")) {
 156             SkDELETE(renderer);
 157
 158             ++argv;
 159             if (argv >= stop) {
 160                 SkDebugf("Missing mode for --mode\n");
 161                 usage(argv0);
 162                 exit(-1);
 163             }
 164
 165             if (0 == strcmp(*argv, "pipe")) {
 166                 renderer = SkNEW(sk_tools::PipePictureRenderer);
 167             } else if (0 == strcmp(*argv, "simple")) {
 168                 renderer = SkNEW(sk_tools::SimplePictureRenderer);
 169             } else if ((0 == strcmp(*argv, "tile")) || (0 == strcmp(*argv, "pow2tile"))) {
 170                 char* mode = *argv;
 171                 bool isPowerOf2Mode = false;
 172
 173                 if (0 == strcmp(*argv, "pow2tile")) {
 174                     isPowerOf2Mode = true;
 175                 }
 176
 177                 sk_tools::TiledPictureRenderer* tileRenderer =
 178                     SkNEW(sk_tools::TiledPictureRenderer);
 179                 ++argv;
 180                 if (argv >= stop) {
 181                     SkDELETE(tileRenderer);
 182                     SkDebugf("Missing width for --mode %s\n", mode);
 183                     usage(argv0);
 184                     exit(-1);
 185                 }
 186
 187                 if (isPowerOf2Mode) {
 188                     int minWidth = atoi(*argv);
 189
 190                     if (!SkIsPow2(minWidth) || minWidth <= 0) {
 191                         SkDELETE(tileRenderer);
 192                         SkDebugf("--mode %s must be given a width"
 193                                  " value that is a power of two\n", mode);
 194                         exit(-1);
 195                     }
 196
 197                     tileRenderer->setTileMinPowerOf2Width(minWidth);
 198                 } else if (sk_tools::is_percentage(*argv)) {
 199                     tileRenderer->setTileWidthPercentage(atof(*argv));
 200                     if (!(tileRenderer->getTileWidthPercentage() > 0)) {
 201                         SkDELETE(tileRenderer);
 202                         SkDebugf("--mode %s must be given a width percentage > 0\n", mode);
 203                         exit(-1);
 204                     }
 205                 } else {
 206                     tileRenderer->setTileWidth(atoi(*argv));
 207                     if (!(tileRenderer->getTileWidth() > 0)) {
 208                         SkDELETE(tileRenderer);
 209                         SkDebugf("--mode %s must be given a width > 0\n", mode);
 210                         exit(-1);
 211                     }
 212                 }
 213
 214                 ++argv;
 215                 if (argv >= stop) {
 216                     SkDELETE(tileRenderer);
 217                     SkDebugf("Missing height for --mode %s\n", mode);
 218                     usage(argv0);
 219                     exit(-1);
 220                 }
 221
 222                 if (sk_tools::is_percentage(*argv)) {
 223                     tileRenderer->setTileHeightPercentage(atof(*argv));
 224                     if (!(tileRenderer->getTileHeightPercentage() > 0)) {
 225                         SkDELETE(tileRenderer);
 226                         SkDebugf(
 227                             "--mode %s must be given a height percentage > 0\n", mode);
 228                         exit(-1);
 229                     }
 230                 } else {
 231                     tileRenderer->setTileHeight(atoi(*argv));
 232                     if (!(tileRenderer->getTileHeight() > 0)) {
 233                         SkDELETE(tileRenderer);
 234                         SkDebugf("--mode %s must be given a height > 0\n", mode);
 235                         exit(-1);
 236                     }
 237                 }
 238
 239                 renderer = tileRenderer;
 240             } else {
 241                 SkDebugf("%s is not a valid mode for --mode\n", *argv);
 242                 usage(argv0);
 243                 exit(-1);
 244             }
 245         } else if (0 == strcmp(*argv, "--device")) {
 246             ++argv;
 247             if (argv >= stop) {
 248                 SkDebugf("Missing mode for --deivce\n");
 249                 usage(argv0);
 250                 exit(-1);
 251             }
 252
 253             if (0 == strcmp(*argv, "bitmap")) {
 254                 deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType;
 255             }
 256 #if SK_SUPPORT_GPU
 257             else if (0 == strcmp(*argv, "gpu")) {
 258                 deviceType = sk_tools::PictureRenderer::kGPU_DeviceType;
 259             }
 260 #endif
 261             else {
 262                 SkDebugf("%s is not a valid mode for --device\n", *argv);
 263                 usage(argv0);
 264                 exit(-1);
 265             }
 266
 267         } else if ((0 == strcmp(*argv, "-h")) || (0 == strcmp(*argv, "--help"))) {
 268             SkDELETE(renderer);
 269             usage(argv0);
 270             exit(-1);
 271         } else {
 272             inputs->push_back(SkString(*argv));
 273         }
 274     }
 275
 276     if (inputs->count() < 2) {
 277         SkDELETE(renderer);
 278         usage(argv0);
 279         exit(-1);
 280     }
 281
 282     if (NULL == renderer) {
 283         renderer = SkNEW(sk_tools::SimplePictureRenderer);
 284     }
 285
 286     renderer->setDeviceType(deviceType);
 287 }
 288
 289 int main(int argc, char* const argv[]) {
 290     SkAutoGraphics ag;
 291     SkTArray<SkString> inputs;
 292     sk_tools::PictureRenderer* renderer = NULL;
 293
 294     parse_commandline(argc, argv, &inputs, renderer);
 295     SkString outputDir = inputs[inputs.count() - 1];
 296     SkASSERT(renderer);
 297
 298     int failures = 0;
 299     for (int i = 0; i < inputs.count() - 1; i ++) {
 300         failures += process_input(inputs[i], outputDir, *renderer);
 301     }
 302     if (failures != 0) {
 303         SkDebugf("Failed to render %i pictures.\n", failures);
 304         return 1;
 305     }
 306 #if SK_SUPPORT_GPU
 307 #if GR_CACHE_STATS
 308     if (renderer->isUsingGpuDevice()) {
 309         GrContext* ctx = renderer->getGrContext();
 310
 311         ctx->printCacheStats();
 312     }
 313 #endif
 314 #endif
 315
 316     SkDELETE(renderer);
 317 }