Home | History | Annotate | Download | only in tools 
      1 /*
      2  * Copyright 2012 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 #include "skdiff.h"
      8 #include "skdiff_utils.h"
      9 #include "SkBitmap.h"
     10 #include "SkData.h"
     11 #include "SkImageDecoder.h"
     12 #include "SkImageEncoder.h"
     13 #include "SkStream.h"
     14 #include "SkTypes.h"
     15 
     16 #include <memory>
     17 
     18 bool are_buffers_equal(SkData* skdata1, SkData* skdata2) {
     19     if ((nullptr == skdata1) || (nullptr == skdata2)) {
     20         return false;
     21     }
     22     if (skdata1->size() != skdata2->size()) {
     23         return false;
     24     }
     25     return (0 == memcmp(skdata1->data(), skdata2->data(), skdata1->size()));
     26 }
     27 
     28 SkData* read_file(const char* file_path) {
     29     SkData* data = SkData::NewFromFileName(file_path);
     30     if (!data) {
     31         SkDebugf("WARNING: could not open file <%s> for reading\n", file_path);
     32     }
     33     return data;
     34 }
     35 
     36 bool get_bitmap(SkData* fileBits, DiffResource& resource, SkImageDecoder::Mode mode) {
     37     SkMemoryStream stream(fileBits->data(), fileBits->size());
     38 
     39     // In debug, the DLL will automatically be unloaded when this is deleted,
     40     // but that shouldn't be a problem in release mode.
     41     std::unique_ptr<SkImageDecoder> codec(SkImageDecoder::Factory(&stream));
     42     if (nullptr == codec) {
     43         SkDebugf("ERROR: no codec found for <%s>\n", resource.fFullPath.c_str());
     44         resource.fStatus = DiffResource::kCouldNotDecode_Status;
     45         return false;
     46     }
     47 
     48     stream.rewind();
     49     if (!codec->decode(&stream, &resource.fBitmap, kN32_SkColorType, mode)) {
     50         SkDebugf("ERROR: codec failed for basePath <%s>\n", resource.fFullPath.c_str());
     51         resource.fStatus = DiffResource::kCouldNotDecode_Status;
     52         return false;
     53     }
     54 
     55     resource.fStatus = DiffResource::kDecoded_Status;
     56     return true;
     57 }
     58 
     59 /** Thanks to PNG, we need to force all pixels 100% opaque. */
     60 static void force_all_opaque(const SkBitmap& bitmap) {
     61    SkAutoLockPixels lock(bitmap);
     62    for (int y = 0; y < bitmap.height(); y++) {
     63        for (int x = 0; x < bitmap.width(); x++) {
     64            *bitmap.getAddr32(x, y) |= (SK_A32_MASK << SK_A32_SHIFT);
     65        }
     66    }
     67 }
     68 
     69 bool write_bitmap(const SkString& path, const SkBitmap& bitmap) {
     70     SkBitmap copy;
     71     bitmap.copyTo(&copy, kN32_SkColorType);
     72     force_all_opaque(copy);
     73     return SkImageEncoder::EncodeFile(path.c_str(), copy,
     74                                       SkImageEncoder::kPNG_Type, 100);
     75 }
     76 
     77 /// Return a copy of the "input" string, within which we have replaced all instances
     78 /// of oldSubstring with newSubstring.
     79 ///
     80 /// TODO: If we like this, we should move it into the core SkString implementation,
     81 /// adding more checks and ample test cases, and paying more attention to efficiency.
     82 static SkString replace_all(const SkString &input,
     83                             const char oldSubstring[], const char newSubstring[]) {
     84     SkString output;
     85     const char *input_cstr = input.c_str();
     86     const char *first_char = input_cstr;
     87     const char *match_char;
     88     size_t oldSubstringLen = strlen(oldSubstring);
     89     while ((match_char = strstr(first_char, oldSubstring))) {
     90         output.append(first_char, (match_char - first_char));
     91         output.append(newSubstring);
     92         first_char = match_char + oldSubstringLen;
     93     }
     94     output.append(first_char);
     95     return output;
     96 }
     97 
     98 static SkString filename_to_derived_filename(const SkString& filename, const char *suffix) {
     99     SkString diffName (filename);
    100     const char* cstring = diffName.c_str();
    101     size_t dotOffset = strrchr(cstring, '.') - cstring;
    102     diffName.remove(dotOffset, diffName.size() - dotOffset);
    103     diffName.append(suffix);
    104 
    105     // In case we recursed into subdirectories, replace slashes with something else
    106     // so the diffs will all be written into a single flat directory.
    107     diffName = replace_all(diffName, PATH_DIV_STR, "_");
    108     return diffName;
    109 }
    110 
    111 SkString filename_to_diff_filename(const SkString& filename) {
    112     return filename_to_derived_filename(filename, "-diff.png");
    113 }
    114 
    115 SkString filename_to_white_filename(const SkString& filename) {
    116     return filename_to_derived_filename(filename, "-white.png");
    117 }
    118 
    119 void create_and_write_diff_image(DiffRecord* drp,
    120                                  DiffMetricProc dmp,
    121                                  const int colorThreshold,
    122                                  const SkString& outputDir,
    123                                  const SkString& filename) {
    124     const int w = drp->fBase.fBitmap.width();
    125     const int h = drp->fBase.fBitmap.height();
    126 
    127     if (w != drp->fComparison.fBitmap.width() || h != drp->fComparison.fBitmap.height()) {
    128         drp->fResult = DiffRecord::kDifferentSizes_Result;
    129     } else {
    130         drp->fDifference.fBitmap.allocN32Pixels(w, h);
    131 
    132         drp->fWhite.fBitmap.allocN32Pixels(w, h);
    133 
    134         SkASSERT(DiffRecord::kUnknown_Result == drp->fResult);
    135         compute_diff(drp, dmp, colorThreshold);
    136         SkASSERT(DiffRecord::kUnknown_Result != drp->fResult);
    137     }
    138 
    139     if (outputDir.isEmpty()) {
    140         drp->fDifference.fStatus = DiffResource::kUnspecified_Status;
    141         drp->fWhite.fStatus = DiffResource::kUnspecified_Status;
    142 
    143     } else {
    144         drp->fDifference.fFilename = filename_to_diff_filename(filename);
    145         drp->fDifference.fFullPath = outputDir;
    146         drp->fDifference.fFullPath.append(drp->fDifference.fFilename);
    147         drp->fDifference.fStatus = DiffResource::kSpecified_Status;
    148 
    149         drp->fWhite.fFilename = filename_to_white_filename(filename);
    150         drp->fWhite.fFullPath = outputDir;
    151         drp->fWhite.fFullPath.append(drp->fWhite.fFilename);
    152         drp->fWhite.fStatus = DiffResource::kSpecified_Status;
    153 
    154         if (DiffRecord::kDifferentPixels_Result == drp->fResult) {
    155             if (write_bitmap(drp->fDifference.fFullPath, drp->fDifference.fBitmap)) {
    156                 drp->fDifference.fStatus = DiffResource::kExists_Status;
    157             } else {
    158                 drp->fDifference.fStatus = DiffResource::kDoesNotExist_Status;
    159             }
    160             if (write_bitmap(drp->fWhite.fFullPath, drp->fWhite.fBitmap)) {
    161                 drp->fWhite.fStatus = DiffResource::kExists_Status;
    162             } else {
    163                 drp->fWhite.fStatus = DiffResource::kDoesNotExist_Status;
    164             }
    165         }
    166     }
    167 }
    168