Preparations for running skimage tool on bots.

tools/skimage_main.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 "gm_expectations.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkTemplates.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 DEFINE_string(createExpectationsPath, "", "Path to write JSON expectations.");
+DEFINE_string(mismatchPath, "", "Folder to write mismatched images to.");
 DEFINE_string2(readPath, r, "", "Folder(s) and files to decode images. Required.");
 DEFINE_string(readExpectationsPath, "", "Path to read JSON expectations from.");
-DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
 DEFINE_bool(reencode, true, "Reencode the images to test encoding.");
 DEFINE_bool(testSubsetDecoding, true, "Test decoding subsets of images.");
+DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
 
 struct Format {
     SkImageEncoder::Type    fType;
     SkImageDecoder::Format  fFormat;
     const char*             fSuffix;
 };
 
 static const Format gFormats[] = {
     { SkImageEncoder::kBMP_Type, SkImageDecoder::kBMP_Format, ".bmp" },
     { SkImageEncoder::kGIF_Type, SkImageDecoder::kGIF_Format, ".gif" },
@@ skipping 53 matching lines @@
 static SkTArray<SkString, false> gDecodeFailures;
 static SkTArray<SkString, false> gEncodeFailures;
 static SkTArray<SkString, false> gSuccessfulDecodes;
 static SkTArray<SkString, false> gSuccessfulSubsetDecodes;
 static SkTArray<SkString, false> gFailedSubsetDecodes;
 
 // Expections read from a file specified by readExpectationsPath. The expectations must have been
 // previously written using createExpectationsPath.
 SkAutoTUnref<skiagm::JsonExpectationsSource> gJsonExpectations;
 
-static bool write_bitmap(const char outName[], SkBitmap* bm) {
-    SkBitmap bitmap8888;
-    if (SkBitmap::kARGB_8888_Config != bm->config()) {
-        if (!bm->copyTo(&bitmap8888, SkBitmap::kARGB_8888_Config)) {
-            return false;
-        }
-        bm = &bitmap8888;
-    }
-    // FIXME: This forces all pixels to be opaque, like the many implementations
-    // of force_all_opaque. These should be unified if they cannot be eliminated.
-    SkAutoLockPixels lock(*bm);
-    for (int y = 0; y < bm->height(); y++) {
-        for (int x = 0; x < bm->width(); x++) {
-            *bm->getAddr32(x, y) |= (SK_A32_MASK << SK_A32_SHIFT);
-        }
-    }
-    return SkImageEncoder::EncodeFile(outName, *bm, SkImageEncoder::kPNG_Type, 100);
+static bool write_bitmap(const char outName[], const SkBitmap& bm) {
+    return SkImageEncoder::EncodeFile(outName, bm, SkImageEncoder::kPNG_Type, 100);
 }
 
 /**
  *  Return a random SkIRect inside the range specified.
  *  @param rand Random number generator.
  *  @param maxX Exclusive maximum x-coordinate. SkIRect's fLeft and fRight will be
  *      in the range [0, maxX)
  *  @param maxY Exclusive maximum y-coordinate. SkIRect's fTop and fBottom will be
  *      in the range [0, maxY)
  *  @return SkIRect Non-empty, non-degenerate rectangle.
@@ skipping 45 matching lines @@
         gExpectationsToWrite[filename] = value;
     }
 }
 
 /**
  *  Compare against an expectation for this filename, if there is one.
  *  @param bitmap SkBitmap to compare to the expected value.
  *  @param filename String used to find the expected value.
  *  @return bool True in any of these cases:
  *                  - the bitmap matches the expectation.
+ *               False in any of these cases:
  *                  - there is no expectations file.
- *               False in any of these cases:
  *                  - there is an expectations file, but no expectation for this bitmap.
  *                  - there is an expectation for this bitmap, but it did not match.
  *                  - expectation could not be computed from the bitmap.
  */
 static bool compare_to_expectations_if_necessary(const SkBitmap& bitmap, const char* filename,
                                                  SkTArray<SkString, false>* failureArray) {
+    skiagm::GmResultDigest resultDigest(bitmap);
+    if (!resultDigest.isValid()) {
+        if (failureArray != NULL) {
+            failureArray->push_back().printf("decoded %s, but could not create a GmResultDigest.",
+                                             filename);
+        }
+        return false;
+    }
+
     if (NULL == gJsonExpectations.get()) {
-        return true;
+        return false;
     }
 
     skiagm::Expectations jsExpectation = gJsonExpectations->get(filename);
     if (jsExpectation.empty()) {
         if (failureArray != NULL) {
             failureArray->push_back().printf("decoded %s, but could not find expectation.",
                                              filename);
         }
         return false;
-    }
-
-    skiagm::GmResultDigest resultDigest(bitmap);
-    if (!resultDigest.isValid()) {
-        if (failureArray != NULL) {
-            failureArray->push_back().printf("decoded %s, but could not create a GmResultDigest.",
-                                             filename);
-        }
-        return false;
     }
 
     if (jsExpectation.match(resultDigest)) {
         return true;
     }
 
     if (failureArray != NULL) {
         failureArray->push_back().printf("decoded %s, but the result does not match "
                                          "expectations.",
                                          filename);
@@ skipping 39 matching lines @@
         gFailedSubsetDecodes.push_back().printf("Successfully decoded %s from %s, but failed to "
                                                 "create a directory to write to.", subsetDim,
                                                  filename);
         return false;
     }
 
     // Write the subset to a file whose name includes the dimensions.
     SkString suffix = SkStringPrintf("_%s.png", subsetDim);
     SkString outPath;
     make_outname(&outPath, dir.c_str(), filename, suffix.c_str());
-    SkAssertResult(write_bitmap(outPath.c_str(), bitmapFromDecodeSubset));
+    SkAssertResult(write_bitmap(outPath.c_str(), *bitmapFromDecodeSubset));
     gSuccessfulSubsetDecodes.push_back().printf("\twrote %s", outPath.c_str());
 
     // Also use extractSubset from the original for visual comparison.
     // Write the result to a file in a separate subdirectory.
     SkBitmap extractedSubset;
     if (!originalBitmap.extractSubset(&extractedSubset, rect)) {
         gFailedSubsetDecodes.push_back().printf("Successfully decoded %s from %s, but failed to "
                                                 "extract a similar subset for comparison.",
                                                 subsetDim, filename);
         return false;
     }
 
     SkString dirExtracted = SkOSPath::SkPathJoin(writePath, "extracted");
     if (!sk_mkdir(dirExtracted.c_str())) {
         gFailedSubsetDecodes.push_back().printf("Successfully decoded %s from %s, but failed to "
                                                 "create a directory for extractSubset comparison.",
                                                 subsetDim, filename);
         return false;
     }
 
     make_outname(&outPath, dirExtracted.c_str(), filename, suffix.c_str());
-    SkAssertResult(write_bitmap(outPath.c_str(), &extractedSubset));
+    SkAssertResult(write_bitmap(outPath.c_str(), extractedSubset));
     return true;
 }
 
 static void decodeFileAndWrite(const char srcPath[], const SkString* writePath) {
     SkBitmap bitmap;
     SkFILEStream stream(srcPath);
     if (!stream.isValid()) {
         gInvalidStreams.push_back().set(srcPath);
         return;
     }
@@ skipping 13 matching lines @@
         return;
     }
 
     // Create a string representing just the filename itself, for use in json expectations.
     SkString basename = SkOSPath::SkBasename(srcPath);
     const char* filename = basename.c_str();
 
     if (compare_to_expectations_if_necessary(bitmap, filename, &gDecodeFailures)) {
         gSuccessfulDecodes.push_back().printf("%s [%d %d]", srcPath, bitmap.width(),
                                               bitmap.height());
+    } else if (!FLAGS_mismatchPath.isEmpty()) {
+        SkString outPath;
+        make_outname(&outPath, FLAGS_mismatchPath[0], srcPath, ".png");
+        if (write_bitmap(outPath.c_str(), bitmap)) {
+            gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
+        } else {
+            gEncodeFailures.push_back().set(outPath);
+        }
+    }
+
+    if (writePath != NULL) {
+        SkString outPath;
+        make_outname(&outPath, writePath->c_str(), srcPath, ".png");
+        if (write_bitmap(outPath.c_str(), bitmap)) {
+            gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
+        } else {
+            gEncodeFailures.push_back().set(outPath);
+        }
     }
 
     write_expectations(bitmap, filename);
 
     if (FLAGS_testSubsetDecoding) {
         SkDEBUGCODE(bool couldRewind =) stream.rewind();
         SkASSERT(couldRewind);
         int width, height;
         // Build the tile index for decoding subsets. If the image is 1x1, skip subset
         // decoding since there are no smaller subsets.
         if (codec->buildTileIndex(&stream, &width, &height) && width > 1 && height > 1) {
             SkASSERT(bitmap.width() == width && bitmap.height() == height);
             // Call decodeSubset multiple times:
             SkRandom rand(0);
             for (int i = 0; i < 5; i++) {
                 SkBitmap bitmapFromDecodeSubset;
                 // FIXME: Come up with a more representative set of rectangles.
                 SkIRect rect = generate_random_rect(&rand, width, height);
                 SkString subsetDim = SkStringPrintf("[%d,%d,%d,%d]", rect.fLeft, rect.fTop,
                                                     rect.fRight, rect.fBottom);
                 if (codec->decodeSubset(&bitmapFromDecodeSubset, rect, SkBitmap::kNo_Config)) {
                     SkString subsetName = SkStringPrintf("%s_%s", filename, subsetDim.c_str());
                     if (compare_to_expectations_if_necessary(bitmapFromDecodeSubset,
                                                              subsetName.c_str(),
                                                              &gFailedSubsetDecodes)) {
                         gSuccessfulSubsetDecodes.push_back().printf("Decoded subset %s from %s",
                                                               subsetDim.c_str(), srcPath);
+                    } else if (!FLAGS_mismatchPath.isEmpty()) {
+                        write_subset(FLAGS_mismatchPath[0], filename, subsetDim.c_str(),
+                                     &bitmapFromDecodeSubset, rect, bitmap);
                     }
 
                     write_expectations(bitmapFromDecodeSubset, subsetName.c_str());
                     if (writePath != NULL) {
                         write_subset(writePath->c_str(), filename, subsetDim.c_str(),
                                      &bitmapFromDecodeSubset, rect, bitmap);
                     }
                 } else {
                     gFailedSubsetDecodes.push_back().printf("Failed to decode region %s from %s",
                                                             subsetDim.c_str(), srcPath);
@@ skipping 38 matching lines @@
         // Encode to a stream.
         SkDynamicMemoryWStream wStream;
         if (!encoder->encodeStream(&wStream, bitmap, 100)) {
             gEncodeFailures.push_back().printf("Failed to reencode %s to type '%s'", srcPath,
                                                suffix_for_type(type));
             return;
         }
 
         SkAutoTUnref<SkData> data(wStream.copyToData());
         if (writePath != NULL && type != SkImageEncoder::kPNG_Type) {
-            // Write the encoded data to a file. Do not write to PNG, which will be written later,
-            // regardless of the input format.
+            // Write the encoded data to a file. Do not write to PNG, which was already written.
             SkString outPath;
             make_outname(&outPath, writePath->c_str(), srcPath, suffix_for_type(type));
             SkFILEWStream file(outPath.c_str());
             if(file.write(data->data(), data->size())) {
                 gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
             } else {
                 gEncodeFailures.push_back().printf("Failed to write %s", outPath.c_str());
             }
         }
         // Ensure that the reencoded data can still be decoded.
         SkMemoryStream memStream(data);
         SkBitmap redecodedBitmap;
         SkImageDecoder::Format formatOnSecondDecode;
         if (SkImageDecoder::DecodeStream(&memStream, &redecodedBitmap, SkBitmap::kNo_Config,
                                           SkImageDecoder::kDecodePixels_Mode,
                                           &formatOnSecondDecode)) {
             SkASSERT(format_to_type(formatOnSecondDecode) == type);
         } else {
             gDecodeFailures.push_back().printf("Failed to redecode %s after reencoding to '%s'",
                                                srcPath, suffix_for_type(type));
         }
     }
-
-    if (writePath != NULL) {
-        SkString outPath;
-        make_outname(&outPath, writePath->c_str(), srcPath, ".png");
-        if (write_bitmap(outPath.c_str(), &bitmap)) {
-            gSuccessfulDecodes.push_back().appendf("\twrote %s", outPath.c_str());
-        } else {
-            gEncodeFailures.push_back().set(outPath);
-        }
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // If strings is not empty, print title, followed by each string on its own line starting
 // with a tab.
 // @return bool True if strings had at least one entry.
 static bool print_strings(const char* title, const SkTArray<SkString, false>& strings) {
     if (strings.count() > 0) {
         SkDebugf("%s:\n", title);
@@ skipping 65 matching lines @@
         }
     }
 
     if (!FLAGS_createExpectationsPath.isEmpty()) {
         // Use an empty value for everything besides expectations, since the reader only cares
         // about the expectations.
         Json::Value nullValue;
         Json::Value root = skiagm::CreateJsonTree(gExpectationsToWrite, nullValue, nullValue,
                                                   nullValue, nullValue);
         std::string jsonStdString = root.toStyledString();
-        SkString path = SkStringPrintf("%s%cresults.json", FLAGS_createExpectationsPath[0],
-                                       SkPATH_SEPARATOR);
-        SkFILEWStream stream(path.c_str());
+        SkFILEWStream stream(FLAGS_createExpectationsPath[0]);
         stream.write(jsonStdString.c_str(), jsonStdString.length());
     }
     // Add some space, since codecs may print warnings without newline.
     SkDebugf("\n\n");
 
     bool failed = print_strings("Invalid files", gInvalidStreams);
     failed |= print_strings("Missing codec", gMissingCodecs);
     failed |= print_strings("Failed to decode", gDecodeFailures);
     failed |= print_strings("Failed to encode", gEncodeFailures);
     print_strings("Decoded", gSuccessfulDecodes);
 
     if (FLAGS_testSubsetDecoding) {
         failed |= print_strings("Failed subset decodes", gFailedSubsetDecodes);
         print_strings("Decoded subsets", gSuccessfulSubsetDecodes);
     }
 
     return failed ? -1 : 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif