simplify xfers

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"
@@ skipping 1183 matching lines @@
 }
 
 static Sk4f clamp_255(const Sk4f& value) {
     return Sk4f::Min(Sk4f(255), value);
 }
 
 static Sk4f clamp_0_255(const Sk4f& value) {
     return Sk4f::Max(Sk4f(0), Sk4f::Min(Sk4f(255), value));
 }
 
-// return a swizzle of a | rgb
-static Sk4f set_a_rgb(const Sk4f& a, const Sk4f& rgb) {
-    SkPMFloat pma = a;
-    SkPMFloat pmc = rgb;
-    return SkPMFloat(pma.a(), pmc.r(), pmc.g(), pmc.b());
-}
-
 /**
  *  Some modes can, due to very slight numerical error, generate "invalid" pmcolors...
  *
  *  e.g.
  *      alpha = 100.9999
  *      red   = 101
  *
  *  or
  *      alpha = 255.0001
  *
@@ skipping 87 matching lines @@
 
 struct Difference4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         Sk4f sa = Sk4f(src.a());
         Sk4f da = Sk4f(dst.a());
         Sk4f sc = src;
         Sk4f dc = dst;
         Sk4f min = Sk4f::Min(sc * da, dc * sa) * inv255;
         Sk4f ra = sc + dc - min;
-        return check_as_pmfloat(set_a_rgb(ra, ra - min));
+        return check_as_pmfloat(ra - min * SkPMFloat(0, 1, 1, 1));
     }
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kDifference_Mode;
 };
 
 struct Exclusion4f {
     static SkPMFloat Xfer(const SkPMFloat& src, const SkPMFloat& dst) {
         const Sk4f inv255(gInv255);
         Sk4f sc = src;
         Sk4f dc = dst;
         Sk4f prod = sc * dc * inv255;
         Sk4f ra = sc + dc - prod;
-        return check_as_pmfloat(set_a_rgb(ra, ra - prod));
+        return check_as_pmfloat(ra - prod * SkPMFloat(0, 1, 1, 1));
     }
     static const bool kFoldCoverageIntoSrcAlpha = false;
     static const SkXfermode::Mode kMode = SkXfermode::kExclusion_Mode;
 };
 
 template <typename ProcType>
 class SkT4fXfermode : public SkProcCoeffXfermode {
 public:
     static SkXfermode* Create(const ProcCoeff& rec) {
         return SkNEW_ARGS(SkT4fXfermode, (rec));
     }
 
     void xfer32(SkPMColor dst[], const SkPMColor src[], int n, const SkAlpha aa[]) const override {
         if (NULL == aa) {
-            while (n & 3) {
-                *dst = ProcType::Xfer(SkPMFloat(*src++), SkPMFloat(*dst)).round();
-                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::RoundTo4PMColors(ProcType::Xfer(s0, d0), ProcType::Xfer(s1, d1),
-                                            ProcType::Xfer(s2, d2), ProcType::Xfer(s3, d3), dst);
-                src += 4;
-                dst += 4;
+                dst[i] = ProcType::Xfer(SkPMFloat(src[i]), SkPMFloat(dst[i])).round();
             }
         } else {
             for (int i = 0; i < n; ++i) {
                 const Sk4f aa4 = Sk4f(aa[i] * gInv255);
                 SkPMFloat dstF(dst[i]);
                 SkPMFloat srcF(src[i]);
                 Sk4f res;
                 if (ProcType::kFoldCoverageIntoSrcAlpha) {
                     Sk4f src4 = srcF;
                     res = ProcType::Xfer(src4 * aa4, dstF);
@@ skipping 402 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