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