| /* |
| * 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 <cmath> |
| |
| namespace { |
| |
| template<typename dstType, ApplyPremul premul> |
| void ramp(const Sk4f& c, const Sk4f& dc, dstType dst[], int n, |
| const Sk4f& bias0, const Sk4f& bias1) { |
| SkASSERT(n > 0); |
| |
| const Sk4f dc2 = dc + dc, |
| dc4 = dc2 + dc2; |
| |
| Sk4f c0 = c + DstTraits<dstType, premul>::pre_lerp_bias(bias0), |
| c1 = c + dc + DstTraits<dstType, premul>::pre_lerp_bias(bias1), |
| c2 = c0 + dc2, |
| c3 = c1 + dc2; |
| |
| while (n >= 4) { |
| DstTraits<dstType, premul>::store4x(c0, c1, c2, c3, dst, bias0, bias1); |
| dst += 4; |
| |
| c0 = c0 + dc4; |
| c1 = c1 + dc4; |
| c2 = c2 + dc4; |
| c3 = c3 + dc4; |
| n -= 4; |
| } |
| if (n & 2) { |
| DstTraits<dstType, premul>::store(c0, dst++, bias0); |
| DstTraits<dstType, premul>::store(c1, dst++, bias1); |
| c0 = c0 + dc2; |
| } |
| if (n & 1) { |
| DstTraits<dstType, premul>::store(c0, dst, bias0); |
| } |
| } |
| |
| template<SkShader::TileMode> |
| SkScalar pinFx(SkScalar); |
| |
| template<> |
| SkScalar pinFx<SkShader::kClamp_TileMode>(SkScalar fx) { |
| return fx; |
| } |
| |
| template<> |
| SkScalar pinFx<SkShader::kRepeat_TileMode>(SkScalar fx) { |
| SkScalar f = SkScalarFraction(fx); |
| if (f < 0) { |
| f = SkTMin(f + 1, nextafterf(1, 0)); |
| } |
| SkASSERT(f >= 0); |
| SkASSERT(f < 1.0f); |
| return f; |
| } |
| |
| template<> |
| SkScalar pinFx<SkShader::kMirror_TileMode>(SkScalar fx) { |
| SkScalar f = SkScalarMod(fx, 2.0f); |
| if (f < 0) { |
| f = SkTMin(f + 2, nextafterf(2, 0)); |
| } |
| SkASSERT(f >= 0); |
| SkASSERT(f < 2.0f); |
| return f; |
| } |
| |
| // true when x is in [k1,k2], or [k2, k1] when the interval is reversed. |
| // TODO(fmalita): hoist the reversed interval check out of this helper. |
| 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 = std::signbit(fDstToPos.getScaleX()); |
| fIntervals.init(shader, rec.fDstColorSpace, shader.fTileMode, |
| fColorsArePremul, rec.fPaint->getAlpha() * (1.0f / 255), reverseIntervals); |
| |
| SkASSERT(fIntervals->count() > 0); |
| fCachedInterval = fIntervals->begin(); |
| } |
| |
| const Sk4fGradientInterval* |
| SkLinearGradient::LinearGradient4fContext::findInterval(SkScalar fx) const { |
| SkASSERT(in_range(fx, fIntervals->front().fT0, fIntervals->back().fT1)); |
| |
| 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->fT0, fCachedInterval->fT1)) { |
| 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 auto* i0 = fIntervals->begin(); |
| const auto* i1 = fIntervals->end() - 1; |
| |
| while (i0 != i1) { |
| SkASSERT(i0 < i1); |
| SkASSERT(in_range(fx, i0->fT0, i1->fT1)); |
| |
| const auto* i = i0 + ((i1 - i0) >> 1); |
| |
| if (in_range(fx, i0->fT0, i->fT1)) { |
| i1 = i; |
| } else { |
| SkASSERT(in_range(fx, i->fT1, i1->fT1)); |
| i0 = i + 1; |
| } |
| } |
| |
| SkASSERT(in_range(fx, i0->fT0, i0->fT1)); |
| return i0; |
| } |
| } |
| |
| |
| void SkLinearGradient:: |
| LinearGradient4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) { |
| SkASSERT(count > 0); |
| |
| float bias0 = 0, |
| bias1 = 0; |
| |
| if (fDither) { |
| static constexpr float dither_cell[] = { |
| -3/8.0f, 1/8.0f, |
| 3/8.0f, -1/8.0f, |
| }; |
| |
| const int rowIndex = (y & 1) << 1; |
| bias0 = dither_cell[rowIndex + 0]; |
| bias1 = dither_cell[rowIndex + 1]; |
| |
| if (x & 1) { |
| SkTSwap(bias0, bias1); |
| } |
| } |
| |
| if (fColorsArePremul) { |
| // In premul interpolation mode, components are pre-scaled by 255 and the store |
| // op is truncating. We pre-bias here to achieve rounding. |
| bias0 += 0.5f; |
| bias1 += 0.5f; |
| |
| this->shadePremulSpan<SkPMColor, ApplyPremul::False>(x, y, dst, count, bias0, bias1); |
| } else { |
| // In unpremul interpolation mode, Components are not pre-scaled. |
| bias0 *= 1/255.0f; |
| bias1 *= 1/255.0f; |
| |
| this->shadePremulSpan<SkPMColor, ApplyPremul::True >(x, y, dst, count, bias0, bias1); |
| } |
| } |
| |
| void SkLinearGradient:: |
| LinearGradient4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) { |
| SkASSERT(count > 0); |
| |
| // 4f dests are dithered at a later stage, if needed. |
| static constexpr float bias0 = 0, |
| bias1 = 0; |
| if (fColorsArePremul) { |
| this->shadePremulSpan<SkPM4f, ApplyPremul::False>(x, y, dst, count, bias0, bias1); |
| } else { |
| this->shadePremulSpan<SkPM4f, ApplyPremul::True >(x, y, dst, count, bias0, bias1); |
| } |
| } |
| |
| template<typename dstType, ApplyPremul premul> |
| void SkLinearGradient:: |
| LinearGradient4fContext::shadePremulSpan(int x, int y, dstType dst[], int count, |
| float bias0, float bias1) const { |
| const SkLinearGradient& shader = static_cast<const SkLinearGradient&>(fShader); |
| switch (shader.fTileMode) { |
| case kClamp_TileMode: |
| this->shadeSpanInternal<dstType, premul, kClamp_TileMode >(x, y, dst, count, bias0, bias1); |
| break; |
| case kRepeat_TileMode: |
| this->shadeSpanInternal<dstType, premul, kRepeat_TileMode>(x, y, dst, count, bias0, bias1); |
| break; |
| case kMirror_TileMode: |
| this->shadeSpanInternal<dstType, premul, kMirror_TileMode>(x, y, dst, count, bias0, bias1); |
| break; |
| } |
| } |
| |
| template<typename dstType, ApplyPremul premul, SkShader::TileMode tileMode> |
| void SkLinearGradient:: |
| LinearGradient4fContext::shadeSpanInternal(int x, int y, dstType dst[], int count, |
| float bias0, float bias1) 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, premul, tileMode> proc(fIntervals->begin(), |
| fIntervals->end() - 1, |
| this->findInterval(fx), |
| fx, |
| dx, |
| SkScalarNearlyZero(dx * count)); |
| Sk4f bias4f0(bias0), |
| bias4f1(bias1); |
| |
| 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, |
| bias4f0, bias4f1); |
| } |
| |
| proc.advance(SkIntToScalar(n)); |
| count -= n; |
| dst += n; |
| |
| if (n & 1) { |
| SkTSwap(bias4f0, bias4f1); |
| } |
| } |
| } |
| |
| template<typename dstType, ApplyPremul premul, SkShader::TileMode tileMode> |
| class SkLinearGradient:: |
| LinearGradient4fContext::LinearIntervalProcessor { |
| public: |
| LinearIntervalProcessor(const Sk4fGradientInterval* firstInterval, |
| const Sk4fGradientInterval* lastInterval, |
| const Sk4fGradientInterval* i, |
| SkScalar fx, |
| SkScalar dx, |
| bool is_vertical) |
| : fAdvX(is_vertical ? SK_ScalarInfinity : (i->fT1 - fx) / dx) |
| , fFirstInterval(firstInterval) |
| , fLastInterval(lastInterval) |
| , fInterval(i) |
| , fDx(dx) |
| , fIsVertical(is_vertical) |
| { |
| SkASSERT(fAdvX >= 0); |
| SkASSERT(firstInterval <= lastInterval); |
| |
| if (tileMode != kClamp_TileMode && !is_vertical) { |
| const auto spanX = (lastInterval->fT1 - firstInterval->fT0) / dx; |
| SkASSERT(spanX >= 0); |
| |
| // If we're in a repeating tile mode and the whole gradient is compressed into a |
| // fraction of a pixel, we just use the average color in zero-ramp mode. |
| // This also avoids cases where we make no progress due to interval advances being |
| // close to zero. |
| static constexpr SkScalar kMinSpanX = .25f; |
| if (spanX < kMinSpanX) { |
| this->init_average_props(); |
| return; |
| } |
| } |
| |
| this->compute_interval_props(fx); |
| } |
| |
| SkScalar currentAdvance() const { |
| SkASSERT(fAdvX >= 0); |
| SkASSERT(fAdvX <= (fInterval->fT1 - fInterval->fT0) / fDx || !std::isfinite(fAdvX)); |
| 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) { |
| SkASSERT(in_range(t, fInterval->fT0, fInterval->fT1)); |
| |
| const Sk4f dc = DstTraits<dstType, premul>::load(fInterval->fCg); |
| fCc = DstTraits<dstType, premul>::load(fInterval->fCb) + dc * Sk4f(t); |
| fDcDx = dc * fDx; |
| fZeroRamp = fIsVertical || (dc == 0).allTrue(); |
| } |
| |
| void init_average_props() { |
| fAdvX = SK_ScalarInfinity; |
| fZeroRamp = true; |
| fDcDx = 0; |
| fCc = Sk4f(0); |
| |
| // TODO: precompute the average at interval setup time? |
| for (const auto* i = fFirstInterval; i <= fLastInterval; ++i) { |
| // Each interval contributes its average color to the total/weighted average: |
| // |
| // C = (c0 + c1) / 2 = (Cb + Cg * t0 + Cb + Cg * t1) / 2 = Cb + Cg *(t0 + t1) / 2 |
| // |
| // Avg += C * (t1 - t0) |
| // |
| const auto c = DstTraits<dstType, premul>::load(i->fCb) |
| + DstTraits<dstType, premul>::load(i->fCg) * (i->fT0 + i->fT1) * 0.5f; |
| fCc = fCc + c * (i->fT1 - i->fT0); |
| } |
| } |
| |
| const Sk4fGradientInterval* next_interval(const Sk4fGradientInterval* 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->fT1 - fInterval->fT0) / fDx; |
| SkASSERT(fAdvX > 0); |
| } while (advX >= fAdvX); |
| |
| compute_interval_props(fInterval->fT0); |
| |
| SkASSERT(advX >= 0); |
| return advX; |
| } |
| |
| // Current interval properties. |
| 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 Sk4fGradientInterval* fFirstInterval; |
| const Sk4fGradientInterval* fLastInterval; |
| const Sk4fGradientInterval* fInterval; // current interval |
| const SkScalar fDx; // 'dx' for consistency with other impls; actually dt/dx |
| const bool fIsVertical; |
| }; |