1 2 #include "SkBlitMask.h" 3 #include "SkColor_opts_neon.h" 4 5 static void D32_A8_Black_neon(void* SK_RESTRICT dst, size_t dstRB, 6 const void* SK_RESTRICT maskPtr, size_t maskRB, 7 SkColor, int width, int height) { 8 SkPMColor* SK_RESTRICT device = (SkPMColor*)dst; 9 const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr; 10 11 maskRB -= width; 12 dstRB -= (width << 2); 13 do { 14 int w = width; 15 while (w >= 8) { 16 uint8x8_t vmask = vld1_u8(mask); 17 uint16x8_t vscale = vsubw_u8(vdupq_n_u16(256), vmask); 18 uint8x8x4_t vdevice = vld4_u8((uint8_t*)device); 19 20 vdevice = SkAlphaMulQ_neon8(vdevice, vscale); 21 vdevice.val[NEON_A] += vmask; 22 23 vst4_u8((uint8_t*)device, vdevice); 24 25 mask += 8; 26 device += 8; 27 w -= 8; 28 } 29 while (w-- > 0) { 30 unsigned aa = *mask++; 31 *device = (aa << SK_A32_SHIFT) 32 + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa)); 33 device += 1; 34 }; 35 device = (uint32_t*)((char*)device + dstRB); 36 mask += maskRB; 37 } while (--height != 0); 38 } 39 40 template <bool isColor> 41 static void D32_A8_Opaque_Color_neon(void* SK_RESTRICT dst, size_t dstRB, 42 const void* SK_RESTRICT maskPtr, size_t maskRB, 43 SkColor color, int width, int height) { 44 SkPMColor pmc = SkPreMultiplyColor(color); 45 SkPMColor* SK_RESTRICT device = (SkPMColor*)dst; 46 const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr; 47 uint8x8x4_t vpmc; 48 49 maskRB -= width; 50 dstRB -= (width << 2); 51 52 if (width >= 8) { 53 vpmc.val[NEON_A] = vdup_n_u8(SkGetPackedA32(pmc)); 54 vpmc.val[NEON_R] = vdup_n_u8(SkGetPackedR32(pmc)); 55 vpmc.val[NEON_G] = vdup_n_u8(SkGetPackedG32(pmc)); 56 vpmc.val[NEON_B] = vdup_n_u8(SkGetPackedB32(pmc)); 57 } 58 do { 59 int w = width; 60 while (w >= 8) { 61 uint8x8_t vmask = vld1_u8(mask); 62 uint16x8_t vscale, vmask256 = SkAlpha255To256_neon8(vmask); 63 if (isColor) { 64 vscale = vsubw_u8(vdupq_n_u16(256), 65 SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256)); 66 } else { 67 vscale = vsubw_u8(vdupq_n_u16(256), vmask); 68 } 69 uint8x8x4_t vdev = vld4_u8((uint8_t*)device); 70 71 vdev.val[NEON_A] = SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256) 72 + SkAlphaMul_neon8(vdev.val[NEON_A], vscale); 73 vdev.val[NEON_R] = SkAlphaMul_neon8(vpmc.val[NEON_R], vmask256) 74 + SkAlphaMul_neon8(vdev.val[NEON_R], vscale); 75 vdev.val[NEON_G] = SkAlphaMul_neon8(vpmc.val[NEON_G], vmask256) 76 + SkAlphaMul_neon8(vdev.val[NEON_G], vscale); 77 vdev.val[NEON_B] = SkAlphaMul_neon8(vpmc.val[NEON_B], vmask256) 78 + SkAlphaMul_neon8(vdev.val[NEON_B], vscale); 79 80 vst4_u8((uint8_t*)device, vdev); 81 82 mask += 8; 83 device += 8; 84 w -= 8; 85 } 86 87 while (w--) { 88 unsigned aa = *mask++; 89 if (isColor) { 90 *device = SkBlendARGB32(pmc, *device, aa); 91 } else { 92 *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa)) 93 + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa)); 94 } 95 device += 1; 96 }; 97 98 device = (uint32_t*)((char*)device + dstRB); 99 mask += maskRB; 100 101 } while (--height != 0); 102 } 103 104 static void D32_A8_Opaque_neon(void* SK_RESTRICT dst, size_t dstRB, 105 const void* SK_RESTRICT maskPtr, size_t maskRB, 106 SkColor color, int width, int height) { 107 D32_A8_Opaque_Color_neon<false>(dst, dstRB, maskPtr, maskRB, color, width, height); 108 } 109 110 static void D32_A8_Color_neon(void* SK_RESTRICT dst, size_t dstRB, 111 const void* SK_RESTRICT maskPtr, size_t maskRB, 112 SkColor color, int width, int height) { 113 D32_A8_Opaque_Color_neon<true>(dst, dstRB, maskPtr, maskRB, color, width, height); 114 } 115 116 SkBlitMask::ColorProc D32_A8_Factory_neon(SkColor color) { 117 if (SK_ColorBLACK == color) { 118 return D32_A8_Black_neon; 119 } else if (0xFF == SkColorGetA(color)) { 120 return D32_A8_Opaque_neon; 121 } else { 122 return D32_A8_Color_neon; 123 } 124 } 125 126 //////////////////////////////////////////////////////////////////////////////// 127 128 void SkBlitLCD16OpaqueRow_neon(SkPMColor dst[], const uint16_t src[], 129 SkColor color, int width, 130 SkPMColor opaqueDst) { 131 int colR = SkColorGetR(color); 132 int colG = SkColorGetG(color); 133 int colB = SkColorGetB(color); 134 135 uint8x8_t vcolR, vcolG, vcolB; 136 uint8x8_t vopqDstA, vopqDstR, vopqDstG, vopqDstB; 137 138 if (width >= 8) { 139 vcolR = vdup_n_u8(colR); 140 vcolG = vdup_n_u8(colG); 141 vcolB = vdup_n_u8(colB); 142 vopqDstA = vdup_n_u8(SkGetPackedA32(opaqueDst)); 143 vopqDstR = vdup_n_u8(SkGetPackedR32(opaqueDst)); 144 vopqDstG = vdup_n_u8(SkGetPackedG32(opaqueDst)); 145 vopqDstB = vdup_n_u8(SkGetPackedB32(opaqueDst)); 146 } 147 148 while (width >= 8) { 149 uint8x8x4_t vdst; 150 uint16x8_t vmask; 151 uint16x8_t vmaskR, vmaskG, vmaskB; 152 uint8x8_t vsel_trans, vsel_opq; 153 154 vdst = vld4_u8((uint8_t*)dst); 155 vmask = vld1q_u16(src); 156 157 // Prepare compare masks 158 vsel_trans = vmovn_u16(vceqq_u16(vmask, vdupq_n_u16(0))); 159 vsel_opq = vmovn_u16(vceqq_u16(vmask, vdupq_n_u16(0xFFFF))); 160 161 // Get all the color masks on 5 bits 162 vmaskR = vshrq_n_u16(vmask, SK_R16_SHIFT); 163 vmaskG = vshrq_n_u16(vshlq_n_u16(vmask, SK_R16_BITS), 164 SK_B16_BITS + SK_R16_BITS + 1); 165 vmaskB = vmask & vdupq_n_u16(SK_B16_MASK); 166 167 // Upscale to 0..32 168 vmaskR = vmaskR + vshrq_n_u16(vmaskR, 4); 169 vmaskG = vmaskG + vshrq_n_u16(vmaskG, 4); 170 vmaskB = vmaskB + vshrq_n_u16(vmaskB, 4); 171 172 vdst.val[NEON_A] = vbsl_u8(vsel_trans, vdst.val[NEON_A], vdup_n_u8(0xFF)); 173 vdst.val[NEON_A] = vbsl_u8(vsel_opq, vopqDstA, vdst.val[NEON_A]); 174 175 vdst.val[NEON_R] = SkBlend32_neon8(vcolR, vdst.val[NEON_R], vmaskR); 176 vdst.val[NEON_G] = SkBlend32_neon8(vcolG, vdst.val[NEON_G], vmaskG); 177 vdst.val[NEON_B] = SkBlend32_neon8(vcolB, vdst.val[NEON_B], vmaskB); 178 179 vdst.val[NEON_R] = vbsl_u8(vsel_opq, vopqDstR, vdst.val[NEON_R]); 180 vdst.val[NEON_G] = vbsl_u8(vsel_opq, vopqDstG, vdst.val[NEON_G]); 181 vdst.val[NEON_B] = vbsl_u8(vsel_opq, vopqDstB, vdst.val[NEON_B]); 182 183 vst4_u8((uint8_t*)dst, vdst); 184 185 dst += 8; 186 src += 8; 187 width -= 8; 188 } 189 190 // Leftovers 191 for (int i = 0; i < width; i++) { 192 dst[i] = SkBlendLCD16Opaque(colR, colG, colB, dst[i], src[i], 193 opaqueDst); 194 } 195 } 196 197 void SkBlitLCD16Row_neon(SkPMColor dst[], const uint16_t src[], 198 SkColor color, int width, SkPMColor) { 199 int colA = SkColorGetA(color); 200 int colR = SkColorGetR(color); 201 int colG = SkColorGetG(color); 202 int colB = SkColorGetB(color); 203 204 colA = SkAlpha255To256(colA); 205 206 uint8x8_t vcolR, vcolG, vcolB; 207 uint16x8_t vcolA; 208 209 if (width >= 8) { 210 vcolA = vdupq_n_u16(colA); 211 vcolR = vdup_n_u8(colR); 212 vcolG = vdup_n_u8(colG); 213 vcolB = vdup_n_u8(colB); 214 } 215 216 while (width >= 8) { 217 uint8x8x4_t vdst; 218 uint16x8_t vmask; 219 uint16x8_t vmaskR, vmaskG, vmaskB; 220 221 vdst = vld4_u8((uint8_t*)dst); 222 vmask = vld1q_u16(src); 223 224 // Get all the color masks on 5 bits 225 vmaskR = vshrq_n_u16(vmask, SK_R16_SHIFT); 226 vmaskG = vshrq_n_u16(vshlq_n_u16(vmask, SK_R16_BITS), 227 SK_B16_BITS + SK_R16_BITS + 1); 228 vmaskB = vmask & vdupq_n_u16(SK_B16_MASK); 229 230 // Upscale to 0..32 231 vmaskR = vmaskR + vshrq_n_u16(vmaskR, 4); 232 vmaskG = vmaskG + vshrq_n_u16(vmaskG, 4); 233 vmaskB = vmaskB + vshrq_n_u16(vmaskB, 4); 234 235 vmaskR = vshrq_n_u16(vmaskR * vcolA, 8); 236 vmaskG = vshrq_n_u16(vmaskG * vcolA, 8); 237 vmaskB = vshrq_n_u16(vmaskB * vcolA, 8); 238 239 vdst.val[NEON_A] = vdup_n_u8(0xFF); 240 vdst.val[NEON_R] = SkBlend32_neon8(vcolR, vdst.val[NEON_R], vmaskR); 241 vdst.val[NEON_G] = SkBlend32_neon8(vcolG, vdst.val[NEON_G], vmaskG); 242 vdst.val[NEON_B] = SkBlend32_neon8(vcolB, vdst.val[NEON_B], vmaskB); 243 244 vst4_u8((uint8_t*)dst, vdst); 245 246 dst += 8; 247 src += 8; 248 width -= 8; 249 } 250 251 for (int i = 0; i < width; i++) { 252 dst[i] = SkBlendLCD16(colA, colR, colG, colB, dst[i], src[i]); 253 } 254 } 255
