4f linear gradient shader blitters

src/effects/gradients/Sk4fGradientBase.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 "Sk4fGradientBase.h"
-#include "Sk4fGradientPriv.h"
 
 #include <functional>
 
 namespace {
 
 SkPMColor pack_color(SkColor c, bool premul) {
     return premul
         ? SkPreMultiplyColor(c)
         : SkPackARGB32NoCheck(SkColorGetA(c), SkColorGetR(c), SkColorGetG(c), SkColorGetB(c));
 }
@@ skipping 250 matching lines @@
                                 2 - p0,
                                 pack_color(c1, fColorsArePremul),
                                 2 - p1,
                                 componentScale);
     });
 }
 
 void SkGradientShaderBase::
 GradientShaderBase4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) {
     if (fColorsArePremul) {
-        this->shadePremulSpan<SkPMColor, false>(x, y, dst, count);
+        this->shadePremulSpan<SkPMColor, ApplyPremul::False>(x, y, dst, count);
     } else {
-        this->shadePremulSpan<SkPMColor, true>(x, y, dst, count);
+        this->shadePremulSpan<SkPMColor, ApplyPremul::True>(x, y, dst, count);
     }
 }
 
 void SkGradientShaderBase::
 GradientShaderBase4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
     if (fColorsArePremul) {
-        this->shadePremulSpan<SkPM4f, false>(x, y, dst, count);
+        this->shadePremulSpan<SkPM4f, ApplyPremul::False>(x, y, dst, count);
     } else {
-        this->shadePremulSpan<SkPM4f, true>(x, y, dst, count);
+        this->shadePremulSpan<SkPM4f, ApplyPremul::True>(x, y, dst, count);
     }
 }
 
-template<typename DstType, bool do_premul>
+template<typename DstType, ApplyPremul premul>
 void SkGradientShaderBase::
 GradientShaderBase4fContext::shadePremulSpan(int x, int y,
                                              DstType dst[],
                                              int count) const {
     const SkGradientShaderBase& shader =
         static_cast<const SkGradientShaderBase&>(fShader);
 
     switch (shader.fTileMode) {
     case kClamp_TileMode:
         this->shadeSpanInternal<DstType,
-                                do_premul,
+                                premul,
                                 kClamp_TileMode>(x, y, dst, count);
         break;
     case kRepeat_TileMode:
         this->shadeSpanInternal<DstType,
-                                do_premul,
+                                premul,
                                 kRepeat_TileMode>(x, y, dst, count);
         break;
     case kMirror_TileMode:
         this->shadeSpanInternal<DstType,
-                                do_premul,
+                                premul,
                                 kMirror_TileMode>(x, y, dst, count);
         break;
     }
 }
 
-template<typename DstType, bool do_premul, SkShader::TileMode tileMode>
+template<typename DstType, ApplyPremul premul, SkShader::TileMode tileMode>
 void SkGradientShaderBase::
 GradientShaderBase4fContext::shadeSpanInternal(int x, int y,
                                                DstType dst[],
                                                int count) const {
     static const int kBufSize = 128;
     SkScalar ts[kBufSize];
     TSampler<DstType, tileMode> sampler(*this);
 
     SkASSERT(count > 0);
     do {
         const int n = SkTMin(kBufSize, count);
         this->mapTs(x, y, ts, n);
         for (int i = 0; i < n; ++i) {
             const Sk4f c = sampler.sample(ts[i]);
-            store<DstType, do_premul>(c, dst++);
+            store<DstType, kLinear_SkColorProfileType, premul>(c, dst++);
         }
         x += n;
         count -= n;
     } while (count > 0);
 }
 
 template<typename DstType, SkShader::TileMode tileMode>
 class SkGradientShaderBase::GradientShaderBase4fContext::TSampler {
 public:
     TSampler(const GradientShaderBase4fContext& ctx)
@@ skipping 69 matching lines @@
                 if (i < fFirstInterval) {
                     i = fLastInterval;
                 }
             } while (tiled_t < i->fP0 || tiled_t >= i->fP1);
         }
 
         return i;
     }
 
     void loadIntervalData(const Interval* i) {
-        fCc = dst_swizzle<DstType>(i->fC0) * dst_component_scale<DstType>();
-        fDc = dst_swizzle<DstType>(i->fDc) * dst_component_scale<DstType>();
+        fCc = scale_for_dest<DstType, kLinear_SkColorProfileType>(dst_swizzle<DstType>(i->fC0));
+        fDc = scale_for_dest<DstType, kLinear_SkColorProfileType>(dst_swizzle<DstType>(i->fDc));
     }
 
     const Interval* fFirstInterval;
     const Interval* fLastInterval;
     const Interval* fInterval;
     SkScalar        fPrevT;
     Sk4f            fCc;
     Sk4f            fDc;
 };