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