Faster 4f gradient premul path

src/effects/gradients/Sk4fLinearGradient.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Sk4fLinearGradient.h"
 #include "Sk4x4f.h"
 #include "SkXfermode.h"
@@ skipping 222 matching lines @@
 LinearGradient4fContext::shadeSpanInternal(int x, int y,
                                            typename DstTraits<dstType, premul>::Type dst[],
                                            int count) const {
     SkPoint pt;
     fDstToPosProc(fDstToPos,
                   x + SK_ScalarHalf,
                   y + SK_ScalarHalf,
                   &pt);
     const SkScalar fx = pinFx<tileMode>(pt.x());
     const SkScalar dx = fDstToPos.getScaleX();
-    LinearIntervalProcessor<dstType, tileMode> proc(fIntervals.begin(),
-                                                    fIntervals.end() - 1,
-                                                    this->findInterval(fx),
-                                                    fx,
-                                                    dx,
-                                                    SkScalarNearlyZero(dx * count));
+    LinearIntervalProcessor<dstType, premul, tileMode> proc(fIntervals.begin(),
+                                                            fIntervals.end() - 1,
+                                                            this->findInterval(fx),
+                                                            fx,
+                                                            dx,
+                                                            SkScalarNearlyZero(dx * count));
     while (count > 0) {
         // What we really want here is SkTPin(advance, 1, count)
         // but that's a significant perf hit for >> stops; investigate.
         const int n = SkScalarTruncToInt(
             SkTMin<SkScalar>(proc.currentAdvance() + 1, SkIntToScalar(count)));
 
         // The current interval advance can be +inf (e.g. when reaching
         // the clamp mode end intervals) - when that happens, we expect to
         //   a) consume all remaining count in one swoop
         //   b) return a zero color gradient
         SkASSERT(SkScalarIsFinite(proc.currentAdvance())
             || (n == count && proc.currentRampIsZero()));
 
         if (proc.currentRampIsZero()) {
             DstTraits<dstType, premul>::store(proc.currentColor(),
                                               dst, n);
         } else {
             ramp<dstType, premul>(proc.currentColor(),
                                   proc.currentColorGrad(),
                                   dst, n);
         }
 
         proc.advance(SkIntToScalar(n));
         count -= n;
         dst   += n;
     }
 }
 
-template<DstType dstType, SkShader::TileMode tileMode>
+template<DstType dstType, ApplyPremul premul, SkShader::TileMode tileMode>
 class SkLinearGradient::
 LinearGradient4fContext::LinearIntervalProcessor {
 public:
     LinearIntervalProcessor(const Interval* firstInterval,
                             const Interval* lastInterval,
                             const Interval* i,
                             SkScalar fx,
                             SkScalar dx,
                             bool is_vertical)
         : fAdvX((i->fP1 - fx) / dx)
@@ skipping 27 matching lines @@
             advX = this->advance_interval(advX);
         }
         SkASSERT(advX < fAdvX);
 
         fCc = fCc + fDcDx * Sk4f(advX);
         fAdvX -= advX;
     }
 
 private:
     void compute_interval_props(SkScalar t) {
-        const Sk4f dC = DstTraits<dstType>::load(fInterval->fDc);
-        fCc           = DstTraits<dstType>::load(fInterval->fC0);
+        const Sk4f dC = DstTraits<dstType, premul>::load(fInterval->fDc);
+        fCc           = DstTraits<dstType, premul>::load(fInterval->fC0);
         fCc           = fCc + dC * Sk4f(t);
         fDcDx         = dC * fDx;
         fZeroRamp     = fIsVertical || fInterval->isZeroRamp();
     }
 
     const Interval* next_interval(const Interval* i) const {
         SkASSERT(i >= fFirstInterval);
         SkASSERT(i <= fLastInterval);
         i++;
 
@@ skipping 137 matching lines @@
         static_cast<const LinearGradient4fContext*>(state->fCtx);
 
     if (ctx->fColorsArePremul) {
         ctx->shadePremulSpan<DstType::F16, ApplyPremul::False>(
             x, y, dst.writable_addr64(x, y), count);
     } else {
         ctx->shadePremulSpan<DstType::F16, ApplyPremul::True>(
             x, y, dst.writable_addr64(x, y), count);
     }
 }