experimental speedup some xfermodes with Sk4f

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 "SkXfermode_opts_SSE2.h"
 #include "SkXfermode_proccoeff.h"
 #include "SkColorPriv.h"
 #include "SkLazyPtr.h"
 #include "SkMathPriv.h"
+#include "SkPMFloat.h"
 #include "SkReadBuffer.h"
 #include "SkString.h"
 #include "SkUtilsArm.h"
 #include "SkWriteBuffer.h"
 
 #if !SK_ARM_NEON_IS_NONE
 #include "SkXfermode_opts_arm_neon.h"
 #endif
 
 #define SkAlphaMulAlpha(a, b)   SkMulDiv255Round(a, b)
@@ skipping 1154 matching lines @@
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkDstInXfermode::toString(SkString* str) const {
     this->INHERITED::toString(str);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static const float gInv255 = 0.0039215683f; //  (1.0f / 255) - ULP == SkBits2Float(0x3B808080)
+
+static Sk4f ramp(const Sk4f& v0, const Sk4f& v1, const Sk4f& t) {
+    return v0 + (v1 - v0) * t;
+}
+
+//  kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]

[mtklein, 2015/04/01 19:33:55]

I suspect that this formulation of src-atop has tricked us into doing more work
than we need to.

If I'm thinking right, Da == Sa*Da + (1-Sa)*Da.  The formula for color
components can also be applied to alphas?

If that's true, res == res2.

It's looking like another ~10% speedup to just do this, with no GM diffs against
your version:
  SkPMFloat res = d4 + (s4 * Sk4f(dst.a()) - d4*Sk4f(src.a())) * inv255;
  SkASSERT(res.isValid());
  return res;

+static inline SkPMFloat srcatop(const SkPMFloat& src, const SkPMFloat& dst) {
+    const Sk4f inv255(gInv255);
+    Sk4f s4 = src;
+    Sk4f d4 = dst;
+    SkPMFloat res = d4 + (s4 * Sk4f(dst.a()) - d4 * Sk4f(src.a())) * inv255;
+    SkPMFloat res2 = SkPMFloat::FromARGB(dst.a(), res.r(), res.g(), res.b());
+    SkASSERT(res2.isValid());
+    return res2;
+}
+
+class SkSrcATopXfermode : public SkProcCoeffXfermode {
+public:
+    static SkXfermode* Create(const ProcCoeff& rec) {
+        return SkNEW_ARGS(SkSrcATopXfermode, (rec));
+    }
+    
+    void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
+        if (NULL == aa) {
+            while (n & 3) {
+                *dst = srcatop(SkPMFloat(*src++), SkPMFloat(*dst)).get();
+                dst++;
+                n -= 1;
+            }
+            n >>= 2;
+            for (int i = 0; i < n; ++i) {
+                SkPMFloat s0, s1, s2, s3;
+                SkPMFloat::From4PMColors(src, &s0, &s1, &s2, &s3);
+                SkPMFloat d0, d1, d2, d3;
+                SkPMFloat::From4PMColors(dst, &d0, &d1, &d2, &d3);
+                SkPMFloat::To4PMColors(srcatop(s0, d0), srcatop(s1, d1),
+                                       srcatop(s2, d2), srcatop(s3, d3), dst);
+                src += 4;
+                dst += 4;
+            }
+        } else {
+            for (int i = 0; i < n; ++i) {
+                SkPMFloat dstF(dst[i]);
+                SkPMFloat resF = srcatop(SkPMFloat(src[i]), dstF);
+                dst[i] = SkPMFloat(ramp(dstF, resF, Sk4f(aa[i] * gInv255))).get();
+            }
+        }
+    }
+    
+//    SK_TO_STRING_OVERRIDE()
+    
+private:
+    SkSrcATopXfermode(const ProcCoeff& rec) : SkProcCoeffXfermode(rec, kSrcATop_Mode) {}
+    
+    typedef SkProcCoeffXfermode INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
 class SkDstOutXfermode : public SkProcCoeffXfermode {
 public:
     static SkDstOutXfermode* Create(const ProcCoeff& rec) {
         return SkNEW_ARGS(SkDstOutXfermode, (rec));
     }
 
     void xfer32(SkPMColor*, const SkPMColor*, int, const SkAlpha*) const override;
 
     SK_TO_STRING_OVERRIDE()
 
@@ skipping 41 matching lines @@
 
     ProcCoeff rec = gProcCoeffs[mode];
     SkXfermodeProc pp = SkPlatformXfermodeProcFactory(mode);
     if (pp != NULL) {
         rec.fProc = pp;
     }
 
     SkXfermode* xfer = NULL;
     // check if we have a platform optim for that
     SkProcCoeffXfermode* xfm = SkPlatformXfermodeFactory(rec, mode);
+#if 1
+    xfm = NULL;
+#endif
     if (xfm != NULL) {
         xfer = xfm;
     } else {
         // All modes can in theory be represented by the ProcCoeff rec, since
         // it contains function ptrs. However, a few modes are both simple and
         // commonly used, so we call those out for their own subclasses here.
         switch (mode) {
             case SkXfermode::kClear_Mode:
                 xfer = SkClearXfermode::Create(rec);
                 break;
             case SkXfermode::kSrc_Mode:
                 xfer = SkSrcXfermode::Create(rec);
                 break;
             case SkXfermode::kSrcOver_Mode:
                 SkASSERT(false);    // should not land here
                 break;
             case SkXfermode::kDstIn_Mode:
                 xfer = SkDstInXfermode::Create(rec);
                 break;
             case SkXfermode::kDstOut_Mode:
                 xfer = SkDstOutXfermode::Create(rec);
                 break;
+            case SkXfermode::kSrcATop_Mode:
+                xfer = SkSrcATopXfermode::Create(rec);
+                break;
             default:
                 // no special-case, just rely in the rec and its function-ptrs
                 xfer = SkNEW_ARGS(SkProcCoeffXfermode, (rec, mode));
                 break;
         }
     }
     return xfer;
 }
 }  // namespace
 
@@ skipping 254 matching lines @@
         } else {
             proc16 = rec.fProc16_General;
         }
     }
     return proc16;
 }
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermode)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkProcCoeffXfermode)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END