src/effects/gradients/Sk4fLinearGradient.cpp - platform/external/skqp - Gitiles

 /*
  * 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 "Sk4fGradientPriv.h"
 #include "Sk4fLinearGradient.h"

 namespace {

 template<typename DstType, bool do_premul>
 void fill(const Sk4f& c, DstType* dst, int n);

 template<>
 void fill<SkPM4f, false>(const Sk4f& c, SkPM4f* dst, int n) {
     while (n > 0) {
         c.store(dst++);
         n--;
     }
 }

 template<>
 void fill<SkPM4f, true>(const Sk4f& c, SkPM4f* dst, int n) {
     fill<SkPM4f, false>(premul_4f(c), dst, n);
 }

 template<>
 void fill<SkPMColor, false>(const Sk4f& c, SkPMColor* dst, int n) {
     sk_memset32(dst, trunc_from_255<false>(c), n);
 }

 template<>
 void fill<SkPMColor, true>(const Sk4f& c, SkPMColor* dst, int n) {
     sk_memset32(dst, trunc_from_255<true>(c), n);
 }

 template<typename DstType, bool do_premul>
 void ramp(const Sk4f& c, const Sk4f& dc, DstType* dst, int n) {
     SkASSERT(n > 0);

     const Sk4f dc2 = dc + dc;
     const Sk4f dc4 = dc2 + dc2;

     Sk4f c0 = c ;
     Sk4f c1 = c + dc;
     Sk4f c2 = c0 + dc2;
     Sk4f c3 = c1 + dc2;

     while (n >= 4) {
         store4x<DstType, do_premul>(c0, c1, c2, c3, dst);
         dst += 4;

         c0 = c0 + dc4;
         c1 = c1 + dc4;
         c2 = c2 + dc4;
         c3 = c3 + dc4;
         n -= 4;
     }
     if (n & 2) {
         store<DstType, do_premul>(c0, dst++);
         store<DstType, do_premul>(c1, dst++);
         c0 = c0 + dc2;
     }
     if (n & 1) {
         store<DstType, do_premul>(c0, dst);
     }
 }

 template<SkShader::TileMode>
 SkScalar pinFx(SkScalar);

 template<>
 SkScalar pinFx<SkShader::kClamp_TileMode>(SkScalar fx) {
     return fx;
 }

 template<>
 SkScalar pinFx<SkShader::kRepeat_TileMode>(SkScalar fx) {
     const SkScalar f = SkScalarFraction(fx);
     return f < 0 ? f + 1 : f;
 }

 template<>
 SkScalar pinFx<SkShader::kMirror_TileMode>(SkScalar fx) {
     const SkScalar f = SkScalarMod(fx, 2.0f);
     return f < 0 ? f + 2 : f;
 }

 // true when x is in [k1,k2)
 bool in_range(SkScalar x, SkScalar k1, SkScalar k2) {
     SkASSERT(k1 != k2);
     return (k1 < k2)
         ? (x >= k1 && x < k2)
         : (x >= k2 && x < k1);
 }

 } // anonymous namespace

 SkLinearGradient::
 LinearGradient4fContext::LinearGradient4fContext(const SkLinearGradient& shader,
                                                  const ContextRec& rec)
     : INHERITED(shader, rec) {

     // Our fast path expects interval points to be monotonically increasing in x.
     const bool reverseIntervals = this->isFast() && fDstToPos.getScaleX() < 0;
     this->buildIntervals(shader, rec, reverseIntervals);

     SkASSERT(fIntervals.count() > 0);
     fCachedInterval = fIntervals.begin();
 }

 const SkGradientShaderBase::GradientShaderBase4fContext::Interval*
 SkLinearGradient::LinearGradient4fContext::findInterval(SkScalar fx) const {
     SkASSERT(in_range(fx, fIntervals.front().fP0, fIntervals.back().fP1));

     if (1) {
         // Linear search, using the last scanline interval as a starting point.
         SkASSERT(fCachedInterval >= fIntervals.begin());
         SkASSERT(fCachedInterval < fIntervals.end());
         const int search_dir = fDstToPos.getScaleX() >= 0 ? 1 : -1;
         while (!in_range(fx, fCachedInterval->fP0, fCachedInterval->fP1)) {
             fCachedInterval += search_dir;
             if (fCachedInterval >= fIntervals.end()) {
                 fCachedInterval = fIntervals.begin();
             } else if (fCachedInterval < fIntervals.begin()) {
                 fCachedInterval = fIntervals.end() - 1;
             }
         }
         return fCachedInterval;
     } else {
         // Binary search.  Seems less effective than linear + caching.
         const Interval* i0 = fIntervals.begin();
         const Interval* i1 = fIntervals.end() - 1;

         while (i0 != i1) {
             SkASSERT(i0 < i1);
             SkASSERT(in_range(fx, i0->fP0, i1->fP1));

             const Interval* i = i0 + ((i1 - i0) >> 1);

             if (in_range(fx, i0->fP0, i->fP1)) {
                 i1 = i;
             } else {
                 SkASSERT(in_range(fx, i->fP1, i1->fP1));
                 i0 = i + 1;
             }
         }

         SkASSERT(in_range(fx, i0->fP0, i0->fP1));
         return i0;
     }
 }

 void SkLinearGradient::
 LinearGradient4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) {
     if (!this->isFast()) {
         this->INHERITED::shadeSpan(x, y, dst, count);
         return;
     }

     // TODO: plumb dithering
     SkASSERT(count > 0);
     if (fColorsArePremul) {
         this->shadePremulSpan<SkPMColor, false>(x, y, dst, count);
     } else {
         this->shadePremulSpan<SkPMColor, true>(x, y, dst, count);
     }
 }

 void SkLinearGradient::
 LinearGradient4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
     if (!this->isFast()) {
         this->INHERITED::shadeSpan4f(x, y, dst, count);
         return;
     }

     // TONOTDO: plumb dithering
     SkASSERT(count > 0);
     if (fColorsArePremul) {
         this->shadePremulSpan<SkPM4f, false>(x, y, dst, count);
     } else {
         this->shadePremulSpan<SkPM4f, true>(x, y, dst, count);
     }
 }

 template<typename DstType, bool do_premul>
 void SkLinearGradient::
 LinearGradient4fContext::shadePremulSpan(int x, int y,
                                          DstType dst[],
                                          int count) const {
     const SkLinearGradient& shader =
         static_cast<const SkLinearGradient&>(fShader);
     switch (shader.fTileMode) {
     case kClamp_TileMode:
         this->shadeSpanInternal<DstType,
                                 do_premul,
                                 kClamp_TileMode>(x, y, dst, count);
         break;
     case kRepeat_TileMode:
         this->shadeSpanInternal<DstType,
                                 do_premul,
                                 kRepeat_TileMode>(x, y, dst, count);
         break;
     case kMirror_TileMode:
         this->shadeSpanInternal<DstType,
                                 do_premul,
                                 kMirror_TileMode>(x, y, dst, count);
         break;
     }
 }

 template<typename DstType, bool do_premul, SkShader::TileMode tileMode>
 void SkLinearGradient::
 LinearGradient4fContext::shadeSpanInternal(int x, int y,
                                            DstType 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));
     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()) {
             fill<DstType, do_premul>(proc.currentColor(),
                                      dst, n);
         } else {
             ramp<DstType, do_premul>(proc.currentColor(),
                                      proc.currentColorGrad(),
                                      dst, n);
         }

         proc.advance(SkIntToScalar(n));
         count -= n;
         dst   += n;
     }
 }

 template<typename DstType, 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)
         : fDstComponentScale(dst_component_scale<DstType>())
         , fAdvX((i->fP1 - fx) / dx)
         , fFirstInterval(firstInterval)
         , fLastInterval(lastInterval)
         , fInterval(i)
         , fDx(dx)
         , fIsVertical(is_vertical)
     {
         SkASSERT(firstInterval <= lastInterval);
         SkASSERT(in_range(fx, i->fP0, i->fP1));
         this->compute_interval_props(fx - i->fP0);
     }

     SkScalar currentAdvance() const {
         SkASSERT(fAdvX >= 0);
         SkASSERT(fAdvX <= (fInterval->fP1 - fInterval->fP0) / fDx);
         return fAdvX;
     }

     bool currentRampIsZero() const { return fZeroRamp; }
     const Sk4f& currentColor() const { return fCc; }
     const Sk4f& currentColorGrad() const { return fDcDx; }

     void advance(SkScalar advX) {
         SkASSERT(advX > 0);
         SkASSERT(fAdvX >= 0);

         if (advX >= fAdvX) {
             advX = this->advance_interval(advX);
         }
         SkASSERT(advX < fAdvX);

         fCc = fCc + fDcDx * Sk4f(advX);
         fAdvX -= advX;
     }

 private:
     void compute_interval_props(SkScalar t) {
         fDc   = dst_swizzle<DstType>(fInterval->fDc);
         fCc   = dst_swizzle<DstType>(fInterval->fC0);
         fCc   = fCc + fDc * Sk4f(t);
         fCc   = fCc * fDstComponentScale;
         fDcDx = fDc * fDstComponentScale * Sk4f(fDx);
         fZeroRamp = fIsVertical || fInterval->isZeroRamp();
     }

     const Interval* next_interval(const Interval* i) const {
         SkASSERT(i >= fFirstInterval);
         SkASSERT(i <= fLastInterval);
         i++;

         if (tileMode == kClamp_TileMode) {
             SkASSERT(i <= fLastInterval);
             return i;
         }

         return (i <= fLastInterval) ? i : fFirstInterval;
     }

     SkScalar advance_interval(SkScalar advX) {
         SkASSERT(advX >= fAdvX);

         do {
             advX -= fAdvX;
             fInterval = this->next_interval(fInterval);
             fAdvX = (fInterval->fP1 - fInterval->fP0) / fDx;
             SkASSERT(fAdvX > 0);
         } while (advX >= fAdvX);

         compute_interval_props(0);

         SkASSERT(advX >= 0);
         return advX;
     }

     const Sk4f      fDstComponentScale; // cached dst scale (PMC: 255, PM4f: 1)

     // Current interval properties.
     Sk4f            fDc;        // local color gradient (dc/dt)
     Sk4f            fDcDx;      // dst color gradient (dc/dx)
     Sk4f            fCc;        // current color, interpolated in dst
     SkScalar        fAdvX;      // remaining interval advance in dst
     bool            fZeroRamp;  // current interval color grad is 0

     const Interval* fFirstInterval;
     const Interval* fLastInterval;
     const Interval* fInterval;  // current interval
     const SkScalar  fDx;        // 'dx' for consistency with other impls; actually dt/dx
     const bool      fIsVertical;
 };

 void SkLinearGradient::
 LinearGradient4fContext::mapTs(int x, int y, SkScalar ts[], int count) const {
     SkASSERT(count > 0);
     SkASSERT(fDstToPosClass != kLinear_MatrixClass);

     SkScalar sx = x + SK_ScalarHalf;
     const SkScalar sy = y + SK_ScalarHalf;
     SkPoint pt;

     if (fDstToPosClass != kPerspective_MatrixClass) {
         // kLinear_MatrixClass, kFixedStepInX_MatrixClass => fixed dt per scanline
         const SkScalar dtdx = fDstToPos.fixedStepInX(sy).x();
         fDstToPosProc(fDstToPos, sx, sy, &pt);

         const Sk4f dtdx4 = Sk4f(4 * dtdx);
         Sk4f t4 = Sk4f(pt.x() + 0 * dtdx,
                        pt.x() + 1 * dtdx,
                        pt.x() + 2 * dtdx,
                        pt.x() + 3 * dtdx);

         while (count >= 4) {
             t4.store(ts);
             t4 = t4 + dtdx4;
             ts += 4;
             count -= 4;
         }

         if (count & 2) {
             *ts++ = t4[0];
             *ts++ = t4[1];
             t4 = SkNx_shuffle<2, 0, 1, 3>(t4);
         }

         if (count & 1) {
             *ts++ = t4[0];
         }
     } else {
         for (int i = 0; i < count; ++i) {
             fDstToPosProc(fDstToPos, sx, sy, &pt);
             ts[i] = pt.x();
             sx += SK_Scalar1;
         }
     }
 }
	/*
	* 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 "Sk4fGradientPriv.h"
	#include "Sk4fLinearGradient.h"

	namespace {

	template<typename DstType, bool do_premul>
	void fill(const Sk4f& c, DstType* dst, int n);

	template<>
	void fill<SkPM4f, false>(const Sk4f& c, SkPM4f* dst, int n) {
	while (n > 0) {
	c.store(dst++);
	n--;
	}
	}

	template<>
	void fill<SkPM4f, true>(const Sk4f& c, SkPM4f* dst, int n) {
	fill<SkPM4f, false>(premul_4f(c), dst, n);
	}

	template<>
	void fill<SkPMColor, false>(const Sk4f& c, SkPMColor* dst, int n) {
	sk_memset32(dst, trunc_from_255<false>(c), n);
	}

	template<>
	void fill<SkPMColor, true>(const Sk4f& c, SkPMColor* dst, int n) {
	sk_memset32(dst, trunc_from_255<true>(c), n);
	}

	template<typename DstType, bool do_premul>
	void ramp(const Sk4f& c, const Sk4f& dc, DstType* dst, int n) {
	SkASSERT(n > 0);

	const Sk4f dc2 = dc + dc;
	const Sk4f dc4 = dc2 + dc2;

	Sk4f c0 = c ;
	Sk4f c1 = c + dc;
	Sk4f c2 = c0 + dc2;
	Sk4f c3 = c1 + dc2;

	while (n >= 4) {
	store4x<DstType, do_premul>(c0, c1, c2, c3, dst);
	dst += 4;

	c0 = c0 + dc4;
	c1 = c1 + dc4;
	c2 = c2 + dc4;
	c3 = c3 + dc4;
	n -= 4;
	}
	if (n & 2) {
	store<DstType, do_premul>(c0, dst++);
	store<DstType, do_premul>(c1, dst++);
	c0 = c0 + dc2;
	}
	if (n & 1) {
	store<DstType, do_premul>(c0, dst);
	}
	}

	template<SkShader::TileMode>
	SkScalar pinFx(SkScalar);

	template<>
	SkScalar pinFx<SkShader::kClamp_TileMode>(SkScalar fx) {
	return fx;
	}

	template<>
	SkScalar pinFx<SkShader::kRepeat_TileMode>(SkScalar fx) {
	const SkScalar f = SkScalarFraction(fx);
	return f < 0 ? f + 1 : f;
	}

	template<>
	SkScalar pinFx<SkShader::kMirror_TileMode>(SkScalar fx) {
	const SkScalar f = SkScalarMod(fx, 2.0f);
	return f < 0 ? f + 2 : f;
	}

	// true when x is in [k1,k2)
	bool in_range(SkScalar x, SkScalar k1, SkScalar k2) {
	SkASSERT(k1 != k2);
	return (k1 < k2)
	? (x >= k1 && x < k2)
	: (x >= k2 && x < k1);
	}

	} // anonymous namespace

	SkLinearGradient::
	LinearGradient4fContext::LinearGradient4fContext(const SkLinearGradient& shader,
	const ContextRec& rec)
	: INHERITED(shader, rec) {

	// Our fast path expects interval points to be monotonically increasing in x.
	const bool reverseIntervals = this->isFast() && fDstToPos.getScaleX() < 0;
	this->buildIntervals(shader, rec, reverseIntervals);

	SkASSERT(fIntervals.count() > 0);
	fCachedInterval = fIntervals.begin();
	}

	const SkGradientShaderBase::GradientShaderBase4fContext::Interval*
	SkLinearGradient::LinearGradient4fContext::findInterval(SkScalar fx) const {
	SkASSERT(in_range(fx, fIntervals.front().fP0, fIntervals.back().fP1));

	if (1) {
	// Linear search, using the last scanline interval as a starting point.
	SkASSERT(fCachedInterval >= fIntervals.begin());
	SkASSERT(fCachedInterval < fIntervals.end());
	const int search_dir = fDstToPos.getScaleX() >= 0 ? 1 : -1;
	while (!in_range(fx, fCachedInterval->fP0, fCachedInterval->fP1)) {
	fCachedInterval += search_dir;
	if (fCachedInterval >= fIntervals.end()) {
	fCachedInterval = fIntervals.begin();
	} else if (fCachedInterval < fIntervals.begin()) {
	fCachedInterval = fIntervals.end() - 1;
	}
	}
	return fCachedInterval;
	} else {
	// Binary search. Seems less effective than linear + caching.
	const Interval* i0 = fIntervals.begin();
	const Interval* i1 = fIntervals.end() - 1;

	while (i0 != i1) {
	SkASSERT(i0 < i1);
	SkASSERT(in_range(fx, i0->fP0, i1->fP1));

	const Interval* i = i0 + ((i1 - i0) >> 1);

	if (in_range(fx, i0->fP0, i->fP1)) {
	i1 = i;
	} else {
	SkASSERT(in_range(fx, i->fP1, i1->fP1));
	i0 = i + 1;
	}
	}

	SkASSERT(in_range(fx, i0->fP0, i0->fP1));
	return i0;
	}
	}

	void SkLinearGradient::
	LinearGradient4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) {
	if (!this->isFast()) {
	this->INHERITED::shadeSpan(x, y, dst, count);
	return;
	}

	// TODO: plumb dithering
	SkASSERT(count > 0);
	if (fColorsArePremul) {
	this->shadePremulSpan<SkPMColor, false>(x, y, dst, count);
	} else {
	this->shadePremulSpan<SkPMColor, true>(x, y, dst, count);
	}
	}

	void SkLinearGradient::
	LinearGradient4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
	if (!this->isFast()) {
	this->INHERITED::shadeSpan4f(x, y, dst, count);
	return;
	}

	// TONOTDO: plumb dithering
	SkASSERT(count > 0);
	if (fColorsArePremul) {
	this->shadePremulSpan<SkPM4f, false>(x, y, dst, count);
	} else {
	this->shadePremulSpan<SkPM4f, true>(x, y, dst, count);
	}
	}

	template<typename DstType, bool do_premul>
	void SkLinearGradient::
	LinearGradient4fContext::shadePremulSpan(int x, int y,
	DstType dst[],
	int count) const {
	const SkLinearGradient& shader =
	static_cast<const SkLinearGradient&>(fShader);
	switch (shader.fTileMode) {
	case kClamp_TileMode:
	this->shadeSpanInternal<DstType,
	do_premul,
	kClamp_TileMode>(x, y, dst, count);
	break;
	case kRepeat_TileMode:
	this->shadeSpanInternal<DstType,
	do_premul,
	kRepeat_TileMode>(x, y, dst, count);
	break;
	case kMirror_TileMode:
	this->shadeSpanInternal<DstType,
	do_premul,
	kMirror_TileMode>(x, y, dst, count);
	break;
	}
	}

	template<typename DstType, bool do_premul, SkShader::TileMode tileMode>
	void SkLinearGradient::
	LinearGradient4fContext::shadeSpanInternal(int x, int y,
	DstType 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));
	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()) {
	fill<DstType, do_premul>(proc.currentColor(),
	dst, n);
	} else {
	ramp<DstType, do_premul>(proc.currentColor(),
	proc.currentColorGrad(),
	dst, n);
	}

	proc.advance(SkIntToScalar(n));
	count -= n;
	dst += n;
	}
	}

	template<typename DstType, 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)
	: fDstComponentScale(dst_component_scale<DstType>())
	, fAdvX((i->fP1 - fx) / dx)
	, fFirstInterval(firstInterval)
	, fLastInterval(lastInterval)
	, fInterval(i)
	, fDx(dx)
	, fIsVertical(is_vertical)
	{
	SkASSERT(firstInterval <= lastInterval);
	SkASSERT(in_range(fx, i->fP0, i->fP1));
	this->compute_interval_props(fx - i->fP0);
	}

	SkScalar currentAdvance() const {
	SkASSERT(fAdvX >= 0);
	SkASSERT(fAdvX <= (fInterval->fP1 - fInterval->fP0) / fDx);
	return fAdvX;
	}

	bool currentRampIsZero() const { return fZeroRamp; }
	const Sk4f& currentColor() const { return fCc; }
	const Sk4f& currentColorGrad() const { return fDcDx; }

	void advance(SkScalar advX) {
	SkASSERT(advX > 0);
	SkASSERT(fAdvX >= 0);

	if (advX >= fAdvX) {
	advX = this->advance_interval(advX);
	}
	SkASSERT(advX < fAdvX);

	fCc = fCc + fDcDx * Sk4f(advX);
	fAdvX -= advX;
	}

	private:
	void compute_interval_props(SkScalar t) {
	fDc = dst_swizzle<DstType>(fInterval->fDc);
	fCc = dst_swizzle<DstType>(fInterval->fC0);
	fCc = fCc + fDc * Sk4f(t);
	fCc = fCc * fDstComponentScale;
	fDcDx = fDc * fDstComponentScale * Sk4f(fDx);
	fZeroRamp = fIsVertical \|\| fInterval->isZeroRamp();
	}

	const Interval* next_interval(const Interval* i) const {
	SkASSERT(i >= fFirstInterval);
	SkASSERT(i <= fLastInterval);
	i++;

	if (tileMode == kClamp_TileMode) {
	SkASSERT(i <= fLastInterval);
	return i;
	}

	return (i <= fLastInterval) ? i : fFirstInterval;
	}

	SkScalar advance_interval(SkScalar advX) {
	SkASSERT(advX >= fAdvX);

	do {
	advX -= fAdvX;
	fInterval = this->next_interval(fInterval);
	fAdvX = (fInterval->fP1 - fInterval->fP0) / fDx;
	SkASSERT(fAdvX > 0);
	} while (advX >= fAdvX);

	compute_interval_props(0);

	SkASSERT(advX >= 0);
	return advX;
	}

	const Sk4f fDstComponentScale; // cached dst scale (PMC: 255, PM4f: 1)

	// Current interval properties.
	Sk4f fDc; // local color gradient (dc/dt)
	Sk4f fDcDx; // dst color gradient (dc/dx)
	Sk4f fCc; // current color, interpolated in dst
	SkScalar fAdvX; // remaining interval advance in dst
	bool fZeroRamp; // current interval color grad is 0

	const Interval* fFirstInterval;
	const Interval* fLastInterval;
	const Interval* fInterval; // current interval
	const SkScalar fDx; // 'dx' for consistency with other impls; actually dt/dx
	const bool fIsVertical;
	};

	void SkLinearGradient::
	LinearGradient4fContext::mapTs(int x, int y, SkScalar ts[], int count) const {
	SkASSERT(count > 0);
	SkASSERT(fDstToPosClass != kLinear_MatrixClass);

	SkScalar sx = x + SK_ScalarHalf;
	const SkScalar sy = y + SK_ScalarHalf;
	SkPoint pt;

	if (fDstToPosClass != kPerspective_MatrixClass) {
	// kLinear_MatrixClass, kFixedStepInX_MatrixClass => fixed dt per scanline
	const SkScalar dtdx = fDstToPos.fixedStepInX(sy).x();
	fDstToPosProc(fDstToPos, sx, sy, &pt);

	const Sk4f dtdx4 = Sk4f(4 * dtdx);
	Sk4f t4 = Sk4f(pt.x() + 0 * dtdx,
	pt.x() + 1 * dtdx,
	pt.x() + 2 * dtdx,
	pt.x() + 3 * dtdx);

	while (count >= 4) {
	t4.store(ts);
	t4 = t4 + dtdx4;
	ts += 4;
	count -= 4;
	}

	if (count & 2) {
	*ts++ = t4[0];
	*ts++ = t4[1];
	t4 = SkNx_shuffle<2, 0, 1, 3>(t4);
	}

	if (count & 1) {
	*ts++ = t4[0];
	}
	} else {
	for (int i = 0; i < count; ++i) {
	fDstToPosProc(fDstToPos, sx, sy, &pt);
	ts[i] = pt.x();
	sx += SK_Scalar1;
	}
	}
	}