src/opts/SkBlitMask_opts.h - platform/external/skia - Gitiles

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #ifndef SkBlitMask_opts_DEFINED
 #define SkBlitMask_opts_DEFINED

 #include "src/core/Sk4px.h"

 namespace SK_OPTS_NS {

 #if defined(SK_ARM_HAS_NEON)
     // The Sk4px versions below will work fine with NEON, but we have had many indications
     // that it doesn't perform as well as this NEON-specific code.  TODO(mtklein): why?

     #define NEON_A (SK_A32_SHIFT / 8)
     #define NEON_R (SK_R32_SHIFT / 8)
     #define NEON_G (SK_G32_SHIFT / 8)
     #define NEON_B (SK_B32_SHIFT / 8)

     static inline uint16x8_t SkAlpha255To256_neon8(uint8x8_t alpha) {
         return vaddw_u8(vdupq_n_u16(1), alpha);
     }

     static inline uint8x8_t SkAlphaMul_neon8(uint8x8_t color, uint16x8_t scale) {
         return vshrn_n_u16(vmovl_u8(color) * scale, 8);
     }

     static inline uint8x8x4_t SkAlphaMulQ_neon8(uint8x8x4_t color, uint16x8_t scale) {
         uint8x8x4_t ret;

         ret.val[0] = SkAlphaMul_neon8(color.val[0], scale);
         ret.val[1] = SkAlphaMul_neon8(color.val[1], scale);
         ret.val[2] = SkAlphaMul_neon8(color.val[2], scale);
         ret.val[3] = SkAlphaMul_neon8(color.val[3], scale);

         return ret;
     }


     template <bool isColor>
     static void D32_A8_Opaque_Color_neon(void* SK_RESTRICT dst, size_t dstRB,
                                          const void* SK_RESTRICT maskPtr, size_t maskRB,
                                          SkColor color, int width, int height) {
         SkPMColor pmc = SkPreMultiplyColor(color);
         SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
         const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
         uint8x8x4_t vpmc;

         maskRB -= width;
         dstRB -= (width << 2);

         if (width >= 8) {
             vpmc.val[NEON_A] = vdup_n_u8(SkGetPackedA32(pmc));
             vpmc.val[NEON_R] = vdup_n_u8(SkGetPackedR32(pmc));
             vpmc.val[NEON_G] = vdup_n_u8(SkGetPackedG32(pmc));
             vpmc.val[NEON_B] = vdup_n_u8(SkGetPackedB32(pmc));
         }
         do {
             int w = width;
             while (w >= 8) {
                 uint8x8_t vmask = vld1_u8(mask);
                 uint16x8_t vscale, vmask256 = SkAlpha255To256_neon8(vmask);
                 if (isColor) {
                     vscale = vsubw_u8(vdupq_n_u16(256),
                             SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256));
                 } else {
                     vscale = vsubw_u8(vdupq_n_u16(256), vmask);
                 }
                 uint8x8x4_t vdev = vld4_u8((uint8_t*)device);

                 vdev.val[NEON_A] =   SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256)
                     + SkAlphaMul_neon8(vdev.val[NEON_A], vscale);
                 vdev.val[NEON_R] =   SkAlphaMul_neon8(vpmc.val[NEON_R], vmask256)
                     + SkAlphaMul_neon8(vdev.val[NEON_R], vscale);
                 vdev.val[NEON_G] =   SkAlphaMul_neon8(vpmc.val[NEON_G], vmask256)
                     + SkAlphaMul_neon8(vdev.val[NEON_G], vscale);
                 vdev.val[NEON_B] =   SkAlphaMul_neon8(vpmc.val[NEON_B], vmask256)
                     + SkAlphaMul_neon8(vdev.val[NEON_B], vscale);

                 vst4_u8((uint8_t*)device, vdev);

                 mask += 8;
                 device += 8;
                 w -= 8;
             }

             while (w--) {
                 unsigned aa = *mask++;
                 if (isColor) {
                     *device = SkBlendARGB32(pmc, *device, aa);
                 } else {
                     *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa))
                         + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
                 }
                 device += 1;
             }

             device = (uint32_t*)((char*)device + dstRB);
             mask += maskRB;

         } while (--height != 0);
     }

     static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
                                          const SkAlpha* mask, size_t maskRB,
                                          SkColor color, int w, int h) {
         D32_A8_Opaque_Color_neon<true>(dst, dstRB, mask, maskRB, color, w, h);
     }

     // As above, but made slightly simpler by requiring that color is opaque.
     static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
                                         const SkAlpha* mask, size_t maskRB,
                                         SkColor color, int w, int h) {
         D32_A8_Opaque_Color_neon<false>(dst, dstRB, mask, maskRB, color, w, h);
     }

     // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
     static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
                                        const SkAlpha* maskPtr, size_t maskRB,
                                        int width, int height) {
         SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
         const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;

         maskRB -= width;
         dstRB -= (width << 2);
         do {
             int w = width;
             while (w >= 8) {
                 uint8x8_t vmask = vld1_u8(mask);
                 uint16x8_t vscale = vsubw_u8(vdupq_n_u16(256), vmask);
                 uint8x8x4_t vdevice = vld4_u8((uint8_t*)device);

                 vdevice = SkAlphaMulQ_neon8(vdevice, vscale);
                 vdevice.val[NEON_A] += vmask;

                 vst4_u8((uint8_t*)device, vdevice);

                 mask += 8;
                 device += 8;
                 w -= 8;
             }
             while (w-- > 0) {
                 unsigned aa = *mask++;
                 *device = (aa << SK_A32_SHIFT)
                             + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
                 device += 1;
             }
             device = (uint32_t*)((char*)device + dstRB);
             mask += maskRB;
         } while (--height != 0);
     }

 #else
     static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
                                          const SkAlpha* mask, size_t maskRB,
                                          SkColor color, int w, int h) {
         auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
         auto fn = [&](const Sk4px& d, const Sk4px& aa) {
             //  = (s + d(1-sa))aa + d(1-aa)
             //  = s*aa + d(1-sa*aa)
             auto left  = s.approxMulDiv255(aa),
                  right = d.approxMulDiv255(left.alphas().inv());
             return left + right;  // This does not overflow (exhaustively checked).
         };
         while (h --> 0) {
             Sk4px::MapDstAlpha(w, dst, mask, fn);
             dst  +=  dstRB / sizeof(*dst);
             mask += maskRB / sizeof(*mask);
         }
     }

     // As above, but made slightly simpler by requiring that color is opaque.
     static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
                                         const SkAlpha* mask, size_t maskRB,
                                         SkColor color, int w, int h) {
         SkASSERT(SkColorGetA(color) == 0xFF);
         auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
         auto fn = [&](const Sk4px& d, const Sk4px& aa) {
             //  = (s + d(1-sa))aa + d(1-aa)
             //  = s*aa + d(1-sa*aa)
             //   ~~~>
             //  = s*aa + d(1-aa)
             return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv());
         };
         while (h --> 0) {
             Sk4px::MapDstAlpha(w, dst, mask, fn);
             dst  +=  dstRB / sizeof(*dst);
             mask += maskRB / sizeof(*mask);
         }
     }

     // Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
     static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
                                        const SkAlpha* mask, size_t maskRB,
                                        int w, int h) {
         auto fn = [](const Sk4px& d, const Sk4px& aa) {
             //   = (s + d(1-sa))aa + d(1-aa)
             //   = s*aa + d(1-sa*aa)
             //   ~~~>
             // a = 1*aa + d(1-1*aa) = aa + d(1-aa)
             // c = 0*aa + d(1-1*aa) =      d(1-aa)
             return Sk4px(Sk16b(aa) & Sk16b(0,0,0,255, 0,0,0,255, 0,0,0,255, 0,0,0,255))
                  + d.approxMulDiv255(aa.inv());
         };
         while (h --> 0) {
             Sk4px::MapDstAlpha(w, dst, mask, fn);
             dst  +=  dstRB / sizeof(*dst);
             mask += maskRB / sizeof(*mask);
         }
     }
 #endif

 /*not static*/ inline void blit_mask_d32_a8(SkPMColor* dst, size_t dstRB,
                                             const SkAlpha* mask, size_t maskRB,
                                             SkColor color, int w, int h) {
     if (color == SK_ColorBLACK) {
         blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h);
     } else if (SkColorGetA(color) == 0xFF) {
         blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h);
     } else {
         blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h);
     }
 }

 }  // SK_OPTS_NS

 #endif//SkBlitMask_opts_DEFINED
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#ifndef SkBlitMask_opts_DEFINED
	#define SkBlitMask_opts_DEFINED

	#include "src/core/Sk4px.h"

	namespace SK_OPTS_NS {

	#if defined(SK_ARM_HAS_NEON)
	// The Sk4px versions below will work fine with NEON, but we have had many indications
	// that it doesn't perform as well as this NEON-specific code. TODO(mtklein): why?

	#define NEON_A (SK_A32_SHIFT / 8)
	#define NEON_R (SK_R32_SHIFT / 8)
	#define NEON_G (SK_G32_SHIFT / 8)
	#define NEON_B (SK_B32_SHIFT / 8)

	static inline uint16x8_t SkAlpha255To256_neon8(uint8x8_t alpha) {
	return vaddw_u8(vdupq_n_u16(1), alpha);
	}

	static inline uint8x8_t SkAlphaMul_neon8(uint8x8_t color, uint16x8_t scale) {
	return vshrn_n_u16(vmovl_u8(color) * scale, 8);
	}

	static inline uint8x8x4_t SkAlphaMulQ_neon8(uint8x8x4_t color, uint16x8_t scale) {
	uint8x8x4_t ret;

	ret.val[0] = SkAlphaMul_neon8(color.val[0], scale);
	ret.val[1] = SkAlphaMul_neon8(color.val[1], scale);
	ret.val[2] = SkAlphaMul_neon8(color.val[2], scale);
	ret.val[3] = SkAlphaMul_neon8(color.val[3], scale);

	return ret;
	}


	template <bool isColor>
	static void D32_A8_Opaque_Color_neon(void* SK_RESTRICT dst, size_t dstRB,
	const void* SK_RESTRICT maskPtr, size_t maskRB,
	SkColor color, int width, int height) {
	SkPMColor pmc = SkPreMultiplyColor(color);
	SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
	const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
	uint8x8x4_t vpmc;

	maskRB -= width;
	dstRB -= (width << 2);

	if (width >= 8) {
	vpmc.val[NEON_A] = vdup_n_u8(SkGetPackedA32(pmc));
	vpmc.val[NEON_R] = vdup_n_u8(SkGetPackedR32(pmc));
	vpmc.val[NEON_G] = vdup_n_u8(SkGetPackedG32(pmc));
	vpmc.val[NEON_B] = vdup_n_u8(SkGetPackedB32(pmc));
	}
	do {
	int w = width;
	while (w >= 8) {
	uint8x8_t vmask = vld1_u8(mask);
	uint16x8_t vscale, vmask256 = SkAlpha255To256_neon8(vmask);
	if (isColor) {
	vscale = vsubw_u8(vdupq_n_u16(256),
	SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256));
	} else {
	vscale = vsubw_u8(vdupq_n_u16(256), vmask);
	}
	uint8x8x4_t vdev = vld4_u8((uint8_t*)device);

	vdev.val[NEON_A] = SkAlphaMul_neon8(vpmc.val[NEON_A], vmask256)
	+ SkAlphaMul_neon8(vdev.val[NEON_A], vscale);
	vdev.val[NEON_R] = SkAlphaMul_neon8(vpmc.val[NEON_R], vmask256)
	+ SkAlphaMul_neon8(vdev.val[NEON_R], vscale);
	vdev.val[NEON_G] = SkAlphaMul_neon8(vpmc.val[NEON_G], vmask256)
	+ SkAlphaMul_neon8(vdev.val[NEON_G], vscale);
	vdev.val[NEON_B] = SkAlphaMul_neon8(vpmc.val[NEON_B], vmask256)
	+ SkAlphaMul_neon8(vdev.val[NEON_B], vscale);

	vst4_u8((uint8_t*)device, vdev);

	mask += 8;
	device += 8;
	w -= 8;
	}

	while (w--) {
	unsigned aa = *mask++;
	if (isColor) {
	device = SkBlendARGB32(pmc, device, aa);
	} else {
	*device = SkAlphaMulQ(pmc, SkAlpha255To256(aa))
	+ SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
	}
	device += 1;
	}

	device = (uint32_t)((char)device + dstRB);
	mask += maskRB;

	} while (--height != 0);
	}

	static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
	const SkAlpha* mask, size_t maskRB,
	SkColor color, int w, int h) {
	D32_A8_Opaque_Color_neon<true>(dst, dstRB, mask, maskRB, color, w, h);
	}

	// As above, but made slightly simpler by requiring that color is opaque.
	static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
	const SkAlpha* mask, size_t maskRB,
	SkColor color, int w, int h) {
	D32_A8_Opaque_Color_neon<false>(dst, dstRB, mask, maskRB, color, w, h);
	}

	// Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
	static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
	const SkAlpha* maskPtr, size_t maskRB,
	int width, int height) {
	SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
	const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;

	maskRB -= width;
	dstRB -= (width << 2);
	do {
	int w = width;
	while (w >= 8) {
	uint8x8_t vmask = vld1_u8(mask);
	uint16x8_t vscale = vsubw_u8(vdupq_n_u16(256), vmask);
	uint8x8x4_t vdevice = vld4_u8((uint8_t*)device);

	vdevice = SkAlphaMulQ_neon8(vdevice, vscale);
	vdevice.val[NEON_A] += vmask;

	vst4_u8((uint8_t*)device, vdevice);

	mask += 8;
	device += 8;
	w -= 8;
	}
	while (w-- > 0) {
	unsigned aa = *mask++;
	*device = (aa << SK_A32_SHIFT)
	+ SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
	device += 1;
	}
	device = (uint32_t)((char)device + dstRB);
	mask += maskRB;
	} while (--height != 0);
	}

	#else
	static void blit_mask_d32_a8_general(SkPMColor* dst, size_t dstRB,
	const SkAlpha* mask, size_t maskRB,
	SkColor color, int w, int h) {
	auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
	auto fn = [&](const Sk4px& d, const Sk4px& aa) {
	// = (s + d(1-sa))aa + d(1-aa)
	// = saa + d(1-saaa)
	auto left = s.approxMulDiv255(aa),
	right = d.approxMulDiv255(left.alphas().inv());
	return left + right; // This does not overflow (exhaustively checked).
	};
	while (h --> 0) {
	Sk4px::MapDstAlpha(w, dst, mask, fn);
	dst += dstRB / sizeof(*dst);
	mask += maskRB / sizeof(*mask);
	}
	}

	// As above, but made slightly simpler by requiring that color is opaque.
	static void blit_mask_d32_a8_opaque(SkPMColor* dst, size_t dstRB,
	const SkAlpha* mask, size_t maskRB,
	SkColor color, int w, int h) {
	SkASSERT(SkColorGetA(color) == 0xFF);
	auto s = Sk4px::DupPMColor(SkPreMultiplyColor(color));
	auto fn = [&](const Sk4px& d, const Sk4px& aa) {
	// = (s + d(1-sa))aa + d(1-aa)
	// = saa + d(1-saaa)
	// ~~~>
	// = s*aa + d(1-aa)
	return s.approxMulDiv255(aa) + d.approxMulDiv255(aa.inv());
	};
	while (h --> 0) {
	Sk4px::MapDstAlpha(w, dst, mask, fn);
	dst += dstRB / sizeof(*dst);
	mask += maskRB / sizeof(*mask);
	}
	}

	// Same as _opaque, but assumes color == SK_ColorBLACK, a very common and even simpler case.
	static void blit_mask_d32_a8_black(SkPMColor* dst, size_t dstRB,
	const SkAlpha* mask, size_t maskRB,
	int w, int h) {
	auto fn = [](const Sk4px& d, const Sk4px& aa) {
	// = (s + d(1-sa))aa + d(1-aa)
	// = saa + d(1-saaa)
	// ~~~>
	// a = 1aa + d(1-1aa) = aa + d(1-aa)
	// c = 0aa + d(1-1aa) = d(1-aa)
	return Sk4px(Sk16b(aa) & Sk16b(0,0,0,255, 0,0,0,255, 0,0,0,255, 0,0,0,255))
	+ d.approxMulDiv255(aa.inv());
	};
	while (h --> 0) {
	Sk4px::MapDstAlpha(w, dst, mask, fn);
	dst += dstRB / sizeof(*dst);
	mask += maskRB / sizeof(*mask);
	}
	}
	#endif

	/not static/ inline void blit_mask_d32_a8(SkPMColor* dst, size_t dstRB,
	const SkAlpha* mask, size_t maskRB,
	SkColor color, int w, int h) {
	if (color == SK_ColorBLACK) {
	blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h);
	} else if (SkColorGetA(color) == 0xFF) {
	blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h);
	} else {
	blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h);
	}
	}

	} // SK_OPTS_NS

	#endif//SkBlitMask_opts_DEFINED