revise row blits to keep intermediate precision so that color is preserved when blended against its…

include/core/SkColorPriv.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkColorPriv_DEFINED
 #define SkColorPriv_DEFINED
 
@@ skipping 182 matching lines @@
 static inline unsigned Sk255To256(U8CPU value) {
     SkASSERT(SkToU8(value) == value);
     return value + (value >> 7);
 }
 
 /** Multiplify value by 0..256, and shift the result down 8
     (i.e. return (value * alpha256) >> 8)
  */
 #define SkAlphaMul(value, alpha256)     (((value) * (alpha256)) >> 8)
 
+/** Inverted version of SkAlphaMul that properly subtracts off
+ *  any fractional precision.
+ */
+#define SkAlphaMulInv256(value, alpha256) (((256<<8) - (value) * (alpha256)) >> 8)

[mtklein, 2016/07/26 19:29:43]

Let's make this a static function and maybe try to make the comment clearer?  It
wasn't immediately clear whether this was (1-aa)*x or 1 - (x*aa).

Maybe:
    // 1 - (x*aa), for [0,255] x and [0,256] aa.

+
 //  The caller may want negative values, so keep all params signed (int)
 //  so we don't accidentally slip into unsigned math and lose the sign
 //  extension when we shift (in SkAlphaMul)
 static inline int SkAlphaBlend(int src, int dst, int scale256) {
     SkASSERT((unsigned)scale256 <= 256);
     return dst + SkAlphaMul(src - dst, scale256);
 }
 
 /**
  *  Returns (src * alpha + dst * (255 - alpha)) / 255
@@ skipping 352 matching lines @@
 }
 
 static inline SkPMColor SkPMSrcOver(SkPMColor src, SkPMColor dst) {
     return src + SkAlphaMulQ(dst, SkAlpha255To256(255 - SkGetPackedA32(src)));
 }
 
 static inline SkPMColor SkBlendARGB32(SkPMColor src, SkPMColor dst, U8CPU aa) {
     SkASSERT((unsigned)aa <= 255);
 
     unsigned src_scale = SkAlpha255To256(aa);
-    unsigned dst_scale = SkAlpha255To256(255 - SkAlphaMul(SkGetPackedA32(src), src_scale));
+    unsigned dst_scale = SkAlphaMulInv256(SkGetPackedA32(src), src_scale);
 
-    return SkAlphaMulQ(src, src_scale) + SkAlphaMulQ(dst, dst_scale);
+    const uint32_t mask = 0xFF00FF;
+
+    uint32_t src_rb = (src & mask) * src_scale;
+    uint32_t src_ag = ((src >> 8) & mask) * src_scale;
+
+    uint32_t dst_rb = (dst & mask) * dst_scale;
+    uint32_t dst_ag = ((dst >> 8) & mask) * dst_scale;
+
+    return (((src_rb + dst_rb) >> 8) & mask) | ((src_ag + dst_ag) & ~mask);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Convert a 32bit pixel to a 16bit pixel (no dither)
 
 #define SkR32ToR16_MACRO(r)   ((unsigned)(r) >> (SK_R32_BITS - SK_R16_BITS))
 #define SkG32ToG16_MACRO(g)   ((unsigned)(g) >> (SK_G32_BITS - SK_G16_BITS))
 #define SkB32ToB16_MACRO(b)   ((unsigned)(b) >> (SK_B32_BITS - SK_B16_BITS))
 
 #ifdef SK_DEBUG
@@ skipping 464 matching lines @@
     int srcG = SkColorGetG(src);
     int srcB = SkColorGetB(src);
 
     for (int i = 0; i < width; i++) {
         dst[i] = SkBlendLCD16Opaque(srcR, srcG, srcB, dst[i], mask[i],
                                     opaqueDst);
     }
 }
 
 #endif