src/third_party/skia/tests/BlendTest.cpp

   1 #include "Test.h"
   2 #include "SkColor.h"
   3
   4 #define ASSERT(x) REPORTER_ASSERT(r, x)
   5
   6 static uint8_t double_to_u8(double d) {
   7     SkASSERT(d >= 0);
   8     SkASSERT(d < 256);
   9     return uint8_t(d);
  10 }
  11
  12 // All algorithms we're testing have this interface.
  13 // We want a single channel blend, src over dst, assuming src is premultiplied by srcAlpha.
  14 typedef uint8_t(*Blend)(uint8_t dst, uint8_t src, uint8_t srcAlpha);
  15
  16 // This is our golden algorithm.
  17 static uint8_t blend_double_round(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  18     SkASSERT(src <= srcAlpha);
  19     return double_to_u8(0.5 + src + dst * (255.0 - srcAlpha) / 255.0);
  20 }
  21
  22 static uint8_t abs_diff(uint8_t a, uint8_t b) {
  23     const int diff = a - b;
  24     return diff > 0 ? diff : -diff;
  25 }
  26
  27 static void test(skiatest::Reporter* r, int maxDiff, Blend algorithm,
  28                  uint8_t dst, uint8_t src, uint8_t alpha) {
  29     const uint8_t golden = blend_double_round(dst, src, alpha);
  30     const uint8_t  blend =          algorithm(dst, src, alpha);
  31     if (abs_diff(blend, golden) > maxDiff) {
  32         SkDebugf("dst %02x, src %02x, alpha %02x, |%02x - %02x| > %d\n",
  33                  dst, src, alpha, blend, golden, maxDiff);
  34         ASSERT(abs_diff(blend, golden) <= maxDiff);
  35     }
  36 }
  37
  38 // Exhaustively compare an algorithm against our golden, for a given alpha.
  39 static void test_alpha(skiatest::Reporter* r, uint8_t alpha, int maxDiff, Blend algorithm) {
  40     SkASSERT(maxDiff >= 0);
  41
  42     for (unsigned src = 0; src <= alpha; src++) {
  43         for (unsigned dst = 0; dst < 256; dst++) {
  44             test(r, maxDiff, algorithm, dst, src, alpha);
  45         }
  46     }
  47 }
  48
  49 // Exhaustively compare an algorithm against our golden, for a given dst.
  50 static void test_dst(skiatest::Reporter* r, uint8_t dst, int maxDiff, Blend algorithm) {
  51     SkASSERT(maxDiff >= 0);
  52
  53     for (unsigned alpha = 0; alpha < 256; alpha++) {
  54         for (unsigned src = 0; src <= alpha; src++) {
  55             test(r, maxDiff, algorithm, dst, src, alpha);
  56         }
  57     }
  58 }
  59
  60 static uint8_t blend_double_trunc(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  61     return double_to_u8(src + dst * (255.0 - srcAlpha) / 255.0);
  62 }
  63
  64 static uint8_t blend_float_trunc(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  65     return double_to_u8(src + dst * (255.0f - srcAlpha) / 255.0f);
  66 }
  67
  68 static uint8_t blend_float_round(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  69     return double_to_u8(0.5f + src + dst * (255.0f - srcAlpha) / 255.0f);
  70 }
  71
  72 static uint8_t blend_255_trunc(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  73     const uint16_t invAlpha = 255 - srcAlpha;
  74     const uint16_t product = dst * invAlpha;
  75     return src + (product >> 8);
  76 }
  77
  78 static uint8_t blend_255_round(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  79     const uint16_t invAlpha = 255 - srcAlpha;
  80     const uint16_t product = dst * invAlpha + 128;
  81     return src + (product >> 8);
  82 }
  83
  84 static uint8_t blend_256_trunc(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  85     const uint16_t invAlpha = 256 - (srcAlpha + (srcAlpha >> 7));
  86     const uint16_t product = dst * invAlpha;
  87     return src + (product >> 8);
  88 }
  89
  90 static uint8_t blend_256_round(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  91     const uint16_t invAlpha = 256 - (srcAlpha + (srcAlpha >> 7));
  92     const uint16_t product = dst * invAlpha + 128;
  93     return src + (product >> 8);
  94 }
  95
  96 static uint8_t blend_256_round_alt(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
  97     const uint8_t invAlpha8 = 255 - srcAlpha;
  98     const uint16_t invAlpha = invAlpha8 + (invAlpha8 >> 7);
  99     const uint16_t product = dst * invAlpha + 128;
 100     return src + (product >> 8);
 101 }
 102
 103 static uint8_t blend_256_plus1_trunc(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
 104     const uint16_t invAlpha = 256 - (srcAlpha + 1);
 105     const uint16_t product = dst * invAlpha;
 106     return src + (product >> 8);
 107 }
 108
 109 static uint8_t blend_256_plus1_round(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
 110     const uint16_t invAlpha = 256 - (srcAlpha + 1);
 111     const uint16_t product = dst * invAlpha + 128;
 112     return src + (product >> 8);
 113 }
 114
 115 static uint8_t blend_perfect(uint8_t dst, uint8_t src, uint8_t srcAlpha) {
 116     const uint8_t invAlpha = 255 - srcAlpha;
 117     const uint16_t product = dst * invAlpha + 128;
 118     return src + ((product + (product >> 8)) >> 8);
 119 }
 120
 121
 122 // We want 0 diff whenever src is fully transparent.
 123 DEF_TEST(Blend_alpha_0x00, r) {
 124     const uint8_t alpha = 0x00;
 125
 126     // GOOD
 127     test_alpha(r, alpha, 0, blend_256_round);
 128     test_alpha(r, alpha, 0, blend_256_round_alt);
 129     test_alpha(r, alpha, 0, blend_256_trunc);
 130     test_alpha(r, alpha, 0, blend_double_trunc);
 131     test_alpha(r, alpha, 0, blend_float_round);
 132     test_alpha(r, alpha, 0, blend_float_trunc);
 133     test_alpha(r, alpha, 0, blend_perfect);
 134
 135     // BAD
 136     test_alpha(r, alpha, 1, blend_255_round);
 137     test_alpha(r, alpha, 1, blend_255_trunc);
 138     test_alpha(r, alpha, 1, blend_256_plus1_round);
 139     test_alpha(r, alpha, 1, blend_256_plus1_trunc);
 140 }
 141
 142 // We want 0 diff whenever dst is 0.
 143 DEF_TEST(Blend_dst_0x00, r) {
 144     const uint8_t dst = 0x00;
 145
 146     // GOOD
 147     test_dst(r, dst, 0, blend_255_round);
 148     test_dst(r, dst, 0, blend_255_trunc);
 149     test_dst(r, dst, 0, blend_256_plus1_round);
 150     test_dst(r, dst, 0, blend_256_plus1_trunc);
 151     test_dst(r, dst, 0, blend_256_round);
 152     test_dst(r, dst, 0, blend_256_round_alt);
 153     test_dst(r, dst, 0, blend_256_trunc);
 154     test_dst(r, dst, 0, blend_double_trunc);
 155     test_dst(r, dst, 0, blend_float_round);
 156     test_dst(r, dst, 0, blend_float_trunc);
 157     test_dst(r, dst, 0, blend_perfect);
 158
 159     // BAD
 160 }
 161
 162 // We want 0 diff whenever src is fully opaque.
 163 DEF_TEST(Blend_alpha_0xFF, r) {
 164     const uint8_t alpha = 0xFF;
 165
 166     // GOOD
 167     test_alpha(r, alpha, 0, blend_255_round);
 168     test_alpha(r, alpha, 0, blend_255_trunc);
 169     test_alpha(r, alpha, 0, blend_256_plus1_round);
 170     test_alpha(r, alpha, 0, blend_256_plus1_trunc);
 171     test_alpha(r, alpha, 0, blend_256_round);
 172     test_alpha(r, alpha, 0, blend_256_round_alt);
 173     test_alpha(r, alpha, 0, blend_256_trunc);
 174     test_alpha(r, alpha, 0, blend_double_trunc);
 175     test_alpha(r, alpha, 0, blend_float_round);
 176     test_alpha(r, alpha, 0, blend_float_trunc);
 177     test_alpha(r, alpha, 0, blend_perfect);
 178
 179     // BAD
 180 }
 181
 182 // We want 0 diff whenever dst is 0xFF.
 183 DEF_TEST(Blend_dst_0xFF, r) {
 184     const uint8_t dst = 0xFF;
 185
 186     // GOOD
 187     test_dst(r, dst, 0, blend_256_round);
 188     test_dst(r, dst, 0, blend_256_round_alt);
 189     test_dst(r, dst, 0, blend_double_trunc);
 190     test_dst(r, dst, 0, blend_float_round);
 191     test_dst(r, dst, 0, blend_float_trunc);
 192     test_dst(r, dst, 0, blend_perfect);
 193
 194     // BAD
 195     test_dst(r, dst, 1, blend_255_round);
 196     test_dst(r, dst, 1, blend_255_trunc);
 197     test_dst(r, dst, 1, blend_256_plus1_round);
 198     test_dst(r, dst, 1, blend_256_plus1_trunc);
 199     test_dst(r, dst, 1, blend_256_trunc);
 200 }
 201
 202 // We'd like diff <= 1 everywhere.
 203 DEF_TEST(Blend_alpha_Exhaustive, r) {
 204     for (unsigned alpha = 0; alpha < 256; alpha++) {
 205         // PERFECT
 206         test_alpha(r, alpha, 0, blend_float_round);
 207         test_alpha(r, alpha, 0, blend_perfect);
 208
 209         // GOOD
 210         test_alpha(r, alpha, 1, blend_255_round);
 211         test_alpha(r, alpha, 1, blend_256_plus1_round);
 212         test_alpha(r, alpha, 1, blend_256_round);
 213         test_alpha(r, alpha, 1, blend_256_round_alt);
 214         test_alpha(r, alpha, 1, blend_256_trunc);
 215         test_alpha(r, alpha, 1, blend_double_trunc);
 216         test_alpha(r, alpha, 1, blend_float_trunc);
 217
 218         // BAD
 219         test_alpha(r, alpha, 2, blend_255_trunc);
 220         test_alpha(r, alpha, 2, blend_256_plus1_trunc);
 221     }
 222 }
 223
 224 // We'd like diff <= 1 everywhere.
 225 DEF_TEST(Blend_dst_Exhaustive, r) {
 226     for (unsigned dst = 0; dst < 256; dst++) {
 227         // PERFECT
 228         test_dst(r, dst, 0, blend_float_round);
 229         test_dst(r, dst, 0, blend_perfect);
 230
 231         // GOOD
 232         test_dst(r, dst, 1, blend_255_round);
 233         test_dst(r, dst, 1, blend_256_plus1_round);
 234         test_dst(r, dst, 1, blend_256_round);
 235         test_dst(r, dst, 1, blend_256_round_alt);
 236         test_dst(r, dst, 1, blend_256_trunc);
 237         test_dst(r, dst, 1, blend_double_trunc);
 238         test_dst(r, dst, 1, blend_float_trunc);
 239
 240         // BAD
 241         test_dst(r, dst, 2, blend_255_trunc);
 242         test_dst(r, dst, 2, blend_256_plus1_trunc);
 243     }
 244 }
 245 // Overall summary:
 246 // PERFECT
 247 //  blend_double_round
 248 //  blend_float_round
 249 //  blend_perfect
 250 // GOOD ENOUGH
 251 //  blend_double_trunc
 252 //  blend_float_trunc
 253 //  blend_256_round
 254 //  blend_256_round_alt
 255 // NOT GOOD ENOUGH
 256 //  all others
 257 //
 258 //  Algorithms that make sense to use in Skia: blend_256_round, blend_256_round_alt, blend_perfect