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

src/opts/SkBlitRow_opts_arm_neon.cpp

 /*
  * Copyright 2012 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.
  */
 
 #include "SkBlitRow_opts_arm_neon.h"
 
 #include "SkBlitMask.h"
@@ skipping 891 matching lines @@
         vdst = vreinterpret_u8_u32(vld1_u32(dst));
 
         // Process src
         vsrc_wide = vmovl_u8(vsrc);
         vsrc_wide = vmulq_u16(vsrc_wide, vdupq_n_u16(src_scale));
 
         // Process dst
         vdst_wide = vmull_u8(vdst, vdup_n_u8(dst_scale));
 
         // Combine
+#ifdef SK_SUPPORT_LEGACY_BROKEN_LERP
         vres = vshrn_n_u16(vdst_wide, 8) + vshrn_n_u16(vsrc_wide, 8);
+#else
+        vdst_wide += vsrc_wide;
+        vres = vshrn_n_u16(vdst_wide, 8);
+#endif
 
         // Store
         vst1_u32(dst, vreinterpret_u32_u8(vres));
 
         src += 2;
         dst += 2;
         count -= 2;
     }
 
     if (count == 1) {
         uint8x8_t vsrc = vdup_n_u8(0), vdst = vdup_n_u8(0), vres;
         uint16x8_t vsrc_wide, vdst_wide;
 
         // Load
         vsrc = vreinterpret_u8_u32(vld1_lane_u32(src, vreinterpret_u32_u8(vsrc), 0));
         vdst = vreinterpret_u8_u32(vld1_lane_u32(dst, vreinterpret_u32_u8(vdst), 0));
 
         // Process
         vsrc_wide = vmovl_u8(vsrc);
         vsrc_wide = vmulq_u16(vsrc_wide, vdupq_n_u16(src_scale));
         vdst_wide = vmull_u8(vdst, vdup_n_u8(dst_scale));
+#ifdef SK_SUPPORT_LEGACY_BROKEN_LERP
         vres = vshrn_n_u16(vdst_wide, 8) + vshrn_n_u16(vsrc_wide, 8);
+#else
+        vdst_wide += vsrc_wide;
+        vres = vshrn_n_u16(vdst_wide, 8);
+#endif
 
         // Store
         vst1_lane_u32(dst, vreinterpret_u32_u8(vres), 0);
     }
 }
 
 #ifdef SK_CPU_ARM32
 void S32A_Blend_BlitRow32_neon(SkPMColor* SK_RESTRICT dst,
                          const SkPMColor* SK_RESTRICT src,
                          int count, U8CPU alpha) {
 
-    SkASSERT(255 >= alpha);
+    SkASSERT(255 > alpha);
 
     if (count <= 0) {
         return;
     }
 
     unsigned alpha256 = SkAlpha255To256(alpha);
 
     // First deal with odd counts
     if (count & 1) {
         uint8x8_t vsrc = vdup_n_u8(0), vdst = vdup_n_u8(0), vres;
         uint16x8_t vdst_wide, vsrc_wide;
         unsigned dst_scale;
 
         // Load
         vsrc = vreinterpret_u8_u32(vld1_lane_u32(src, vreinterpret_u32_u8(vsrc), 0));
         vdst = vreinterpret_u8_u32(vld1_lane_u32(dst, vreinterpret_u32_u8(vdst), 0));
 
         // Calc dst_scale
         dst_scale = vget_lane_u8(vsrc, 3);
-        dst_scale *= alpha256;
-        dst_scale >>= 8;
-        dst_scale = 256 - dst_scale;
+        dst_scale = SkAlphaMulInv256(dst_scale, alpha256);
 
         // Process src
         vsrc_wide = vmovl_u8(vsrc);
         vsrc_wide = vmulq_n_u16(vsrc_wide, alpha256);
 
         // Process dst
         vdst_wide = vmovl_u8(vdst);
         vdst_wide = vmulq_n_u16(vdst_wide, dst_scale);
 
         // Combine
+#ifdef SK_SUPPORT_LEGACY_BROKEN_LERP
         vres = vshrn_n_u16(vdst_wide, 8) + vshrn_n_u16(vsrc_wide, 8);
+#else
+        vdst_wide += vsrc_wide;
+        vres = vshrn_n_u16(vdst_wide, 8);
+#endif
 
         vst1_lane_u32(dst, vreinterpret_u32_u8(vres), 0);
         dst++;
         src++;
         count--;
     }
 
     if (count) {
         uint8x8_t alpha_mask;
         static const uint8_t alpha_mask_setup[] = {3,3,3,3,7,7,7,7};
@@ skipping 10 matching lines @@
             // Load
             vsrc = vreinterpret_u8_u32(vld1_u32(src));
             vdst = vreinterpret_u8_u32(vld1_u32(dst));
 
             // Prepare src_scale
             vsrc_scale = vdupq_n_u16(alpha256);
 
             // Calc dst_scale
             vsrc_alphas = vtbl1_u8(vsrc, alpha_mask);
             vdst_scale = vmovl_u8(vsrc_alphas);
+#ifdef SK_SUPPORT_LEGACY_BROKEN_LERP
             vdst_scale *= vsrc_scale;
             vdst_scale = vshrq_n_u16(vdst_scale, 8);
             vdst_scale = vsubq_u16(vdupq_n_u16(256), vdst_scale);
+#else
+            // Calculate SkAlphaMulInv256(vdst_scale, vsrc_scale).
+            // A 16-bit lane would overflow if we used 0xFFFF here,
+            // so use an approximation with 0xFF00 that is off by 1,
+            // and add back 1 after to get the correct value.
+            // This is valid if alpha256 <= 255.
+            vdst_scale = vmlsq_u16(vdupq_n_u16(0xFF00), vdst_scale, vsrc_scale);
+            vdst_scale = vsraq_n_u16(vdst_scale, vdst_scale, 8);
+            vdst_scale = vsraq_n_u16(vdupq_n_u16(1), vdst_scale, 8);
+#endif
 
             // Process src
             vsrc_wide = vmovl_u8(vsrc);
             vsrc_wide *= vsrc_scale;
 
             // Process dst
             vdst_wide = vmovl_u8(vdst);
             vdst_wide *= vdst_scale;
 
             // Combine
+#ifdef SK_SUPPORT_LEGACY_BROKEN_LERP
             vres = vshrn_n_u16(vdst_wide, 8) + vshrn_n_u16(vsrc_wide, 8);
+#else
+            vdst_wide += vsrc_wide;
+            vres = vshrn_n_u16(vdst_wide, 8);
+#endif
 
             vst1_u32(dst, vreinterpret_u32_u8(vres));
 
             src += 2;
             dst += 2;
             count -= 2;
         } while(count);
     }
 }
 
@@ skipping 251 matching lines @@
 const SkBlitRow::Proc32 sk_blitrow_platform_32_procs_arm_neon[] = {
     nullptr,   // S32_Opaque,
     S32_Blend_BlitRow32_neon,        // S32_Blend,
     nullptr,  // Ported to SkOpts
 #ifdef SK_CPU_ARM32
     S32A_Blend_BlitRow32_neon        // S32A_Blend
 #else
     nullptr
 #endif
 };