src/third_party/skia/tests/SrcOverTest.cpp

   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
   8 #include "SkColorPriv.h"
   9 #include "SkXfermode.h"
  10 #include "Test.h"
  11
  12 // our std SkAlpha255To256
  13 static int test_srcover0(unsigned dst, unsigned alpha) {
  14     return alpha + SkAlphaMul(dst, SkAlpha255To256(255 - alpha));
  15 }
  16
  17 // faster hack +1
  18 static int test_srcover1(unsigned dst, unsigned alpha) {
  19     return alpha + SkAlphaMul(dst, 256 - alpha);
  20 }
  21
  22 // slower "correct"
  23 static int test_srcover2(unsigned dst, unsigned alpha) {
  24     return alpha + SkMulDiv255Round(dst, 255 - alpha);
  25 }
  26
  27 DEF_TEST(SrcOver, reporter) {
  28     /*  Here's the idea. Can we ensure that when we blend on top of an opaque
  29         dst, that the result always stay's opaque (i.e. exactly 255)?
  30      */
  31
  32     unsigned i;
  33     int opaqueCounter0 = 0;
  34     int opaqueCounter1 = 0;
  35     int opaqueCounter2 = 0;
  36     for (i = 0; i <= 255; i++) {
  37         unsigned result0 = test_srcover0(0xFF, i);
  38         unsigned result1 = test_srcover1(0xFF, i);
  39         unsigned result2 = test_srcover2(0xFF, i);
  40         opaqueCounter0 += (result0 == 0xFF);
  41         opaqueCounter1 += (result1 == 0xFF);
  42         opaqueCounter2 += (result2 == 0xFF);
  43     }
  44 #if 0
  45     SkDebugf("---- opaque test: [%d %d %d]\n",
  46              opaqueCounter0, opaqueCounter1, opaqueCounter2);
  47 #endif
  48     // we acknowledge that technique0 does not always return opaque
  49     REPORTER_ASSERT(reporter, opaqueCounter0 == 256);
  50     REPORTER_ASSERT(reporter, opaqueCounter1 == 256);
  51     REPORTER_ASSERT(reporter, opaqueCounter2 == 256);
  52
  53     // Now ensure that we never over/underflow a byte
  54     for (i = 0; i <= 255; i++) {
  55         for (unsigned dst = 0; dst <= 255; dst++) {
  56             unsigned r0 = test_srcover0(dst, i);
  57             unsigned r1 = test_srcover1(dst, i);
  58             unsigned r2 = test_srcover2(dst, i);
  59             unsigned max = SkMax32(dst, i);
  60             // ignore the known failure
  61             if (dst != 255) {
  62                 REPORTER_ASSERT(reporter, r0 <= 255 && r0 >= max);
  63             }
  64             REPORTER_ASSERT(reporter, r1 <= 255 && r1 >= max);
  65             REPORTER_ASSERT(reporter, r2 <= 255 && r2 >= max);
  66
  67 #if 0
  68             // this shows where r1 (faster) differs from r2 (more exact)
  69             if (r1 != r2) {
  70                 SkDebugf("--- dst=%d i=%d r1=%d r2=%d exact=%g\n",
  71                          dst, i, r1, r2, i + dst - dst*i/255.0f);
  72             }
  73 #endif
  74         }
  75     }
  76 }