1 /* 2 * Copyright 2015 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 #ifndef SkBlitMask_opts_DEFINED 9 #define SkBlitMask_opts_DEFINED 10 11 #include "Sk4px.h" 12 13 namespace SK_OPTS_NS { 14 15 #if defined(SK_ARM_HAS_NEON) 16 // The Sk4px versions below will work fine with NEON, but we have had many indications 17 // that it doesn't perform as well as this NEON-specific code. TODO(mtklein): why? 18 #include "SkColor_opts_neon.h" 19 20 template <bool isColor> 21 static void D32_A8_Opaque_Color_neon(void* SK_RESTRICT dst, size_t dstRB, 22 const void* SK_RESTRICT maskPtr, size_t maskRB, 23 SkColor color, int width, int height) { 24 SkPMColor pmc = SkPreMultiplyColor(color); 25 SkPMColor* SK_RESTRICT device = (SkPMColor*)dst; 26 const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr; 27 uint8x8x4_t vpmc; 28 29 maskRB -= width; 30 dstRB -= (width << 2); 31 32 if (width >= 8) { 33 vpmc.val[NEON_A] = vdup_n_u8(SkGetPackedA32(pmc)); 34 vpmc.val[NEON_R] = vdup_n_u8(SkGetPackedR32(pmc)); 35 vpmc.val[NEON_G] = vdup_n_u8(SkGetPackedG32(pmc)); 36 vpmc.val[NEON_B] = vdup_n_u8(SkGetPackedB32(pmc)); 37 } 38 do { 39 int w = width; 40 while (w >= 8) { 41 uint8x8_t vmask = vld1_u8(mask); 42 uint16x8_t vscale, vmask256 = SkAlpha255To256_neon8(vmask); 43 if (isColor) { 44 vscale = vsubw_u8(vdupq_n_u16(256), 45 SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256)); 46 } else { 47 vscale = vsubw_u8(vdupq_n_u16(256), vmask); 48 } 49 uint8x8x4_t vdev = vld4_u8((uint8_t*)device); 50 51 vdev.val[NEON_A] = SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256) 52 + SkAlphaMul_neon8(vdev.val[NEON_A], vscale); 53 vdev.val[NEON_R] = SkAlphaMul_neon8(vpmc.val[NEON_R], vmask256) 54 + SkAlphaMul_neon8(vdev.val[NEON_R], vscale); 55 vdev.val[NEON_G] = SkAlphaMul_neon8(vpmc.val[NEON_G], vmask256) 56 + SkAlphaMul_neon8(vdev.val[NEON_G], vscale); 57 vdev.val[NEON_B] = SkAlphaMul_neon8(vpmc.val[NEON_B], vmask256) 58 + SkAlphaMul_neon8(vdev.val[NEON_B], vscale); 59 60 vst4_u8((uint8_t*)device, vdev); 61 62 mask += 8; 63 device += 8; 64 w -= 8; 65 } 66 67 while (w--) { 68 unsigned aa = *mask++; 69 if (isColor) { 70 *device = SkBlendARGB32(pmc, *device, aa); 71 } else { 72 *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa)) 73 + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa)); 74 } 75 device += 1; 76 }; 77 78 device = (uint32_t*)((char*)device + dstRB); 79 mask += maskRB; 80 81 } while (--height != 0); 82 } 83 84 static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB, 85 const SkAlpha* mask, size_t maskRB, 86 SkColor color, int w, int h) { 87 D32_A8_Opaque_Color_neon<true>(dst, dstRB, mask, maskRB, color, w, h); 88 } 89 90 // As above, but made slightly simpler by requiring that color is opaque. 91 static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB, 92 const SkAlpha* mask, size_t maskRB, 93 SkColor color, int w, int h) { 94 D32_A8_Opaque_Color_neon<false>(dst, dstRB, mask, maskRB, color, w, h); 95 } 96 97 // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case. 98 static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB, 99 const SkAlpha* maskPtr, size_t maskRB, 100 int width, int height) { 101 SkPMColor* SK_RESTRICT device = (SkPMColor*)dst; 102 const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr; 103 104 maskRB -= width; 105 dstRB -= (width << 2); 106 do { 107 int w = width; 108 while (w >= 8) { 109 uint8x8_t vmask = vld1_u8(mask); 110 uint16x8_t vscale = vsubw_u8(vdupq_n_u16(256), vmask); 111 uint8x8x4_t vdevice = vld4_u8((uint8_t*)device); 112 113 vdevice = SkAlphaMulQ_neon8(vdevice, vscale); 114 vdevice.val[NEON_A] += vmask; 115 116 vst4_u8((uint8_t*)device, vdevice); 117 118 mask += 8; 119 device += 8; 120 w -= 8; 121 } 122 while (w-- > 0) { 123 unsigned aa = *mask++; 124 *device = (aa << SK_A32_SHIFT) 125 + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa)); 126 device += 1; 127 }; 128 device = (uint32_t*)((char*)device + dstRB); 129 mask += maskRB; 130 } while (--height != 0); 131 } 132 133 #else 134 static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB, 135 const SkAlpha* mask, size_t maskRB, 136 SkColor color, int w, int h) { 137 auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color)); 138 auto fn = [&](const Sk4px& d, const Sk4px& aa) { 139 // = (s + d(1-sa))aa + d(1-aa) 140 // = s*aa + d(1-sa*aa) 141 auto left = s.approxMulDiv255(aa), 142 right = d.approxMulDiv255(left.alphas().inv()); 143 return left + right; // This does not overflow (exhaustively checked). 144 }; 145 while (h --> 0) { 146 Sk4px::MapDstAlpha(w, dst, mask, fn); 147 dst += dstRB / sizeof(*dst); 148 mask += maskRB / sizeof(*mask); 149 } 150 } 151 152 // As above, but made slightly simpler by requiring that color is opaque. 153 static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB, 154 const SkAlpha* mask, size_t maskRB, 155 SkColor color, int w, int h) { 156 SkASSERT(SkColorGetA(color) == 0xFF); 157 auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color)); 158 auto fn = [&](const Sk4px& d, const Sk4px& aa) { 159 // = (s + d(1-sa))aa + d(1-aa) 160 // = s*aa + d(1-sa*aa) 161 // ~~~> 162 // = s*aa + d(1-aa) 163 return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv()); 164 }; 165 while (h --> 0) { 166 Sk4px::MapDstAlpha(w, dst, mask, fn); 167 dst += dstRB / sizeof(*dst); 168 mask += maskRB / sizeof(*mask); 169 } 170 } 171 172 // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case. 173 static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB, 174 const SkAlpha* mask, size_t maskRB, 175 int w, int h) { 176 auto fn = [](const Sk4px& d, const Sk4px& aa) { 177 // = (s + d(1-sa))aa + d(1-aa) 178 // = s*aa + d(1-sa*aa) 179 // ~~~> 180 // a = 1*aa + d(1-1*aa) = aa + d(1-aa) 181 // c = 0*aa + d(1-1*aa) = d(1-aa) 182 return aa.zeroColors() + d.approxMulDiv255(aa.inv()); 183 }; 184 while (h --> 0) { 185 Sk4px::MapDstAlpha(w, dst, mask, fn); 186 dst += dstRB / sizeof(*dst); 187 mask += maskRB / sizeof(*mask); 188 } 189 } 190 #endif 191 192 static void blit_mask_d32_a8(SkPMColor* dst, size_t dstRB, 193 const SkAlpha* mask, size_t maskRB, 194 SkColor color, int w, int h) { 195 if (color == SK_ColorBLACK) { 196 blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h); 197 } else if (SkColorGetA(color) == 0xFF) { 198 blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h); 199 } else { 200 blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h); 201 } 202 } 203 204 } // SK_OPTS_NS 205 206 #endif//SkBlitMask_opts_DEFINED 207
