render_pictures: add --writeJsonSummaryPath

tools/render_pictures_main.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "LazyDecodeBitmap.h"
 #include "CopyTilesRenderer.h"
 #include "SkBitmap.h"
@@ skipping 14 matching lines @@
 // Flags used by this file, alphabetically:
 DEFINE_int32(clone, 0, "Clone the picture n times before rendering.");
 DECLARE_bool(deferImageDecoding);
 DEFINE_int32(maxComponentDiff, 256, "Maximum diff on a component, 0 - 256. Components that differ "
              "by more than this amount are considered errors, though all diffs are reported. "
              "Requires --validate.");
 DECLARE_string(readPath);
 DEFINE_bool(writeEncodedImages, false, "Any time the skp contains an encoded image, write it to a "
             "file rather than decoding it. Requires writePath to be set. Skips drawing the full "
             "skp to a file. Not compatible with deferImageDecoding.");
+DEFINE_string(writeJsonSummaryPath, "", "File to write a JSON summary of image results to. "
+              "TODO(epoger): Currently, this only works if --writePath is also specified.");
 DEFINE_string2(writePath, w, "", "Directory to write the rendered images.");
 DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
             "file, instead of an image for each tile.");
 DEFINE_bool(validate, false, "Verify that the rendered image contains the same pixels as "
             "the picture rendered in simple mode. When used in conjunction with --bbh, results "
             "are validated against the picture rendered in the same mode, but without the bbh.");
 
 DEFINE_bool(bench_record, false, "If true, drop into an infinite loop of recording the picture.");
 
 static void make_output_filepath(SkString* path, const SkString& dir,
@@ skipping 80 matching lines @@
     if (!(fileStream.isValid() && fileStream.write(buffer, size))) {
         SkDebugf("Failed to write encoded data to \"%s\"\n", outPath.c_str());
     }
     // Put in a dummy bitmap.
     return SkImageDecoder::DecodeStream(&memStream, bitmap, SkBitmap::kNo_Config,
                                         SkImageDecoder::kDecodeBounds_Mode);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-static bool render_picture(const SkString& inputPath, const SkString* outputDir,
-                           sk_tools::PictureRenderer& renderer,
-                           SkBitmap** out) {
+/**
+ * Called only by render_picture().
+ */
+static bool render_picture_internal(const SkString& inputPath, const SkString* outputDir,
+                                    sk_tools::PictureRenderer& renderer,
+                                    SkBitmap** out) {
     SkString inputFilename;
     sk_tools::get_basename(&inputFilename, inputPath);
 
     SkFILEStream inputStream;
     inputStream.setPath(inputPath.c_str());
     if (!inputStream.isValid()) {
         SkDebugf("Could not open file %s\n", inputPath.c_str());
         return false;
     }
 
@@ skipping 86 matching lines @@
             fRenderer->setBBoxHierarchyType(fSavedBbhType);
         }
     }
 
 private:
     sk_tools::PictureRenderer* fRenderer;
     sk_tools::PictureRenderer::BBoxHierarchyType fSavedBbhType;
 };
 }
 
+/**
+ * Render the SKP file(s) within inputPath, writing their bitmap images into outputDir.
+ *
+ * @param inputPath path to an individual SKP file, or a directory of SKP files
+ * @param outputDir if not NULL, write the image(s) generated into this directory
+ * @param renderer PictureRenderer to use to render the SKPs
+ * @param jsonSummaryPtr if not NULL, add the image(s) generated to this summary
+ */
 static bool render_picture(const SkString& inputPath, const SkString* outputDir,
-                           sk_tools::PictureRenderer& renderer) {
+                           sk_tools::PictureRenderer& renderer,
+                           sk_tools::ImageResultsSummary *jsonSummaryPtr) {
     int diffs[256] = {0};
     SkBitmap* bitmap = NULL;
-    bool success = render_picture(inputPath,
+    renderer.setJsonSummaryPtr(jsonSummaryPtr);
+    bool success = render_picture_internal(inputPath,
         FLAGS_writeWholeImage ? NULL : outputDir,
         renderer,
         FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
 
     if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
         SkDebugf("Failed to draw the picture.\n");
         SkDELETE(bitmap);
         return false;
     }
 
     if (FLAGS_validate) {
         SkBitmap* referenceBitmap = NULL;
         sk_tools::PictureRenderer* referenceRenderer;
         // If the renderer uses a BBoxHierarchy, then the reference renderer
         // will be the same renderer, without the bbh.
         AutoRestoreBbhType arbbh;
         if (sk_tools::PictureRenderer::kNone_BBoxHierarchyType !=
             renderer.getBBoxHierarchyType()) {
             referenceRenderer = &renderer;
             referenceRenderer->ref();  // to match auto unref below
             arbbh.set(referenceRenderer, sk_tools::PictureRenderer::kNone_BBoxHierarchyType);
         } else {
             referenceRenderer = SkNEW(sk_tools::SimplePictureRenderer);
         }
         SkAutoTUnref<sk_tools::PictureRenderer> aurReferenceRenderer(referenceRenderer);
 
-        success = render_picture(inputPath, NULL, *referenceRenderer,
-                                 &referenceBitmap);
+        success = render_picture_internal(inputPath, NULL, *referenceRenderer,
+                                          &referenceBitmap);
 
         if (!success || NULL == referenceBitmap || NULL == referenceBitmap->getPixels()) {
             SkDebugf("Failed to draw the reference picture.\n");
             SkDELETE(bitmap);
             SkDELETE(referenceBitmap);
             return false;
         }
 
         if (success && (bitmap->width() != referenceBitmap->width())) {
             SkDebugf("Expected image width: %i, actual image width %i.\n",
@@ skipping 33 matching lines @@
 
         for (int i = 1; i <= 255; ++i) {
             if(diffs[i] > 0) {
                 SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
             }
         }
     }
 
     if (FLAGS_writeWholeImage) {
         sk_tools::force_all_opaque(*bitmap);
-        if (NULL != outputDir && FLAGS_writeWholeImage) {
+
+        if (NULL != jsonSummaryPtr) {
+            // EPOGER: This is a hacky way of constructing the filename associated with the
+            // image checksum; we basically are repeating the logic of make_output_filepath()
+            // and code below here, within here.
+            // It would be better for the filename (without outputDir) to be passed in here,
+            // and used both for the checksum file and writing into outputDir.
+            //
+            // EPOGER: what about including the config type within hashFilename?  That way,
+            // we could combine results of different config types without conflicting filenames.
+            SkString hashFilename;
+            sk_tools::get_basename(&hashFilename, inputPath);
+            hashFilename.remove(hashFilename.size() - 4, 4); // Remove ".skp"
+            hashFilename.append(".png");
+            jsonSummaryPtr->add(hashFilename.c_str(), *bitmap);
+        }
+
+        if (NULL != outputDir) {
             SkString inputFilename;
             sk_tools::get_basename(&inputFilename, inputPath);
             SkString outputPath;
             make_output_filepath(&outputPath, *outputDir, inputFilename);
             outputPath.append(".png");
             if (!SkImageEncoder::EncodeFile(outputPath.c_str(), *bitmap,
                                             SkImageEncoder::kPNG_Type, 100)) {
                 SkDebugf("Failed to draw the picture.\n");
                 success = false;
             }
         }
     }
     SkDELETE(bitmap);
 
     return success;
 }
 
 
 static int process_input(const char* input, const SkString* outputDir,
-                         sk_tools::PictureRenderer& renderer) {
+                         sk_tools::PictureRenderer& renderer,
+                         sk_tools::ImageResultsSummary *jsonSummaryPtr) {
     SkOSFile::Iter iter(input, "skp");
     SkString inputFilename;
     int failures = 0;
     SkDebugf("process_input, %s\n", input);
     if (iter.next(&inputFilename)) {
         do {
             SkString inputPath;
             SkString inputAsSkString(input);
             sk_tools::make_filepath(&inputPath, inputAsSkString, inputFilename);
-            if (!render_picture(inputPath, outputDir, renderer)) {
+            if (!render_picture(inputPath, outputDir, renderer, jsonSummaryPtr)) {
                 ++failures;
             }
         } while(iter.next(&inputFilename));
     } else if (SkStrEndsWith(input, ".skp")) {
         SkString inputPath(input);
-        if (!render_picture(inputPath, outputDir, renderer)) {
+        if (!render_picture(inputPath, outputDir, renderer, jsonSummaryPtr)) {
             ++failures;
         }
     } else {
         SkString warning;
         warning.printf("Warning: skipping %s\n", input);
         SkDebugf(warning.c_str());
     }
     return failures;
 }
 
@@ skipping 43 matching lines @@
     if (renderer.get() == NULL) {
         exit(-1);
     }
 
     SkAutoGraphics ag;
 
     SkString outputDir;
     if (FLAGS_writePath.count() == 1) {
         outputDir.set(FLAGS_writePath[0]);
     }
+    sk_tools::ImageResultsSummary jsonSummary;
+    sk_tools::ImageResultsSummary* jsonSummaryPtr = NULL;
+    if (FLAGS_writeJsonSummaryPath.count() == 1) {
+        jsonSummaryPtr = &jsonSummary;
+    }
 
     int failures = 0;
     for (int i = 0; i < FLAGS_readPath.count(); i ++) {
-        failures += process_input(FLAGS_readPath[i], &outputDir, *renderer.get());
+        failures += process_input(FLAGS_readPath[i], &outputDir, *renderer.get(), jsonSummaryPtr);
     }
     if (failures != 0) {
         SkDebugf("Failed to render %i pictures.\n", failures);
         return 1;
     }
 #if SK_SUPPORT_GPU
 #if GR_CACHE_STATS
     if (renderer->isUsingGpuDevice()) {
         GrContext* ctx = renderer->getGrContext();
         ctx->printCacheStats();
 #ifdef SK_DEVELOPER
         ctx->dumpFontCache();
 #endif
     }
 #endif
 #endif
+    if (FLAGS_writeJsonSummaryPath.count() == 1) {
+        jsonSummary.writeToFile(FLAGS_writeJsonSummaryPath[0]);
+    }
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif