Home | History | Annotate | Download | only in tools 
      1 /*
      2  * Copyright 2011 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 #include "skdiff.h"
      8 #include "skdiff_html.h"
      9 #include "skdiff_utils.h"
     10 #include "SkBitmap.h"
     11 #include "SkData.h"
     12 #include "SkForceLinking.h"
     13 #include "SkImageDecoder.h"
     14 #include "SkImageEncoder.h"
     15 #include "SkOSFile.h"
     16 #include "SkStream.h"
     17 #include "../private/SkTDArray.h"
     18 #include "../private/SkTSearch.h"
     19 
     20 #include <stdlib.h>
     21 
     22 __SK_FORCE_IMAGE_DECODER_LINKING;
     23 
     24 /**
     25  * skdiff
     26  *
     27  * Given three directory names, expects to find identically-named files in
     28  * each of the first two; the first are treated as a set of baseline,
     29  * the second a set of variant images, and a diff image is written into the
     30  * third directory for each pair.
     31  * Creates an index.html in the current third directory to compare each
     32  * pair that does not match exactly.
     33  * Recursively descends directories, unless run with --norecurse.
     34  *
     35  * Returns zero exit code if all images match across baseDir and comparisonDir.
     36  */
     37 
     38 typedef SkTDArray<SkString*> StringArray;
     39 typedef StringArray FileArray;
     40 
     41 static void add_unique_basename(StringArray* array, const SkString& filename) {
     42     // trim off dirs
     43     const char* src = filename.c_str();
     44     const char* trimmed = strrchr(src, SkPATH_SEPARATOR);
     45     if (trimmed) {
     46         trimmed += 1;   // skip the separator
     47     } else {
     48         trimmed = src;
     49     }
     50     const char* end = strrchr(trimmed, '.');
     51     if (!end) {
     52         end = trimmed + strlen(trimmed);
     53     }
     54     SkString result(trimmed, end - trimmed);
     55 
     56     // only add unique entries
     57     for (int i = 0; i < array->count(); ++i) {
     58         if (*array->getAt(i) == result) {
     59             return;
     60         }
     61     }
     62     *array->append() = new SkString(result);
     63 }
     64 
     65 struct DiffSummary {
     66     DiffSummary ()
     67         : fNumMatches(0)
     68         , fNumMismatches(0)
     69         , fMaxMismatchV(0)
     70         , fMaxMismatchPercent(0) { };
     71 
     72     ~DiffSummary() {
     73         for (int i = 0; i < DiffRecord::kResultCount; ++i) {
     74             fResultsOfType[i].deleteAll();
     75         }
     76         for (int base = 0; base < DiffResource::kStatusCount; ++base) {
     77             for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
     78                 fStatusOfType[base][comparison].deleteAll();
     79             }
     80         }
     81     }
     82 
     83     uint32_t fNumMatches;
     84     uint32_t fNumMismatches;
     85     uint32_t fMaxMismatchV;
     86     float fMaxMismatchPercent;
     87 
     88     FileArray fResultsOfType[DiffRecord::kResultCount];
     89     FileArray fStatusOfType[DiffResource::kStatusCount][DiffResource::kStatusCount];
     90 
     91     StringArray fFailedBaseNames[DiffRecord::kResultCount];
     92 
     93     void printContents(const FileArray& fileArray,
     94                        const char* baseStatus, const char* comparisonStatus,
     95                        bool listFilenames) {
     96         int n = fileArray.count();
     97         printf("%d file pairs %s in baseDir and %s in comparisonDir",
     98                 n,            baseStatus,       comparisonStatus);
     99         if (listFilenames) {
    100             printf(": ");
    101             for (int i = 0; i < n; ++i) {
    102                 printf("%s ", fileArray[i]->c_str());
    103             }
    104         }
    105         printf("\n");
    106     }
    107 
    108     void printStatus(bool listFilenames,
    109                      bool failOnStatusType[DiffResource::kStatusCount]
    110                                           [DiffResource::kStatusCount]) {
    111         typedef DiffResource::Status Status;
    112 
    113         for (int base = 0; base < DiffResource::kStatusCount; ++base) {
    114             Status baseStatus = static_cast<Status>(base);
    115             for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
    116                 Status comparisonStatus = static_cast<Status>(comparison);
    117                 const FileArray& fileArray = fStatusOfType[base][comparison];
    118                 if (fileArray.count() > 0) {
    119                     if (failOnStatusType[base][comparison]) {
    120                         printf("   [*] ");
    121                     } else {
    122                         printf("   [_] ");
    123                     }
    124                     printContents(fileArray,
    125                                   DiffResource::getStatusDescription(baseStatus),
    126                                   DiffResource::getStatusDescription(comparisonStatus),
    127                                   listFilenames);
    128                 }
    129             }
    130         }
    131     }
    132 
    133     // Print a line about the contents of this FileArray to stdout.
    134     void printContents(const FileArray& fileArray, const char* headerText, bool listFilenames) {
    135         int n = fileArray.count();
    136         printf("%d file pairs %s", n, headerText);
    137         if (listFilenames) {
    138             printf(": ");
    139             for (int i = 0; i < n; ++i) {
    140                 printf("%s ", fileArray[i]->c_str());
    141             }
    142         }
    143         printf("\n");
    144     }
    145 
    146     void print(bool listFilenames, bool failOnResultType[DiffRecord::kResultCount],
    147                bool failOnStatusType[DiffResource::kStatusCount]
    148                                     [DiffResource::kStatusCount]) {
    149         printf("\ncompared %d file pairs:\n", fNumMatches + fNumMismatches);
    150         for (int resultInt = 0; resultInt < DiffRecord::kResultCount; ++resultInt) {
    151             DiffRecord::Result result = static_cast<DiffRecord::Result>(resultInt);
    152             if (failOnResultType[result]) {
    153                 printf("[*] ");
    154             } else {
    155                 printf("[_] ");
    156             }
    157             printContents(fResultsOfType[result], DiffRecord::getResultDescription(result),
    158                           listFilenames);
    159             if (DiffRecord::kCouldNotCompare_Result == result) {
    160                 printStatus(listFilenames, failOnStatusType);
    161             }
    162         }
    163         printf("(results marked with [*] will cause nonzero return value)\n");
    164         printf("\nnumber of mismatching file pairs: %d\n", fNumMismatches);
    165         if (fNumMismatches > 0) {
    166             printf("Maximum pixel intensity mismatch %d\n", fMaxMismatchV);
    167             printf("Largest area mismatch was %.2f%% of pixels\n",fMaxMismatchPercent);
    168         }
    169     }
    170 
    171     void printfFailingBaseNames(const char separator[]) {
    172         for (int resultInt = 0; resultInt < DiffRecord::kResultCount; ++resultInt) {
    173             const StringArray& array = fFailedBaseNames[resultInt];
    174             if (array.count()) {
    175                 printf("%s [%d]%s", DiffRecord::ResultNames[resultInt], array.count(), separator);
    176                 for (int j = 0; j < array.count(); ++j) {
    177                     printf("%s%s", array[j]->c_str(), separator);
    178                 }
    179                 printf("\n");
    180             }
    181         }
    182     }
    183 
    184     void add (DiffRecord* drp) {
    185         uint32_t mismatchValue;
    186 
    187         if (drp->fBase.fFilename.equals(drp->fComparison.fFilename)) {
    188             fResultsOfType[drp->fResult].push(new SkString(drp->fBase.fFilename));
    189         } else {
    190             SkString* blame = new SkString("(");
    191             blame->append(drp->fBase.fFilename);
    192             blame->append(", ");
    193             blame->append(drp->fComparison.fFilename);
    194             blame->append(")");
    195             fResultsOfType[drp->fResult].push(blame);
    196         }
    197         switch (drp->fResult) {
    198           case DiffRecord::kEqualBits_Result:
    199             fNumMatches++;
    200             break;
    201           case DiffRecord::kEqualPixels_Result:
    202             fNumMatches++;
    203             break;
    204           case DiffRecord::kDifferentSizes_Result:
    205             fNumMismatches++;
    206             break;
    207           case DiffRecord::kDifferentPixels_Result:
    208             fNumMismatches++;
    209             if (drp->fFractionDifference * 100 > fMaxMismatchPercent) {
    210                 fMaxMismatchPercent = drp->fFractionDifference * 100;
    211             }
    212             mismatchValue = MAX3(drp->fMaxMismatchR, drp->fMaxMismatchG,
    213                                  drp->fMaxMismatchB);
    214             if (mismatchValue > fMaxMismatchV) {
    215                 fMaxMismatchV = mismatchValue;
    216             }
    217             break;
    218           case DiffRecord::kCouldNotCompare_Result:
    219             fNumMismatches++;
    220             fStatusOfType[drp->fBase.fStatus][drp->fComparison.fStatus].push(
    221                     new SkString(drp->fBase.fFilename));
    222             break;
    223           case DiffRecord::kUnknown_Result:
    224             SkDEBUGFAIL("adding uncategorized DiffRecord");
    225             break;
    226           default:
    227             SkDEBUGFAIL("adding DiffRecord with unhandled fResult value");
    228             break;
    229         }
    230 
    231         switch (drp->fResult) {
    232             case DiffRecord::kEqualBits_Result:
    233             case DiffRecord::kEqualPixels_Result:
    234                 break;
    235             default:
    236                 add_unique_basename(&fFailedBaseNames[drp->fResult], drp->fBase.fFilename);
    237                 break;
    238         }
    239     }
    240 };
    241 
    242 /// Returns true if string contains any of these substrings.
    243 static bool string_contains_any_of(const SkString& string,
    244                                    const StringArray& substrings) {
    245     for (int i = 0; i < substrings.count(); i++) {
    246         if (string.contains(substrings[i]->c_str())) {
    247             return true;
    248         }
    249     }
    250     return false;
    251 }
    252 
    253 /// Internal (potentially recursive) implementation of get_file_list.
    254 static void get_file_list_subdir(const SkString& rootDir, const SkString& subDir,
    255                                  const StringArray& matchSubstrings,
    256                                  const StringArray& nomatchSubstrings,
    257                                  bool recurseIntoSubdirs, FileArray *files) {
    258     bool isSubDirEmpty = subDir.isEmpty();
    259     SkString dir(rootDir);
    260     if (!isSubDirEmpty) {
    261         dir.append(PATH_DIV_STR);
    262         dir.append(subDir);
    263     }
    264 
    265     // Iterate over files (not directories) within dir.
    266     SkOSFile::Iter fileIterator(dir.c_str());
    267     SkString fileName;
    268     while (fileIterator.next(&fileName, false)) {
    269         if (fileName.startsWith(".")) {
    270             continue;
    271         }
    272         SkString pathRelativeToRootDir(subDir);
    273         if (!isSubDirEmpty) {
    274             pathRelativeToRootDir.append(PATH_DIV_STR);
    275         }
    276         pathRelativeToRootDir.append(fileName);
    277         if (string_contains_any_of(pathRelativeToRootDir, matchSubstrings) &&
    278             !string_contains_any_of(pathRelativeToRootDir, nomatchSubstrings)) {
    279             files->push(new SkString(pathRelativeToRootDir));
    280         }
    281     }
    282 
    283     // Recurse into any non-ignored subdirectories.
    284     if (recurseIntoSubdirs) {
    285         SkOSFile::Iter dirIterator(dir.c_str());
    286         SkString dirName;
    287         while (dirIterator.next(&dirName, true)) {
    288             if (dirName.startsWith(".")) {
    289                 continue;
    290             }
    291             SkString pathRelativeToRootDir(subDir);
    292             if (!isSubDirEmpty) {
    293                 pathRelativeToRootDir.append(PATH_DIV_STR);
    294             }
    295             pathRelativeToRootDir.append(dirName);
    296             if (!string_contains_any_of(pathRelativeToRootDir, nomatchSubstrings)) {
    297                 get_file_list_subdir(rootDir, pathRelativeToRootDir,
    298                                      matchSubstrings, nomatchSubstrings, recurseIntoSubdirs,
    299                                      files);
    300             }
    301         }
    302     }
    303 }
    304 
    305 /// Iterate over dir and get all files whose filename:
    306 ///  - matches any of the substrings in matchSubstrings, but...
    307 ///  - DOES NOT match any of the substrings in nomatchSubstrings
    308 ///  - DOES NOT start with a dot (.)
    309 /// Adds the matching files to the list in *files.
    310 static void get_file_list(const SkString& dir,
    311                           const StringArray& matchSubstrings,
    312                           const StringArray& nomatchSubstrings,
    313                           bool recurseIntoSubdirs, FileArray *files) {
    314     get_file_list_subdir(dir, SkString(""),
    315                          matchSubstrings, nomatchSubstrings, recurseIntoSubdirs,
    316                          files);
    317 }
    318 
    319 static void release_file_list(FileArray *files) {
    320     files->deleteAll();
    321 }
    322 
    323 /// Comparison routines for qsort, sort by file names.
    324 static int compare_file_name_metrics(SkString **lhs, SkString **rhs) {
    325     return strcmp((*lhs)->c_str(), (*rhs)->c_str());
    326 }
    327 
    328 class AutoReleasePixels {
    329 public:
    330     AutoReleasePixels(DiffRecord* drp)
    331     : fDrp(drp) {
    332         SkASSERT(drp != nullptr);
    333     }
    334     ~AutoReleasePixels() {
    335         fDrp->fBase.fBitmap.setPixelRef(nullptr);
    336         fDrp->fComparison.fBitmap.setPixelRef(nullptr);
    337         fDrp->fDifference.fBitmap.setPixelRef(nullptr);
    338         fDrp->fWhite.fBitmap.setPixelRef(nullptr);
    339     }
    340 
    341 private:
    342     DiffRecord* fDrp;
    343 };
    344 
    345 static void get_bounds(DiffResource& resource, const char* name) {
    346     if (resource.fBitmap.empty() && !DiffResource::isStatusFailed(resource.fStatus)) {
    347         SkAutoDataUnref fileBits(read_file(resource.fFullPath.c_str()));
    348         if (nullptr == fileBits) {
    349             SkDebugf("WARNING: couldn't read %s file <%s>\n", name, resource.fFullPath.c_str());
    350             resource.fStatus = DiffResource::kCouldNotRead_Status;
    351         } else {
    352             get_bitmap(fileBits, resource, SkImageDecoder::kDecodeBounds_Mode);
    353         }
    354     }
    355 }
    356 
    357 static void get_bounds(DiffRecord& drp) {
    358     get_bounds(drp.fBase, "base");
    359     get_bounds(drp.fComparison, "comparison");
    360 }
    361 
    362 #ifdef SK_OS_WIN
    363 #define ANSI_COLOR_RED     ""
    364 #define ANSI_COLOR_GREEN   ""
    365 #define ANSI_COLOR_YELLOW  ""
    366 #define ANSI_COLOR_RESET   ""
    367 #else
    368 #define ANSI_COLOR_RED     "\x1b[31m"
    369 #define ANSI_COLOR_GREEN   "\x1b[32m"
    370 #define ANSI_COLOR_YELLOW  "\x1b[33m"
    371 #define ANSI_COLOR_RESET   "\x1b[0m"
    372 #endif
    373 
    374 #define VERBOSE_STATUS(status,color,filename) if (verbose) printf( "[ " color " %10s " ANSI_COLOR_RESET " ] %s\n", status, filename->c_str())
    375 
    376 /// Creates difference images, returns the number that have a 0 metric.
    377 /// If outputDir.isEmpty(), don't write out diff files.
    378 static void create_diff_images (DiffMetricProc dmp,
    379                                 const int colorThreshold,
    380                                 RecordArray* differences,
    381                                 const SkString& baseDir,
    382                                 const SkString& comparisonDir,
    383                                 const SkString& outputDir,
    384                                 const StringArray& matchSubstrings,
    385                                 const StringArray& nomatchSubstrings,
    386                                 bool recurseIntoSubdirs,
    387                                 bool getBounds,
    388                                 bool verbose,
    389                                 DiffSummary* summary) {
    390     SkASSERT(!baseDir.isEmpty());
    391     SkASSERT(!comparisonDir.isEmpty());
    392 
    393     FileArray baseFiles;
    394     FileArray comparisonFiles;
    395 
    396     get_file_list(baseDir, matchSubstrings, nomatchSubstrings, recurseIntoSubdirs, &baseFiles);
    397     get_file_list(comparisonDir, matchSubstrings, nomatchSubstrings, recurseIntoSubdirs,
    398                   &comparisonFiles);
    399 
    400     if (!baseFiles.isEmpty()) {
    401         qsort(baseFiles.begin(), baseFiles.count(), sizeof(SkString*),
    402               SkCastForQSort(compare_file_name_metrics));
    403     }
    404     if (!comparisonFiles.isEmpty()) {
    405         qsort(comparisonFiles.begin(), comparisonFiles.count(),
    406               sizeof(SkString*), SkCastForQSort(compare_file_name_metrics));
    407     }
    408 
    409     int i = 0;
    410     int j = 0;
    411 
    412     while (i < baseFiles.count() &&
    413            j < comparisonFiles.count()) {
    414 
    415         SkString basePath(baseDir);
    416         SkString comparisonPath(comparisonDir);
    417 
    418         DiffRecord *drp = new DiffRecord;
    419         int v = strcmp(baseFiles[i]->c_str(), comparisonFiles[j]->c_str());
    420 
    421         if (v < 0) {
    422             // in baseDir, but not in comparisonDir
    423             drp->fResult = DiffRecord::kCouldNotCompare_Result;
    424 
    425             basePath.append(*baseFiles[i]);
    426             comparisonPath.append(*baseFiles[i]);
    427 
    428             drp->fBase.fFilename = *baseFiles[i];
    429             drp->fBase.fFullPath = basePath;
    430             drp->fBase.fStatus = DiffResource::kExists_Status;
    431 
    432             drp->fComparison.fFilename = *baseFiles[i];
    433             drp->fComparison.fFullPath = comparisonPath;
    434             drp->fComparison.fStatus = DiffResource::kDoesNotExist_Status;
    435 
    436             VERBOSE_STATUS("MISSING", ANSI_COLOR_YELLOW, baseFiles[i]);
    437 
    438             ++i;
    439         } else if (v > 0) {
    440             // in comparisonDir, but not in baseDir
    441             drp->fResult = DiffRecord::kCouldNotCompare_Result;
    442 
    443             basePath.append(*comparisonFiles[j]);
    444             comparisonPath.append(*comparisonFiles[j]);
    445 
    446             drp->fBase.fFilename = *comparisonFiles[j];
    447             drp->fBase.fFullPath = basePath;
    448             drp->fBase.fStatus = DiffResource::kDoesNotExist_Status;
    449 
    450             drp->fComparison.fFilename = *comparisonFiles[j];
    451             drp->fComparison.fFullPath = comparisonPath;
    452             drp->fComparison.fStatus = DiffResource::kExists_Status;
    453 
    454             VERBOSE_STATUS("MISSING", ANSI_COLOR_YELLOW, comparisonFiles[j]);
    455 
    456             ++j;
    457         } else {
    458             // Found the same filename in both baseDir and comparisonDir.
    459             SkASSERT(DiffRecord::kUnknown_Result == drp->fResult);
    460 
    461             basePath.append(*baseFiles[i]);
    462             comparisonPath.append(*comparisonFiles[j]);
    463 
    464             drp->fBase.fFilename = *baseFiles[i];
    465             drp->fBase.fFullPath = basePath;
    466             drp->fBase.fStatus = DiffResource::kExists_Status;
    467 
    468             drp->fComparison.fFilename = *comparisonFiles[j];
    469             drp->fComparison.fFullPath = comparisonPath;
    470             drp->fComparison.fStatus = DiffResource::kExists_Status;
    471 
    472             SkAutoDataUnref baseFileBits(read_file(drp->fBase.fFullPath.c_str()));
    473             if (baseFileBits) {
    474                 drp->fBase.fStatus = DiffResource::kRead_Status;
    475             }
    476             SkAutoDataUnref comparisonFileBits(read_file(drp->fComparison.fFullPath.c_str()));
    477             if (comparisonFileBits) {
    478                 drp->fComparison.fStatus = DiffResource::kRead_Status;
    479             }
    480             if (nullptr == baseFileBits || nullptr == comparisonFileBits) {
    481                 if (nullptr == baseFileBits) {
    482                     drp->fBase.fStatus = DiffResource::kCouldNotRead_Status;
    483                     VERBOSE_STATUS("READ FAIL", ANSI_COLOR_RED, baseFiles[i]);
    484                 }
    485                 if (nullptr == comparisonFileBits) {
    486                     drp->fComparison.fStatus = DiffResource::kCouldNotRead_Status;
    487                     VERBOSE_STATUS("READ FAIL", ANSI_COLOR_RED, comparisonFiles[j]);
    488                 }
    489                 drp->fResult = DiffRecord::kCouldNotCompare_Result;
    490 
    491             } else if (are_buffers_equal(baseFileBits, comparisonFileBits)) {
    492                 drp->fResult = DiffRecord::kEqualBits_Result;
    493                 VERBOSE_STATUS("MATCH", ANSI_COLOR_GREEN, baseFiles[i]);
    494             } else {
    495                 AutoReleasePixels arp(drp);
    496                 get_bitmap(baseFileBits, drp->fBase, SkImageDecoder::kDecodePixels_Mode);
    497                 get_bitmap(comparisonFileBits, drp->fComparison,
    498                            SkImageDecoder::kDecodePixels_Mode);
    499                 VERBOSE_STATUS("DIFFERENT", ANSI_COLOR_RED, baseFiles[i]);
    500                 if (DiffResource::kDecoded_Status == drp->fBase.fStatus &&
    501                     DiffResource::kDecoded_Status == drp->fComparison.fStatus) {
    502                     create_and_write_diff_image(drp, dmp, colorThreshold,
    503                                                 outputDir, drp->fBase.fFilename);
    504                 } else {
    505                     drp->fResult = DiffRecord::kCouldNotCompare_Result;
    506                 }
    507             }
    508 
    509             ++i;
    510             ++j;
    511         }
    512 
    513         if (getBounds) {
    514             get_bounds(*drp);
    515         }
    516         SkASSERT(DiffRecord::kUnknown_Result != drp->fResult);
    517         differences->push(drp);
    518         summary->add(drp);
    519     }
    520 
    521     for (; i < baseFiles.count(); ++i) {
    522         // files only in baseDir
    523         DiffRecord *drp = new DiffRecord();
    524         drp->fBase.fFilename = *baseFiles[i];
    525         drp->fBase.fFullPath = baseDir;
    526         drp->fBase.fFullPath.append(drp->fBase.fFilename);
    527         drp->fBase.fStatus = DiffResource::kExists_Status;
    528 
    529         drp->fComparison.fFilename = *baseFiles[i];
    530         drp->fComparison.fFullPath = comparisonDir;
    531         drp->fComparison.fFullPath.append(drp->fComparison.fFilename);
    532         drp->fComparison.fStatus = DiffResource::kDoesNotExist_Status;
    533 
    534         drp->fResult = DiffRecord::kCouldNotCompare_Result;
    535         if (getBounds) {
    536             get_bounds(*drp);
    537         }
    538         differences->push(drp);
    539         summary->add(drp);
    540     }
    541 
    542     for (; j < comparisonFiles.count(); ++j) {
    543         // files only in comparisonDir
    544         DiffRecord *drp = new DiffRecord();
    545         drp->fBase.fFilename = *comparisonFiles[j];
    546         drp->fBase.fFullPath = baseDir;
    547         drp->fBase.fFullPath.append(drp->fBase.fFilename);
    548         drp->fBase.fStatus = DiffResource::kDoesNotExist_Status;
    549 
    550         drp->fComparison.fFilename = *comparisonFiles[j];
    551         drp->fComparison.fFullPath = comparisonDir;
    552         drp->fComparison.fFullPath.append(drp->fComparison.fFilename);
    553         drp->fComparison.fStatus = DiffResource::kExists_Status;
    554 
    555         drp->fResult = DiffRecord::kCouldNotCompare_Result;
    556         if (getBounds) {
    557             get_bounds(*drp);
    558         }
    559         differences->push(drp);
    560         summary->add(drp);
    561     }
    562 
    563     release_file_list(&baseFiles);
    564     release_file_list(&comparisonFiles);
    565 }
    566 
    567 static void usage (char * argv0) {
    568     SkDebugf("Skia baseline image diff tool\n");
    569     SkDebugf("\n"
    570 "Usage: \n"
    571 "    %s <baseDir> <comparisonDir> [outputDir] \n", argv0);
    572     SkDebugf(
    573 "\nArguments:"
    574 "\n    --failonresult <result>: After comparing all file pairs, exit with nonzero"
    575 "\n                             return code (number of file pairs yielding this"
    576 "\n                             result) if any file pairs yielded this result."
    577 "\n                             This flag may be repeated, in which case the"
    578 "\n                             return code will be the number of fail pairs"
    579 "\n                             yielding ANY of these results."
    580 "\n    --failonstatus <baseStatus> <comparisonStatus>: exit with nonzero return"
    581 "\n                             code if any file pairs yielded this status."
    582 "\n    --help: display this info"
    583 "\n    --listfilenames: list all filenames for each result type in stdout"
    584 "\n    --match <substring>: compare files whose filenames contain this substring;"
    585 "\n                         if unspecified, compare ALL files."
    586 "\n                         this flag may be repeated."
    587 "\n    --nodiffs: don't write out image diffs or index.html, just generate"
    588 "\n               report on stdout"
    589 "\n    --nomatch <substring>: regardless of --match, DO NOT compare files whose"
    590 "\n                           filenames contain this substring."
    591 "\n                           this flag may be repeated."
    592 "\n    --noprintdirs: do not print the directories used."
    593 "\n    --norecurse: do not recurse into subdirectories."
    594 "\n    --sortbymaxmismatch: sort by worst color channel mismatch;"
    595 "\n                         break ties with -sortbymismatch"
    596 "\n    --sortbymismatch: sort by average color channel mismatch"
    597 "\n    --threshold <n>: only report differences > n (per color channel) [default 0]"
    598 "\n    --weighted: sort by # pixels different weighted by color difference"
    599 "\n"
    600 "\n    baseDir: directory to read baseline images from."
    601 "\n    comparisonDir: directory to read comparison images from"
    602 "\n    outputDir: directory to write difference images and index.html to;"
    603 "\n               defaults to comparisonDir"
    604 "\n"
    605 "\nIf no sort is specified, it will sort by fraction of pixels mismatching."
    606 "\n");
    607 }
    608 
    609 const int kNoError = 0;
    610 const int kGenericError = -1;
    611 
    612 int tool_main(int argc, char** argv);
    613 int tool_main(int argc, char** argv) {
    614     DiffMetricProc diffProc = compute_diff_pmcolor;
    615     int (*sortProc)(const void*, const void*) = compare<CompareDiffMetrics>;
    616 
    617     // Maximum error tolerated in any one color channel in any one pixel before
    618     // a difference is reported.
    619     int colorThreshold = 0;
    620     SkString baseDir;
    621     SkString comparisonDir;
    622     SkString outputDir;
    623 
    624     StringArray matchSubstrings;
    625     StringArray nomatchSubstrings;
    626 
    627     bool generateDiffs = true;
    628     bool listFilenames = false;
    629     bool printDirNames = true;
    630     bool recurseIntoSubdirs = true;
    631     bool verbose = false;
    632     bool listFailingBase = false;
    633 
    634     RecordArray differences;
    635     DiffSummary summary;
    636 
    637     bool failOnResultType[DiffRecord::kResultCount];
    638     for (int i = 0; i < DiffRecord::kResultCount; i++) {
    639         failOnResultType[i] = false;
    640     }
    641 
    642     bool failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount];
    643     for (int base = 0; base < DiffResource::kStatusCount; ++base) {
    644         for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
    645             failOnStatusType[base][comparison] = false;
    646         }
    647     }
    648 
    649     int i;
    650     int numUnflaggedArguments = 0;
    651     for (i = 1; i < argc; i++) {
    652         if (!strcmp(argv[i], "--failonresult")) {
    653             if (argc == ++i) {
    654                 SkDebugf("failonresult expects one argument.\n");
    655                 continue;
    656             }
    657             DiffRecord::Result type = DiffRecord::getResultByName(argv[i]);
    658             if (type != DiffRecord::kResultCount) {
    659                 failOnResultType[type] = true;
    660             } else {
    661                 SkDebugf("ignoring unrecognized result <%s>\n", argv[i]);
    662             }
    663             continue;
    664         }
    665         if (!strcmp(argv[i], "--failonstatus")) {
    666             if (argc == ++i) {
    667                 SkDebugf("failonstatus missing base status.\n");
    668                 continue;
    669             }
    670             bool baseStatuses[DiffResource::kStatusCount];
    671             if (!DiffResource::getMatchingStatuses(argv[i], baseStatuses)) {
    672                 SkDebugf("unrecognized base status <%s>\n", argv[i]);
    673             }
    674 
    675             if (argc == ++i) {
    676                 SkDebugf("failonstatus missing comparison status.\n");
    677                 continue;
    678             }
    679             bool comparisonStatuses[DiffResource::kStatusCount];
    680             if (!DiffResource::getMatchingStatuses(argv[i], comparisonStatuses)) {
    681                 SkDebugf("unrecognized comarison status <%s>\n", argv[i]);
    682             }
    683 
    684             for (int base = 0; base < DiffResource::kStatusCount; ++base) {
    685                 for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
    686                     failOnStatusType[base][comparison] |=
    687                         baseStatuses[base] && comparisonStatuses[comparison];
    688                 }
    689             }
    690             continue;
    691         }
    692         if (!strcmp(argv[i], "--help")) {
    693             usage(argv[0]);
    694             return kNoError;
    695         }
    696         if (!strcmp(argv[i], "--listfilenames")) {
    697             listFilenames = true;
    698             continue;
    699         }
    700         if (!strcmp(argv[i], "--verbose")) {
    701             verbose = true;
    702             continue;
    703         }
    704         if (!strcmp(argv[i], "--match")) {
    705             matchSubstrings.push(new SkString(argv[++i]));
    706             continue;
    707         }
    708         if (!strcmp(argv[i], "--nodiffs")) {
    709             generateDiffs = false;
    710             continue;
    711         }
    712         if (!strcmp(argv[i], "--nomatch")) {
    713             nomatchSubstrings.push(new SkString(argv[++i]));
    714             continue;
    715         }
    716         if (!strcmp(argv[i], "--noprintdirs")) {
    717             printDirNames = false;
    718             continue;
    719         }
    720         if (!strcmp(argv[i], "--norecurse")) {
    721             recurseIntoSubdirs = false;
    722             continue;
    723         }
    724         if (!strcmp(argv[i], "--sortbymaxmismatch")) {
    725             sortProc = compare<CompareDiffMaxMismatches>;
    726             continue;
    727         }
    728         if (!strcmp(argv[i], "--sortbymismatch")) {
    729             sortProc = compare<CompareDiffMeanMismatches>;
    730             continue;
    731         }
    732         if (!strcmp(argv[i], "--threshold")) {
    733             colorThreshold = atoi(argv[++i]);
    734             continue;
    735         }
    736         if (!strcmp(argv[i], "--weighted")) {
    737             sortProc = compare<CompareDiffWeighted>;
    738             continue;
    739         }
    740         if (argv[i][0] != '-') {
    741             switch (numUnflaggedArguments++) {
    742                 case 0:
    743                     baseDir.set(argv[i]);
    744                     continue;
    745                 case 1:
    746                     comparisonDir.set(argv[i]);
    747                     continue;
    748                 case 2:
    749                     outputDir.set(argv[i]);
    750                     continue;
    751                 default:
    752                     SkDebugf("extra unflagged argument <%s>\n", argv[i]);
    753                     usage(argv[0]);
    754                     return kGenericError;
    755             }
    756         }
    757         if (!strcmp(argv[i], "--listFailingBase")) {
    758             listFailingBase = true;
    759             continue;
    760         }
    761 
    762         SkDebugf("Unrecognized argument <%s>\n", argv[i]);
    763         usage(argv[0]);
    764         return kGenericError;
    765     }
    766 
    767     if (numUnflaggedArguments == 2) {
    768         outputDir = comparisonDir;
    769     } else if (numUnflaggedArguments != 3) {
    770         usage(argv[0]);
    771         return kGenericError;
    772     }
    773 
    774     if (!baseDir.endsWith(PATH_DIV_STR)) {
    775         baseDir.append(PATH_DIV_STR);
    776     }
    777     if (printDirNames) {
    778         printf("baseDir is [%s]\n", baseDir.c_str());
    779     }
    780 
    781     if (!comparisonDir.endsWith(PATH_DIV_STR)) {
    782         comparisonDir.append(PATH_DIV_STR);
    783     }
    784     if (printDirNames) {
    785         printf("comparisonDir is [%s]\n", comparisonDir.c_str());
    786     }
    787 
    788     if (!outputDir.endsWith(PATH_DIV_STR)) {
    789         outputDir.append(PATH_DIV_STR);
    790     }
    791     if (generateDiffs) {
    792         if (printDirNames) {
    793             printf("writing diffs to outputDir is [%s]\n", outputDir.c_str());
    794         }
    795     } else {
    796         if (printDirNames) {
    797             printf("not writing any diffs to outputDir [%s]\n", outputDir.c_str());
    798         }
    799         outputDir.set("");
    800     }
    801 
    802     // If no matchSubstrings were specified, match ALL strings
    803     // (except for whatever nomatchSubstrings were specified, if any).
    804     if (matchSubstrings.isEmpty()) {
    805         matchSubstrings.push(new SkString(""));
    806     }
    807 
    808     create_diff_images(diffProc, colorThreshold, &differences,
    809                        baseDir, comparisonDir, outputDir,
    810                        matchSubstrings, nomatchSubstrings, recurseIntoSubdirs, generateDiffs,
    811                        verbose, &summary);
    812     summary.print(listFilenames, failOnResultType, failOnStatusType);
    813 
    814     if (listFailingBase) {
    815         summary.printfFailingBaseNames("\n");
    816     }
    817 
    818     if (differences.count()) {
    819         qsort(differences.begin(), differences.count(),
    820               sizeof(DiffRecord*), sortProc);
    821     }
    822 
    823     if (generateDiffs) {
    824         print_diff_page(summary.fNumMatches, colorThreshold, differences,
    825                         baseDir, comparisonDir, outputDir);
    826     }
    827 
    828     for (i = 0; i < differences.count(); i++) {
    829         delete differences[i];
    830     }
    831     matchSubstrings.deleteAll();
    832     nomatchSubstrings.deleteAll();
    833 
    834     int num_failing_results = 0;
    835     for (int i = 0; i < DiffRecord::kResultCount; i++) {
    836         if (failOnResultType[i]) {
    837             num_failing_results += summary.fResultsOfType[i].count();
    838         }
    839     }
    840     if (!failOnResultType[DiffRecord::kCouldNotCompare_Result]) {
    841         for (int base = 0; base < DiffResource::kStatusCount; ++base) {
    842             for (int comparison = 0; comparison < DiffResource::kStatusCount; ++comparison) {
    843                 if (failOnStatusType[base][comparison]) {
    844                     num_failing_results += summary.fStatusOfType[base][comparison].count();
    845                 }
    846             }
    847         }
    848     }
    849 
    850     // On Linux (and maybe other platforms too), any results outside of the
    851     // range [0...255] are wrapped (mod 256).  Do the conversion ourselves, to
    852     // make sure that we only return 0 when there were no failures.
    853     return (num_failing_results > 255) ? 255 : num_failing_results;
    854 }
    855 
    856 #if !defined SK_BUILD_FOR_IOS
    857 int main(int argc, char * const argv[]) {
    858     return tool_main(argc, (char**) argv);
    859 }
    860 #endif
    861