ARM Skia NEON patches - 38 - arm64 8888 blitters

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"
 #include "SkBlitRow.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkMathPriv.h"
 #include "SkUtils.h"
 
 #include "SkColor_opts_neon.h"
 #include <arm_neon.h>
 
+#ifdef SK_CPU_ARM
 void S32_D565_Opaque_neon(uint16_t* SK_RESTRICT dst,
                            const SkPMColor* SK_RESTRICT src, int count,
                            U8CPU alpha, int /*x*/, int /*y*/) {
     SkASSERT(255 == alpha);
 
     while (count >= 8) {
         uint8x8x4_t vsrc;
         uint16x8_t vdst;
 
         // Load
@@ skipping 538 matching lines @@
             sb = SkDITHER_B32To565(sb, dither);
 
             uint16_t d = *dst;
             *dst++ = SkPackRGB16(SkAlphaBlend(sr, SkGetPackedR16(d), scale),
                                  SkAlphaBlend(sg, SkGetPackedG16(d), scale),
                                  SkAlphaBlend(sb, SkGetPackedB16(d), scale));
             DITHER_INC_X(x);
         } while (--count != 0);
     }
 }
+#endif
 
 void S32A_Opaque_BlitRow32_neon(SkPMColor* SK_RESTRICT dst,
                                 const SkPMColor* SK_RESTRICT src,
                                 int count, U8CPU alpha) {
 
     SkASSERT(255 == alpha);
     if (count > 0) {
 
 
     uint8x8_t alpha_mask;
@@ skipping 324 matching lines @@
         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));
         vres = vshrn_n_u16(vdst_wide, 8) + vshrn_n_u16(vsrc_wide, 8);
 
         // Store
         vst1_lane_u32(dst, vreinterpret_u32_u8(vres), 0);
     }
 }
 
+#ifdef SK_CPU_ARM
 void S32A_Blend_BlitRow32_neon(SkPMColor* SK_RESTRICT dst,
                          const SkPMColor* SK_RESTRICT src,
                          int count, U8CPU alpha) {
 
     SkASSERT(255 >= alpha);
 
     if (count <= 0) {
         return;
     }
 
@@ skipping 427 matching lines @@
             SkPMColor c = *src++;
             SkPMColorAssert(c);
             SkASSERT(SkGetPackedA32(c) == 255);
 
             unsigned dither = DITHER_VALUE(x);
             *dst++ = SkDitherRGB32To565(c, dither);
             DITHER_INC_X(x);
         } while (--count != 0);
     }
 }
+#endif
 
 void Color32_arm_neon(SkPMColor* dst, const SkPMColor* src, int count,
                       SkPMColor color) {
     if (count <= 0) {
         return;
     }
 
     if (0 == color) {
         if (src != dst) {
             memcpy(dst, src, count * sizeof(SkPMColor));
@@ skipping 15 matching lines @@
 
         vcolor = vdupq_n_u32(color);
 
         // scale numerical interval [0-255], so load as 8 bits
         vscale = vdup_n_u8(scale);
 
         do {
             // load src color, 8 pixels, 4 64 bit registers
             // (and increment src).
             uint32x2x4_t vsrc;
-#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
+#if defined(SK_CPU_ARM) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
             asm (
                 "vld1.32    %h[vsrc], [%[src]]!"
                 : [vsrc] "=w" (vsrc), [src] "+r" (src)
                 : :
             );
-#else // (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
+#else // 64bit targets and Clang
             vsrc.val[0] = vld1_u32(src);
             vsrc.val[1] = vld1_u32(src+2);
             vsrc.val[2] = vld1_u32(src+4);
             vsrc.val[3] = vld1_u32(src+6);
             src += 8;
 #endif
 
             // multiply long by scale, 64 bits at a time,
             // destination into a 128 bit register.
             uint16x8x4_t vtmp;
@@ skipping 15 matching lines @@
 
             // adding back the color, using 128 bit registers.
             uint32x4x2_t vdst;
             vdst.val[0] = vreinterpretq_u32_u8(vres.val[0] +
                                                vreinterpretq_u8_u32(vcolor));
             vdst.val[1] = vreinterpretq_u32_u8(vres.val[1] +
                                                vreinterpretq_u8_u32(vcolor));
 
             // store back the 8 calculated pixels (2 128 bit
             // registers), and increment dst.
-#if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
+#if defined(SK_CPU_ARM) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6)))
             asm (
                 "vst1.32    %h[vdst], [%[dst]]!"
                 : [dst] "+r" (dst)
                 : [vdst] "w" (vdst)
                 : "memory"
             );
-#else // (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 6))
+#else // 64bit targets and Clang
             vst1q_u32(dst, vdst.val[0]);
             vst1q_u32(dst+4, vdst.val[1]);
             dst += 8;
 #endif
             count -= 8;
 
         } while (count >= 8);
     }
 
     while (count > 0) {
         *dst = color + SkAlphaMulQ(*src, scale);
         src += 1;
         dst += 1;
         count--;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 const SkBlitRow::Proc sk_blitrow_platform_565_procs_arm_neon[] = {
+#ifdef SK_CPU_ARM
     // no dither
     S32_D565_Opaque_neon,
     S32_D565_Blend_neon,
     S32A_D565_Opaque_neon,
     S32A_D565_Blend_neon,
 
     // dither
     S32_D565_Opaque_Dither_neon,
     S32_D565_Blend_Dither_neon,
     S32A_D565_Opaque_Dither_neon,
     NULL,   // S32A_D565_Blend_Dither
+#else
+    NULL, NULL, NULL, NULL,
+    NULL, NULL, NULL, NULL
+#endif
 };
 
 const SkBlitRow::Proc32 sk_blitrow_platform_32_procs_arm_neon[] = {
     NULL,   // S32_Opaque,
     S32_Blend_BlitRow32_neon,        // S32_Blend,
     /*
      * We have two choices for S32A_Opaque procs. The one reads the src alpha
      * value and attempts to optimize accordingly.  The optimization is
      * sensitive to the source content and is not a win in all cases. For
      * example, if there are a lot of transitions between the alpha states,
      * the performance will almost certainly be worse.  However, for many
      * common cases the performance is equivalent or better than the standard
      * case where we do not inspect the src alpha.
      */
 #if SK_A32_SHIFT == 24
     // This proc assumes the alpha value occupies bits 24-32 of each SkPMColor
     S32A_Opaque_BlitRow32_neon_src_alpha,   // S32A_Opaque,
 #else
     S32A_Opaque_BlitRow32_neon,     // S32A_Opaque,
 #endif
+#ifdef SK_CPU_ARM
     S32A_Blend_BlitRow32_neon        // S32A_Blend
+#else
+    NULL
+#endif
 };