src/third_party/skia/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 "LazyDecodeBitmap.h"
   9 #include "CopyTilesRenderer.h"
  10 #include "SkBitmap.h"
  11 #include "SkDevice.h"
  12 #include "SkCommandLineFlags.h"
  13 #include "SkGraphics.h"
  14 #include "SkImageDecoder.h"
  15 #include "SkImageEncoder.h"
  16 #include "SkMath.h"
  17 #include "SkOSFile.h"
  18 #include "SkPicture.h"
  19 #include "SkPictureRecorder.h"
  20 #include "SkStream.h"
  21 #include "SkString.h"
  22
  23 #include "image_expectations.h"
  24 #include "PictureRenderer.h"
  25 #include "PictureRenderingFlags.h"
  26 #include "picture_utils.h"
  27
  28 // Flags used by this file, alphabetically:
  29 DEFINE_bool(bench_record, false, "If true, drop into an infinite loop of recording the picture.");
  30 DECLARE_bool(deferImageDecoding);
  31 DEFINE_string(descriptions, "", "one or more key=value pairs to add to the descriptions section "
  32               "of the JSON summary.");
  33 DEFINE_int32(maxComponentDiff, 256, "Maximum diff on a component, 0 - 256. Components that differ "
  34              "by more than this amount are considered errors, though all diffs are reported. "
  35              "Requires --validate.");
  36 DEFINE_string(mismatchPath, "", "Write images for tests that failed due to "
  37               "pixel mismatches into this directory.");
  38 DEFINE_bool(preprocess, false, "If true, perform device specific preprocessing before rendering.");
  39 DEFINE_string(readJsonSummaryPath, "", "JSON file to read image expectations from.");
  40 DECLARE_string(readPath);
  41 DEFINE_bool(writeChecksumBasedFilenames, false,
  42             "When writing out images, use checksum-based filenames.");
  43 DEFINE_bool(writeEncodedImages, false, "Any time the skp contains an encoded image, write it to a "
  44             "file rather than decoding it. Requires writePath to be set. Skips drawing the full "
  45             "skp to a file. Not compatible with deferImageDecoding.");
  46 DEFINE_string(writeJsonSummaryPath, "", "File to write a JSON summary of image results to.");
  47 DEFINE_string2(writePath, w, "", "Directory to write the rendered images into.");
  48 DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
  49             "file, instead of an image for each tile.");
  50 DEFINE_bool(validate, false, "Verify that the rendered image contains the same pixels as "
  51             "the picture rendered in simple mode. When used in conjunction with --bbh, results "
  52             "are validated against the picture rendered in the same mode, but without the bbh.");
  53
  54 ////////////////////////////////////////////////////////////////////////////////////////////////////
  55
  56 /**
  57  *  Table for translating from format of data to a suffix.
  58  */
  59 struct Format {
  60     SkImageDecoder::Format  fFormat;
  61     const char*             fSuffix;
  62 };
  63 static const Format gFormats[] = {
  64     { SkImageDecoder::kBMP_Format, ".bmp" },
  65     { SkImageDecoder::kGIF_Format, ".gif" },
  66     { SkImageDecoder::kICO_Format, ".ico" },
  67     { SkImageDecoder::kJPEG_Format, ".jpg" },
  68     { SkImageDecoder::kPNG_Format, ".png" },
  69     { SkImageDecoder::kWBMP_Format, ".wbmp" },
  70     { SkImageDecoder::kWEBP_Format, ".webp" },
  71     { SkImageDecoder::kUnknown_Format, "" },
  72 };
  73
  74 /**
  75  *  Get an appropriate suffix for an image format.
  76  */
  77 static const char* get_suffix_from_format(SkImageDecoder::Format format) {
  78     for (size_t i = 0; i < SK_ARRAY_COUNT(gFormats); i++) {
  79         if (gFormats[i].fFormat == format) {
  80             return gFormats[i].fSuffix;
  81         }
  82     }
  83     return "";
  84 }
  85
  86 /**
  87  *  Base name for an image file created from the encoded data in an skp.
  88  */
  89 static SkString gInputFileName;
  90
  91 /**
  92  *  Number to be appended to the image file name so that it is unique.
  93  */
  94 static uint32_t gImageNo;
  95
  96 /**
  97  *  Set up the name for writing encoded data to a file.
  98  *  Sets gInputFileName to name, minus any extension ".*"
  99  *  Sets gImageNo to 0, so images from file "X.skp" will
 100  *  look like "X_<gImageNo>.<suffix>", beginning with 0
 101  *  for each new skp.
 102  */
 103 static void reset_image_file_base_name(const SkString& name) {
 104     gImageNo = 0;
 105     // Remove ".skp"
 106     const char* cName = name.c_str();
 107     const char* dot = strrchr(cName, '.');
 108     if (dot != NULL) {
 109         gInputFileName.set(cName, dot - cName);
 110     } else {
 111         gInputFileName.set(name);
 112     }
 113 }
 114
 115 /**
 116  *  Write the raw encoded bitmap data to a file.
 117  */
 118 static bool write_image_to_file(const void* buffer, size_t size, SkBitmap* bitmap) {
 119     SkASSERT(!FLAGS_writePath.isEmpty());
 120     SkMemoryStream memStream(buffer, size);
 121     SkString outPath;
 122     SkImageDecoder::Format format = SkImageDecoder::GetStreamFormat(&memStream);
 123     SkString name = SkStringPrintf("%s_%d%s", gInputFileName.c_str(), gImageNo++,
 124                                    get_suffix_from_format(format));
 125     SkString dir(FLAGS_writePath[0]);
 126     outPath = SkOSPath::Join(dir.c_str(), name.c_str());
 127     SkFILEWStream fileStream(outPath.c_str());
 128     if (!(fileStream.isValid() && fileStream.write(buffer, size))) {
 129         SkDebugf("Failed to write encoded data to \"%s\"\n", outPath.c_str());
 130     }
 131     // Put in a dummy bitmap.
 132     return SkImageDecoder::DecodeStream(&memStream, bitmap, kUnknown_SkColorType,
 133                                         SkImageDecoder::kDecodeBounds_Mode);
 134 }
 135
 136 ////////////////////////////////////////////////////////////////////////////////////////////////////
 137
 138 /**
 139  * Called only by render_picture().
 140  */
 141 static bool render_picture_internal(const SkString& inputPath, const SkString* writePath,
 142                                     const SkString* mismatchPath,
 143                                     sk_tools::PictureRenderer& renderer,
 144                                     SkBitmap** out) {
 145     SkString inputFilename = SkOSPath::Basename(inputPath.c_str());
 146     SkString writePathString;
 147     if (NULL != writePath && writePath->size() > 0 && !FLAGS_writeEncodedImages) {
 148         writePathString.set(*writePath);
 149     }
 150     SkString mismatchPathString;
 151     if (NULL != mismatchPath && mismatchPath->size() > 0) {
 152         mismatchPathString.set(*mismatchPath);
 153     }
 154
 155     SkFILEStream inputStream;
 156     inputStream.setPath(inputPath.c_str());
 157     if (!inputStream.isValid()) {
 158         SkDebugf("Could not open file %s\n", inputPath.c_str());
 159         return false;
 160     }
 161
 162     SkPicture::InstallPixelRefProc proc;
 163     if (FLAGS_deferImageDecoding) {
 164         proc = &sk_tools::LazyDecodeBitmap;
 165     } else if (FLAGS_writeEncodedImages) {
 166         SkASSERT(!FLAGS_writePath.isEmpty());
 167         reset_image_file_base_name(inputFilename);
 168         proc = &write_image_to_file;
 169     } else {
 170         proc = &SkImageDecoder::DecodeMemory;
 171     }
 172
 173     SkDebugf("deserializing... %s\n", inputPath.c_str());
 174
 175     SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(&inputStream, proc));
 176
 177     if (NULL == picture) {
 178         SkDebugf("Could not read an SkPicture from %s\n", inputPath.c_str());
 179         return false;
 180     }
 181
 182     if (FLAGS_preprocess) {
 183         // Because the GPU preprocessing step relies on the in-memory picture
 184         // statistics we need to rerecord the picture here
 185         SkPictureRecorder recorder;
 186         picture->draw(recorder.beginRecording(picture->width(), picture->height(), NULL, 0));
 187         picture.reset(recorder.endRecording());
 188     }
 189
 190     while (FLAGS_bench_record) {
 191         SkPictureRecorder recorder;
 192         picture->draw(recorder.beginRecording(picture->width(), picture->height(), NULL, 0));
 193         SkAutoTUnref<SkPicture> other(recorder.endRecording());
 194     }
 195
 196     SkDebugf("drawing... [%i %i] %s\n", picture->width(), picture->height(),
 197              inputPath.c_str());
 198
 199     renderer.init(picture, &writePathString, &mismatchPathString, &inputFilename,
 200                   FLAGS_writeChecksumBasedFilenames);
 201
 202     if (FLAGS_preprocess) {
 203         if (NULL != renderer.getCanvas()) {
 204             renderer.getCanvas()->EXPERIMENTAL_optimize(renderer.getPicture());
 205         }
 206     }
 207
 208     renderer.setup();
 209     renderer.enableWrites();
 210
 211     bool success = renderer.render(out);
 212     if (!success) {
 213         SkDebugf("Failed to render %s\n", inputFilename.c_str());
 214     }
 215
 216     renderer.end();
 217
 218     return success;
 219 }
 220
 221 static inline int getByte(uint32_t value, int index) {
 222     SkASSERT(0 <= index && index < 4);
 223     return (value >> (index * 8)) & 0xFF;
 224 }
 225
 226 static int MaxByteDiff(uint32_t v1, uint32_t v2) {
 227     return SkMax32(SkMax32(abs(getByte(v1, 0) - getByte(v2, 0)), abs(getByte(v1, 1) - getByte(v2, 1))),
 228                    SkMax32(abs(getByte(v1, 2) - getByte(v2, 2)), abs(getByte(v1, 3) - getByte(v2, 3))));
 229 }
 230
 231 class AutoRestoreBbhType {
 232 public:
 233     AutoRestoreBbhType() {
 234         fRenderer = NULL;
 235         fSavedBbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
 236     }
 237
 238     void set(sk_tools::PictureRenderer* renderer,
 239              sk_tools::PictureRenderer::BBoxHierarchyType bbhType) {
 240         fRenderer = renderer;
 241         fSavedBbhType = renderer->getBBoxHierarchyType();
 242         renderer->setBBoxHierarchyType(bbhType);
 243     }
 244
 245     ~AutoRestoreBbhType() {
 246         if (NULL != fRenderer) {
 247             fRenderer->setBBoxHierarchyType(fSavedBbhType);
 248         }
 249     }
 250
 251 private:
 252     sk_tools::PictureRenderer* fRenderer;
 253     sk_tools::PictureRenderer::BBoxHierarchyType fSavedBbhType;
 254 };
 255
 256 /**
 257  * Render the SKP file(s) within inputPath.
 258  *
 259  * @param inputPath path to an individual SKP file, or a directory of SKP files
 260  * @param writePath if not NULL, write all image(s) generated into this directory
 261  * @param mismatchPath if not NULL, write any image(s) not matching expectations into this directory
 262  * @param renderer PictureRenderer to use to render the SKPs
 263  * @param jsonSummaryPtr if not NULL, add the image(s) generated to this summary
 264  */
 265 static bool render_picture(const SkString& inputPath, const SkString* writePath,
 266                            const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
 267                            sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
 268     int diffs[256] = {0};
 269     SkBitmap* bitmap = NULL;
 270     renderer.setJsonSummaryPtr(jsonSummaryPtr);
 271     bool success = render_picture_internal(inputPath,
 272         FLAGS_writeWholeImage ? NULL : writePath,
 273         FLAGS_writeWholeImage ? NULL : mismatchPath,
 274         renderer,
 275         FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
 276
 277     if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
 278         SkDebugf("Failed to draw the picture.\n");
 279         SkDELETE(bitmap);
 280         return false;
 281     }
 282
 283     if (FLAGS_validate) {
 284         SkBitmap* referenceBitmap = NULL;
 285         sk_tools::PictureRenderer* referenceRenderer;
 286         // If the renderer uses a BBoxHierarchy, then the reference renderer
 287         // will be the same renderer, without the bbh.
 288         AutoRestoreBbhType arbbh;
 289         if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType !=
 290             renderer.getBBoxHierarchyType()) {
 291             referenceRenderer = &renderer;
 292             referenceRenderer->ref();  // to match auto unref below
 293             arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType);
 294         } else {
 295             referenceRenderer = SkNEW(sk_tools::SimplePictureRenderer);
 296         }
 297         SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer);
 298
 299         success = render_picture_internal(inputPath, NULL, NULL, *referenceRenderer,
 300                                           &referenceBitmap);
 301
 302         if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) {
 303             SkDebugf("Failed to draw the reference picture.\n");
 304             SkDELETE(bitmap);
 305             SkDELETE(referenceBitmap);
 306             return false;
 307         }
 308
 309         if (success && (bitmap->width() != referenceBitmap->width())) {
 310             SkDebugf("Expected image width: %i, actual image width %i.\n",
 311                      referenceBitmap->width(), bitmap->width());
 312             SkDELETE(bitmap);
 313             SkDELETE(referenceBitmap);
 314             return false;
 315         }
 316         if (success && (bitmap->height() != referenceBitmap->height())) {
 317             SkDebugf("Expected image height: %i, actual image height %i",
 318                      referenceBitmap->height(), bitmap->height());
 319             SkDELETE(bitmap);
 320             SkDELETE(referenceBitmap);
 321             return false;
 322         }
 323
 324         for (int y = 0; success && y < bitmap->height(); y++) {
 325             for (int x = 0; success && x < bitmap->width(); x++) {
 326                 int diff = MaxByteDiff(*referenceBitmap->getAddr32(x, y),
 327                                        *bitmap->getAddr32(x, y));
 328                 SkASSERT(diff >= 0 && diff <= 255);
 329                 diffs[diff]++;
 330
 331                 if (diff > FLAGS_maxComponentDiff) {
 332                     SkDebugf("Expected pixel at (%i %i) exceedds maximum "
 333                                  "component diff of %i: 0x%x, actual 0x%x\n",
 334                              x, y, FLAGS_maxComponentDiff,
 335                              *referenceBitmap->getAddr32(x, y),
 336                              *bitmap->getAddr32(x, y));
 337                     SkDELETE(bitmap);
 338                     SkDELETE(referenceBitmap);
 339                     return false;
 340                 }
 341             }
 342         }
 343         SkDELETE(referenceBitmap);
 344
 345         for (int i = 1; i <= 255; ++i) {
 346             if(diffs[i] > 0) {
 347                 SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
 348             }
 349         }
 350     }
 351
 352     if (FLAGS_writeWholeImage) {
 353         sk_tools::force_all_opaque(*bitmap);
 354
 355         SkString inputFilename = SkOSPath::Basename(inputPath.c_str());
 356         SkString outputFilename(inputFilename);
 357         sk_tools::replace_char(&outputFilename, '.', '_');
 358         outputFilename.append(".png");
 359
 360         if (NULL != jsonSummaryPtr) {
 361             sk_tools::ImageDigest imageDigest(*bitmap);
 362             jsonSummaryPtr->add(inputFilename.c_str(), outputFilename.c_str(), imageDigest);
 363             if ((NULL != mismatchPath) && !mismatchPath->isEmpty() &&
 364                 !jsonSummaryPtr->matchesExpectation(inputFilename.c_str(), imageDigest)) {
 365                 success &= sk_tools::write_bitmap_to_disk(*bitmap, *mismatchPath, NULL,
 366                                                           outputFilename);
 367             }
 368         }
 369
 370         if ((NULL != writePath) && !writePath->isEmpty()) {
 371             success &= sk_tools::write_bitmap_to_disk(*bitmap, *writePath, NULL, outputFilename);
 372         }
 373     }
 374     SkDELETE(bitmap);
 375
 376     return success;
 377 }
 378
 379
 380 static int process_input(const char* input, const SkString* writePath,
 381                          const SkString* mismatchPath, sk_tools::PictureRenderer& renderer,
 382                          sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
 383     SkOSFile::Iter iter(input, "skp");
 384     SkString inputFilename;
 385     int failures = 0;
 386     SkDebugf("process_input, %s\n", input);
 387     if (iter.next(&inputFilename)) {
 388         do {
 389             SkString inputPath = SkOSPath::Join(input, inputFilename.c_str());
 390             if (!render_picture(inputPath, writePath, mismatchPath, renderer, jsonSummaryPtr)) {
 391                 ++failures;
 392             }
 393         } while(iter.next(&inputFilename));
 394     } else if (SkStrEndsWith(input, ".skp")) {
 395         SkString inputPath(input);
 396         if (!render_picture(inputPath, writePath, mismatchPath, renderer, jsonSummaryPtr)) {
 397             ++failures;
 398         }
 399     } else {
 400         SkString warning;
 401         warning.printf("Warning: skipping %s\n", input);
 402         SkDebugf(warning.c_str());
 403     }
 404     return failures;
 405 }
 406
 407 int tool_main(int argc, char** argv);
 408 int tool_main(int argc, char** argv) {
 409     SkCommandLineFlags::SetUsage("Render .skp files.");
 410     SkCommandLineFlags::Parse(argc, argv);
 411
 412     if (FLAGS_readPath.isEmpty()) {
 413         SkDebugf(".skp files or directories are required.\n");
 414         exit(-1);
 415     }
 416
 417     if (FLAGS_maxComponentDiff < 0 || FLAGS_maxComponentDiff > 256) {
 418         SkDebugf("--maxComponentDiff must be between 0 and 256\n");
 419         exit(-1);
 420     }
 421
 422     if (FLAGS_maxComponentDiff != 256 && !FLAGS_validate) {
 423         SkDebugf("--maxComponentDiff requires --validate\n");
 424         exit(-1);
 425     }
 426
 427     if (FLAGS_writeEncodedImages) {
 428         if (FLAGS_writePath.isEmpty()) {
 429             SkDebugf("--writeEncodedImages requires --writePath\n");
 430             exit(-1);
 431         }
 432         if (FLAGS_deferImageDecoding) {
 433             SkDebugf("--writeEncodedImages is not compatible with --deferImageDecoding\n");
 434             exit(-1);
 435         }
 436     }
 437
 438     SkString errorString;
 439     SkAutoTUnref<sk_tools::PictureRenderer> renderer(parseRenderer(errorString,
 440                                                                    kRender_PictureTool));
 441     if (errorString.size() > 0) {
 442         SkDebugf("%s\n", errorString.c_str());
 443     }
 444
 445     if (renderer.get() == NULL) {
 446         exit(-1);
 447     }
 448
 449     SkAutoGraphics ag;
 450
 451     SkString writePath;
 452     if (FLAGS_writePath.count() == 1) {
 453         writePath.set(FLAGS_writePath[0]);
 454     }
 455     SkString mismatchPath;
 456     if (FLAGS_mismatchPath.count() == 1) {
 457         mismatchPath.set(FLAGS_mismatchPath[0]);
 458     }
 459     sk_tools::ImageResultsAndExpectations jsonSummary;
 460     sk_tools::ImageResultsAndExpectations* jsonSummaryPtr = NULL;
 461     if (FLAGS_writeJsonSummaryPath.count() == 1) {
 462         jsonSummaryPtr = &jsonSummary;
 463         if (FLAGS_readJsonSummaryPath.count() == 1) {
 464             SkASSERT(jsonSummary.readExpectationsFile(FLAGS_readJsonSummaryPath[0]));
 465         }
 466     }
 467
 468     int failures = 0;
 469     for (int i = 0; i < FLAGS_readPath.count(); i ++) {
 470         failures += process_input(FLAGS_readPath[i], &writePath, &mismatchPath, *renderer.get(),
 471                                   jsonSummaryPtr);
 472     }
 473     if (failures != 0) {
 474         SkDebugf("Failed to render %i pictures.\n", failures);
 475         return 1;
 476     }
 477 #if SK_SUPPORT_GPU
 478 #if GR_CACHE_STATS
 479     if (renderer->isUsingGpuDevice()) {
 480         GrContext* ctx = renderer->getGrContext();
 481         ctx->printCacheStats();
 482 #ifdef SK_DEVELOPER
 483         ctx->dumpFontCache();
 484 #endif
 485     }
 486 #endif
 487 #endif
 488     if (FLAGS_writeJsonSummaryPath.count() == 1) {
 489         // If there were any descriptions on the command line, insert them now.
 490         for (int i=0; i<FLAGS_descriptions.count(); i++) {
 491             SkTArray<SkString> tokens;
 492             SkStrSplit(FLAGS_descriptions[i], "=", &tokens);
 493             SkASSERT(tokens.count() == 2);
 494             jsonSummary.addDescription(tokens[0].c_str(), tokens[1].c_str());
 495         }
 496         jsonSummary.writeToFile(FLAGS_writeJsonSummaryPath[0]);
 497     }
 498     return 0;
 499 }
 500
 501 #if !defined SK_BUILD_FOR_IOS
 502 int main(int argc, char * const argv[]) {
 503     return tool_main(argc, (char**) argv);
 504 }
 505 #endif