ARM Skia NEON patches - 32 - Xfermode: 1-pixel NEON 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"
@@ skipping 106 matching lines @@
 //  kSrcOut_Mode,   //!< [Sa * (1 - Da), Sc * (1 - Da)]
 static SkPMColor srcout_modeproc(SkPMColor src, SkPMColor dst) {
     return SkAlphaMulQ(src, SkAlpha255To256(255 - SkGetPackedA32(dst)));
 }
 
 //  kDstOut_Mode,   //!< [Da * (1 - Sa), Dc * (1 - Sa)]
 static SkPMColor dstout_modeproc(SkPMColor src, SkPMColor dst) {
     return SkAlphaMulQ(dst, SkAlpha255To256(255 - SkGetPackedA32(src)));
 }
 
+#if !SK_ARM_NEON_IS_ALWAYS

[djsollen, 2013/12/05 15:11:36]

I would like to remove this.  I think we could do this similar to how we do
other platform specific optimizations.  I suggest that prior to pulling the proc
from gProcCoeffs we call a platformProc funtion that we define in
SkXfermode_opts_* which returns a ProcCoeff if we have a platform specific one
available. If none is found then we default to the standard lookup.

We only lookup the proc once so having it go through an extra function call
should be fine.

[kevin.petit.not.used.account, 2013/12/05 17:02:46]

Done. I've used a factory approach, like suggested. It seems a bit overkill but
I couldn't find a simpler (and clean) way.

 //  kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]
 static SkPMColor srcatop_modeproc(SkPMColor src, SkPMColor dst) {
     unsigned sa = SkGetPackedA32(src);
     unsigned da = SkGetPackedA32(dst);
     unsigned isa = 255 - sa;
 
     return SkPackARGB32(da,
                         SkAlphaMulAlpha(da, SkGetPackedR32(src)) +
                             SkAlphaMulAlpha(isa, SkGetPackedR32(dst)),
                         SkAlphaMulAlpha(da, SkGetPackedG32(src)) +
@@ skipping 45 matching lines @@
 }
 
 // kModulate_Mode
 static SkPMColor modulate_modeproc(SkPMColor src, SkPMColor dst) {
     int a = SkAlphaMulAlpha(SkGetPackedA32(src), SkGetPackedA32(dst));
     int r = SkAlphaMulAlpha(SkGetPackedR32(src), SkGetPackedR32(dst));
     int g = SkAlphaMulAlpha(SkGetPackedG32(src), SkGetPackedG32(dst));
     int b = SkAlphaMulAlpha(SkGetPackedB32(src), SkGetPackedB32(dst));
     return SkPackARGB32(a, r, g, b);
 }
+#endif
 
 static inline int srcover_byte(int a, int b) {
     return a + b - SkAlphaMulAlpha(a, b);
 }
 
 // kMultiply_Mode
 // B(Cb, Cs) = Cb x Cs
 // multiply uses its own version of blendfunc_byte because sa and da are not needed
 static int blendfunc_multiply_byte(int sc, int dc, int sa, int da) {
     return clamp_div255round(sc * (255 - da)  + dc * (255 - sa)  + sc * dc);
@@ skipping 422 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);
 }
 
 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,                       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 },
+    { SK_ARM_NEON_WRAP(srcatop_modeproc),   SkXfermode::kDA_Coeff,      SkXfermode::kISA_Coeff },

[djsollen, 2013/12/05 14:17:05]

this is going to be problematic on chrome as their sandbox does not have access
to whether or not the device has neon so that info is populated as part of the
startup process.  In that case you won't get the neon procs even it the device
has them.

[kevin.petit.not.used.account, 2013/12/05 17:02:46]

I thought that would be problematic in a way or another.

+    { SK_ARM_NEON_WRAP(dstatop_modeproc),   SkXfermode::kIDA_Coeff,     SkXfermode::kSA_Coeff },
+    { SK_ARM_NEON_WRAP(xor_modeproc),       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 },
+    { SK_ARM_NEON_WRAP(plus_modeproc),      SkXfermode::kOne_Coeff,     SkXfermode::kOne_Coeff },
+    { SK_ARM_NEON_WRAP(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 },
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkXfermode::asCoeff(Coeff* src, Coeff* dst) const {
     return false;
 }
 
 bool SkXfermode::asMode(Mode* mode) const {
     return false;
@@ skipping 1289 matching lines @@
 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)
 #if !SK_ARM_NEON_IS_NONE
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkNEONProcCoeffXfermode)
 #endif
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END