ARM Skia NEON patches - 28 - Xfermode: SIMD modeprocs

src/core/SkXfermode.cpp

 
 /*
  * Copyright 2006 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 "SkXfermode.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkMathPriv.h"
 #include "SkString.h"
+#include "SkXfermode_opts.h"
+#include "SkUtilsArm.h"
 
 SK_DEFINE_INST_COUNT(SkXfermode)
 
 #define SkAlphaMulAlpha(a, b)   SkMulDiv255Round(a, b)
 
 #if 0
 // idea for higher precision blends in xfer procs (and slightly faster)
 // see DstATop as a probable caller
 static U8CPU mulmuldiv255round(U8CPU a, U8CPU b, U8CPU c, U8CPU d) {
     SkASSERT(a <= 255);
@@ skipping 602 matching lines @@
     int a = srcover_byte(sa, da);
     int r = blendfunc_nonsep_byte(sr, dr, sa, da, Dr);
     int g = blendfunc_nonsep_byte(sg, dg, sa, da, Dg);
     int b = blendfunc_nonsep_byte(sb, db, sa, da, Db);
     return SkPackARGB32(a, r, g, b);
 }
 
 
 struct ProcCoeff {
     SkXfermodeProc      fProc;
+    SkXfermodeProcSIMD  fProcSIMD;

[djsollen, 2013/10/03 16:38:29]

instead of defining this at compile time why not have SkXfermode_opts.h
implement a function like this...

typedef void (*SkXfermodeProcSIMD)(SkPMColor dst[], const SkPMColor src[], int
count, const SkAlpha aa[]);

// type is an enum consisting of 32, 16, or A8 entries
SkXfermodeProcSIMD SkPlatformXfermodeProcSIMDFactory(unsigned type,
SkXferMode::Mode mode)

That way for clients like Chrome where it is not known at compile time if NEON
is available we can still benefit from these optimizations.

     SkXfermode::Coeff   fSC;
     SkXfermode::Coeff   fDC;
 };
 
 #define CANNOT_USE_COEFF    SkXfermode::Coeff(-1)
 
 static const ProcCoeff gProcCoeffs[] = {
-    { clear_modeproc,   SkXfermode::kZero_Coeff,    SkXfermode::kZero_Coeff },
-    { src_modeproc,     SkXfermode::kOne_Coeff,     SkXfermode::kZero_Coeff },
-    { dst_modeproc,     SkXfermode::kZero_Coeff,    SkXfermode::kOne_Coeff },
-    { srcover_modeproc, SkXfermode::kOne_Coeff,     SkXfermode::kISA_Coeff },
-    { dstover_modeproc, SkXfermode::kIDA_Coeff,     SkXfermode::kOne_Coeff },
-    { srcin_modeproc,   SkXfermode::kDA_Coeff,      SkXfermode::kZero_Coeff },
-    { dstin_modeproc,   SkXfermode::kZero_Coeff,    SkXfermode::kSA_Coeff },
-    { srcout_modeproc,  SkXfermode::kIDA_Coeff,     SkXfermode::kZero_Coeff },
-    { dstout_modeproc,  SkXfermode::kZero_Coeff,    SkXfermode::kISA_Coeff },
-    { srcatop_modeproc, SkXfermode::kDA_Coeff,      SkXfermode::kISA_Coeff },
-    { dstatop_modeproc, SkXfermode::kIDA_Coeff,     SkXfermode::kSA_Coeff },
-    { xor_modeproc,     SkXfermode::kIDA_Coeff,     SkXfermode::kISA_Coeff },
+    { clear_modeproc,     SK_XMPSIMD_CLEAR,     SkXfermode::kZero_Coeff,    SkXfermode::kZero_Coeff },
+    { src_modeproc,       SK_XMPSIMD_SRC,       SkXfermode::kOne_Coeff,     SkXfermode::kZero_Coeff },
+    { dst_modeproc,       SK_XMPSIMD_DST,       SkXfermode::kZero_Coeff,    SkXfermode::kOne_Coeff },
+    { srcover_modeproc,   SK_XMPSIMD_SRCOVER,   SkXfermode::kOne_Coeff,     SkXfermode::kISA_Coeff },
+    { dstover_modeproc,   SK_XMPSIMD_DSTOVER,   SkXfermode::kIDA_Coeff,     SkXfermode::kOne_Coeff },
+    { srcin_modeproc,     SK_XMPSIMD_SRCIN,     SkXfermode::kDA_Coeff,      SkXfermode::kZero_Coeff },
+    { dstin_modeproc,     SK_XMPSIMD_DSTIN,     SkXfermode::kZero_Coeff,    SkXfermode::kSA_Coeff },
+    { srcout_modeproc,    SK_XMPSIMD_SRCOUT,    SkXfermode::kIDA_Coeff,     SkXfermode::kZero_Coeff },
+    { dstout_modeproc,    SK_XMPSIMD_DSTOUT,    SkXfermode::kZero_Coeff,    SkXfermode::kISA_Coeff },
+    { srcatop_modeproc,   SK_XMPSIMD_SRCATOP,   SkXfermode::kDA_Coeff,      SkXfermode::kISA_Coeff },
+    { dstatop_modeproc,   SK_XMPSIMD_DSTATOP,   SkXfermode::kIDA_Coeff,     SkXfermode::kSA_Coeff },
+    { xor_modeproc,       SK_XMPSIMD_XOR,       SkXfermode::kIDA_Coeff,     SkXfermode::kISA_Coeff },
 
-    { plus_modeproc,    SkXfermode::kOne_Coeff,     SkXfermode::kOne_Coeff },
-    { modulate_modeproc,SkXfermode::kZero_Coeff,    SkXfermode::kSC_Coeff },
-    { screen_modeproc,  SkXfermode::kOne_Coeff,     SkXfermode::kISC_Coeff },
-    { overlay_modeproc,     CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { darken_modeproc,      CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { lighten_modeproc,     CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { colordodge_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { colorburn_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { hardlight_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { softlight_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { difference_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { exclusion_modeproc,   CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { multiply_modeproc,    CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { hue_modeproc,         CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { saturation_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { color_modeproc,       CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
-    { luminosity_modeproc,  CANNOT_USE_COEFF,       CANNOT_USE_COEFF },
+    { plus_modeproc,      SK_XMPSIMD_PLUS,      SkXfermode::kOne_Coeff,     SkXfermode::kOne_Coeff },
+    { modulate_modeproc,  SK_XMPSIMD_MODULATE,  SkXfermode::kZero_Coeff,    SkXfermode::kSC_Coeff },
+    { screen_modeproc,    SK_XMPSIMD_SCREEN,    SkXfermode::kOne_Coeff,     SkXfermode::kISC_Coeff },
+    { overlay_modeproc,   SK_XMPSIMD_OVERLAY,   CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { darken_modeproc,    SK_XMPSIMD_DARKEN,    CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { lighten_modeproc,   SK_XMPSIMD_LIGHTEN,   CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { colordodge_modeproc,SK_XMPSIMD_COLORDODGE,CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { colorburn_modeproc, SK_XMPSIMD_COLORBURN, CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { hardlight_modeproc, SK_XMPSIMD_HARDLIGHT, CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { softlight_modeproc, SK_XMPSIMD_SOFTLIGHT, CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { difference_modeproc,SK_XMPSIMD_DIFFERENCE,CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { exclusion_modeproc, SK_XMPSIMD_EXCLUSION, CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { multiply_modeproc,  SK_XMPSIMD_MULTIPLY,  CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { hue_modeproc,       NULL,                 CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { saturation_modeproc,NULL,                 CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { color_modeproc,     NULL,                 CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
+    { luminosity_modeproc,NULL,                 CANNOT_USE_COEFF,           CANNOT_USE_COEFF },
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkXfermode::asCoeff(Coeff* src, Coeff* dst) const {
     return false;
 }
 
 bool SkXfermode::asMode(Mode* mode) const {
     return false;
@@ skipping 100 matching lines @@
 
 void SkProcXfermode::xfer32(SkPMColor* SK_RESTRICT dst,
                             const SkPMColor* SK_RESTRICT src, int count,
                             const SkAlpha* SK_RESTRICT aa) const {
     SkASSERT(dst && src && count >= 0);
 
     SkXfermodeProc proc = fProc;
 
     if (NULL != proc) {
         if (NULL == aa) {
-            for (int i = count - 1; i >= 0; --i) {
-                dst[i] = proc(src[i], dst[i]);
+#if SK_ARM_NEON_IS_ALWAYS

[djsollen, 2013/10/03 16:38:29]

if you do the above approach this code could be put in a static inline function
inside SkXfermode_opts_arm_neon.cpp

[reed1, 2013/10/04 13:39:19]

Looks like we could also return a different subclass when we detect the SIMD
proc at factory time. Would make this more readable.

+            SkXfermodeProcSIMD procSIMD = fProcSIMD;
+            if (procSIMD != NULL) {
+                // Unrolled NEON code
+                while (count >= 8) {
+                    uint8x8x4_t vsrc, vdst, vres;
+
+                    asm volatile (
+                        "vld4.u8    %h[vsrc], [%[src]]!  \t\n"
+                        "vld4.u8    %h[vdst], [%[dst]]   \t\n"
+                        : [vsrc] "=w" (vsrc), [vdst] "=w" (vdst)
+                        : [src] "r" (src), [dst] "r" (dst)
+                        :
+                    );
+
+                    vres = procSIMD(vsrc, vdst);
+
+                    vst4_u8((uint8_t*)dst, vres);
+
+                    count -= 8;
+                    dst += 8;
+                }
+                // Leftovers
+                for (int i = 0; i < count; i++) {
+                    dst[i] = proc(src[i], dst[i]);
+                }
+            } else
+#endif
+            {
+                for (int i = count - 1; i >= 0; --i) {
+                    dst[i] = proc(src[i], dst[i]);
+                }
             }
         } else {
             for (int i = count - 1; i >= 0; --i) {
                 unsigned a = aa[i];
                 if (0 != a) {
                     SkPMColor dstC = dst[i];
                     SkPMColor C = proc(src[i], dstC);
                     if (a != 0xFF) {
                         C = SkFourByteInterp(C, dstC, a);
                     }
@@ skipping 59 matching lines @@
                     dst[i] = SkToU8(A);
                 }
             }
         }
     }
 }
 
 SkProcXfermode::SkProcXfermode(SkFlattenableReadBuffer& buffer)
         : SkXfermode(buffer) {
     fProc = NULL;
+    fProcSIMD = NULL;
     if (!buffer.isCrossProcess()) {
         fProc = (SkXfermodeProc)buffer.readFunctionPtr();
+        fProcSIMD = (SkXfermodeProcSIMD)buffer.readFunctionPtr();
     }
 }
 
 void SkProcXfermode::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     if (!buffer.isCrossProcess()) {
         buffer.writeFunctionPtr((void*)fProc);
+        buffer.writeFunctionPtr((void*)fProcSIMD);
     }
 }
 
 #ifdef SK_DEVELOPER
 void SkProcXfermode::toString(SkString* str) const {
-    str->appendf("SkProcXfermode: %p", fProc);
+    str->appendf("SkProcXfermode: fProc = %p, fProcSIMD = %p", fProc, fProcSIMD);
 }
 #endif
 
 //////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 #include "GrEffect.h"
 #include "GrEffectUnitTest.h"
 #include "GrTBackendEffectFactory.h"
@@ skipping 470 matching lines @@
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkProcCoeffXfermode : public SkProcXfermode {
 public:
     SkProcCoeffXfermode(const ProcCoeff& rec, Mode mode)
-            : INHERITED(rec.fProc) {
+            : INHERITED(rec.fProc, rec.fProcSIMD) {
         fMode = mode;
         // these may be valid, or may be CANNOT_USE_COEFF
         fSrcCoeff = rec.fSC;
         fDstCoeff = rec.fDC;
     }
 
     virtual bool asMode(Mode* mode) const SK_OVERRIDE {
         if (mode) {
             *mode = fMode;
         }
@@ skipping 39 matching lines @@
 
 protected:
     SkProcCoeffXfermode(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
         fMode = (SkXfermode::Mode)buffer.read32();
 
         const ProcCoeff& rec = gProcCoeffs[fMode];
         // these may be valid, or may be CANNOT_USE_COEFF
         fSrcCoeff = rec.fSC;
         fDstCoeff = rec.fDC;
         // now update our function-ptr in the super class
-        this->INHERITED::setProc(rec.fProc);
+        this->INHERITED::setProcs(rec.fProc, rec.fProcSIMD);
     }
 
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
         this->INHERITED::flatten(buffer);
         buffer.write32(fMode);
     }
 
 private:
     Mode    fMode;
     Coeff   fSrcCoeff, fDstCoeff;
@@ skipping 512 matching lines @@
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkClearXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSrcXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstInXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDstOutXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END