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 
8 #ifndef skdiff_DEFINED
9 #define skdiff_DEFINED
10 
11 #include "include/core/SkBitmap.h"
12 #include "include/core/SkColor.h"
13 #include "include/core/SkColorPriv.h"
14 #include "include/core/SkString.h"
15 #include "include/private/SkTDArray.h"
16 
17 #if defined(SK_BUILD_FOR_WIN)
18     #define PATH_DIV_STR "\\"
19     #define PATH_DIV_CHAR '\\'
20 #else
21     #define PATH_DIV_STR "/"
22     #define PATH_DIV_CHAR '/'
23 #endif
24 
25 #define MAX2(a,b) (((b) < (a)) ? (a) : (b))
26 #define MAX3(a,b,c) (((b) < (a)) ? MAX2((a), (c)) : MAX2((b), (c)))
27 
28 
29 struct DiffResource {
30     enum Status {
31         /** The resource was specified, exists, read, and decoded. */
32         kDecoded_Status,
33         /** The resource was specified, exists, read, but could not be decoded. */
34         kCouldNotDecode_Status,
35 
36         /** The resource was specified, exists, and read. */
37         kRead_Status,
38         /** The resource was specified, exists, but could not be read. */
39         kCouldNotRead_Status,
40 
41         /** The resource was specified and exists. */
42         kExists_Status,
43         /** The resource was specified, but does not exist. */
44         kDoesNotExist_Status,
45 
46         /** The resource was specified. */
47         kSpecified_Status,
48         /** The resource was not specified. */
49         kUnspecified_Status,
50 
51         /** Nothing is yet known about the resource. */
52         kUnknown_Status,
53 
54         /** NOT A VALID VALUE -- used to set up arrays and to represent an unknown value. */
55         kStatusCount
56     };
57     static char const * const StatusNames[DiffResource::kStatusCount];
58 
59     /** Returns the Status with this name.
60      *  If there is no Status with this name, returns kStatusCount.
61      */
62     static Status getStatusByName(const char *name);
63 
64     /** Returns a text description of the given Status type. */
65     static const char *getStatusDescription(Status status);
66 
67     /** Returns true if the Status indicates some kind of failure. */
68     static bool isStatusFailed(Status status);
69 
70     /** Sets statuses[i] if it is implied by selector, unsets it if not.
71      *  Selector may be a comma delimited list of status names, "any", or "failed".
72      *  Returns true if the selector was entirely understood, false otherwise.
73      */
74     static bool getMatchingStatuses(char* selector, bool statuses[kStatusCount]);
75 
DiffResourceDiffResource76     DiffResource() : fFilename(), fFullPath(), fBitmap(), fStatus(kUnknown_Status) { }
77 
78     /** If isEmpty() indicates no filename available. */
79     SkString fFilename;
80     /** If isEmpty() indicates no path available. */
81     SkString fFullPath;
82     /** If empty() indicates the bitmap could not be created. */
83     SkBitmap fBitmap;
84     Status fStatus;
85 };
86 
87 struct DiffRecord {
88 
89     // Result of comparison for each pair of files.
90     // Listed from "better" to "worse", for sorting of results.
91     enum Result {
92         kEqualBits_Result,
93         kEqualPixels_Result,
94         kDifferentPixels_Result,
95         kDifferentSizes_Result,
96         kCouldNotCompare_Result,
97         kUnknown_Result,
98 
99         kResultCount  // NOT A VALID VALUE--used to set up arrays. Must be last.
100     };
101     static char const * const ResultNames[DiffRecord::kResultCount];
102 
103     /** Returns the Result with this name.
104      *  If there is no Result with this name, returns kResultCount.
105      */
106     static Result getResultByName(const char *name);
107 
108     /** Returns a text description of the given Result type. */
109     static const char *getResultDescription(Result result);
110 
DiffRecordDiffRecord111     DiffRecord()
112         : fBase()
113         , fComparison()
114         , fDifference()
115         , fWhite()
116         , fFractionDifference(0)
117         , fWeightedFraction(0)
118         , fAverageMismatchA(0)
119         , fAverageMismatchR(0)
120         , fAverageMismatchG(0)
121         , fAverageMismatchB(0)
122         , fTotalMismatchA(0)
123         , fMaxMismatchA(0)
124         , fMaxMismatchR(0)
125         , fMaxMismatchG(0)
126         , fMaxMismatchB(0)
127         , fResult(kUnknown_Result) {
128     }
129 
130     DiffResource fBase;
131     DiffResource fComparison;
132     DiffResource fDifference;
133     DiffResource fWhite;
134 
135     /// Arbitrary floating-point metric to be used to sort images from most
136     /// to least different from baseline; values of 0 will be omitted from the
137     /// summary webpage.
138     float fFractionDifference;
139     float fWeightedFraction;
140 
141     float fAverageMismatchA;
142     float fAverageMismatchR;
143     float fAverageMismatchG;
144     float fAverageMismatchB;
145 
146     uint32_t fTotalMismatchA;
147 
148     uint32_t fMaxMismatchA;
149     uint32_t fMaxMismatchR;
150     uint32_t fMaxMismatchG;
151     uint32_t fMaxMismatchB;
152 
153     /// Which category of diff result.
154     Result fResult;
155 };
156 
157 typedef SkTDArray<DiffRecord*> RecordArray;
158 
159 /// A wrapper for any sortProc (comparison routine) which applies a first-order
160 /// sort beforehand, and a tiebreaker if the sortProc returns 0.
compare(const void * untyped_lhs,const void * untyped_rhs)161 template<typename T> static int compare(const void* untyped_lhs, const void* untyped_rhs) {
162     const DiffRecord* lhs = *reinterpret_cast<DiffRecord* const *>(untyped_lhs);
163     const DiffRecord* rhs = *reinterpret_cast<DiffRecord* const *>(untyped_rhs);
164 
165     // First-order sort... these comparisons should be applied before comparing
166     // pixel values, no matter what.
167     if (lhs->fResult != rhs->fResult) {
168         return (lhs->fResult < rhs->fResult) ? 1 : -1;
169     }
170 
171     // Passed first-order sort, so call the pixel comparison routine.
172     int result = T::comparePixels(lhs, rhs);
173     if (result != 0) {
174         return result;
175     }
176 
177     // Tiebreaker... if we got to this point, we don't really care
178     // which order they are sorted in, but let's at least be consistent.
179     return strcmp(lhs->fBase.fFilename.c_str(), rhs->fBase.fFilename.c_str());
180 }
181 
182 /// Comparison routine for qsort; sorts by fFractionDifference
183 /// from largest to smallest.
184 class CompareDiffMetrics {
185 public:
comparePixels(const DiffRecord * lhs,const DiffRecord * rhs)186     static int comparePixels(const DiffRecord* lhs, const DiffRecord* rhs) {
187         if (lhs->fFractionDifference < rhs->fFractionDifference) {
188           return 1;
189         }
190         if (rhs->fFractionDifference < lhs->fFractionDifference) {
191           return -1;
192         }
193         return 0;
194     }
195 };
196 
197 class CompareDiffWeighted {
198 public:
comparePixels(const DiffRecord * lhs,const DiffRecord * rhs)199     static int comparePixels(const DiffRecord* lhs, const DiffRecord* rhs) {
200         if (lhs->fWeightedFraction < rhs->fWeightedFraction) {
201             return 1;
202         }
203         if (lhs->fWeightedFraction > rhs->fWeightedFraction) {
204             return -1;
205         }
206         return 0;
207     }
208 };
209 
210 /// Comparison routine for qsort;  sorts by max(fAverageMismatch{RGB})
211 /// from largest to smallest.
212 class CompareDiffMeanMismatches {
213 public:
comparePixels(const DiffRecord * lhs,const DiffRecord * rhs)214     static int comparePixels(const DiffRecord* lhs, const DiffRecord* rhs) {
215         float leftValue = MAX3(lhs->fAverageMismatchR,
216                                lhs->fAverageMismatchG,
217                                lhs->fAverageMismatchB);
218         float rightValue = MAX3(rhs->fAverageMismatchR,
219                                 rhs->fAverageMismatchG,
220                                 rhs->fAverageMismatchB);
221         if (leftValue < rightValue) {
222             return 1;
223         }
224         if (rightValue < leftValue) {
225             return -1;
226         }
227         return 0;
228     }
229 };
230 
231 /// Comparison routine for qsort;  sorts by max(fMaxMismatch{RGB})
232 /// from largest to smallest.
233 class CompareDiffMaxMismatches {
234 public:
comparePixels(const DiffRecord * lhs,const DiffRecord * rhs)235     static int comparePixels(const DiffRecord* lhs, const DiffRecord* rhs) {
236         uint32_t leftValue = MAX3(lhs->fMaxMismatchR,
237                                   lhs->fMaxMismatchG,
238                                   lhs->fMaxMismatchB);
239         uint32_t rightValue = MAX3(rhs->fMaxMismatchR,
240                                    rhs->fMaxMismatchG,
241                                    rhs->fMaxMismatchB);
242         if (leftValue < rightValue) {
243             return 1;
244         }
245         if (rightValue < leftValue) {
246             return -1;
247         }
248 
249         return CompareDiffMeanMismatches::comparePixels(lhs, rhs);
250     }
251 };
252 
253 
254 /// Parameterized routine to compute the color of a pixel in a difference image.
255 typedef SkPMColor (*DiffMetricProc)(SkPMColor, SkPMColor);
256 
257 // from gm
compute_diff_pmcolor(SkPMColor c0,SkPMColor c1)258 static inline SkPMColor compute_diff_pmcolor(SkPMColor c0, SkPMColor c1) {
259     int dr = SkGetPackedR32(c0) - SkGetPackedR32(c1);
260     int dg = SkGetPackedG32(c0) - SkGetPackedG32(c1);
261     int db = SkGetPackedB32(c0) - SkGetPackedB32(c1);
262 
263     return SkPackARGB32(0xFF, SkAbs32(dr), SkAbs32(dg), SkAbs32(db));
264 }
265 
266 /** When finished, dr->fResult should have some value other than kUnknown_Result.
267  *  Expects dr->fWhite.fBitmap and dr->fDifference.fBitmap to have the same bounds as
268  *  dr->fBase.fBitmap and have a valid pixelref.
269  */
270 void compute_diff(DiffRecord* dr, DiffMetricProc diffFunction, const int colorThreshold);
271 
272 #endif
273