AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

4f linear gradient shader blitters

Browse Source 
Add F16 specializations to support writing to half-float dests.

Add color profile template arg across the board to support writing
to sRGB dests.

R=reed@google.com,mtklein@google.com,herb@google.com
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1808963005

Review URL: https://codereview.chromium.org/1808963005
This commit is contained in:
fmalita 2016-03-18 10:28:23 -07:00 committed by Commit bot
parent f28ad89427
commit a928b288b3
8 changed files with 244 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/core/SkPixmap.cpp
View File

@ -211,12 +211,6 @@ bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const {
#include "SkNx.h"
#include "SkHalf.h"
static void sk_memset64(uint64_t dst[], uint64_t value, int count) {
for (int i = 0; i < count; ++i) {
dst[i] = value;
}
}
bool SkPixmap::erase(const SkColor4f& origColor, const SkIRect* subset) const {
SkPixmap pm;
if (subset) {

10
src/core/SkUtils.h
View File

@ -32,6 +32,16 @@ static inline void sk_memset32(uint32_t buffer[], uint32_t value, int count) {
}
}
/** Similar to memset(), but it assigns a 64bit value into the buffer.
@param buffer The memory to have value copied into it
@param value The 64bit value to be copied into buffer
@param count The number of times value should be copied into the buffer.
*/
static inline void sk_memset64(uint64_t buffer[], uint64_t value, int count) {
for (int i = 0; i < count; i++) {
buffer[i] = value;
}
}
///////////////////////////////////////////////////////////////////////////////
#define kMaxBytesInUTF8Sequence 4

6
src/core/SkXfermodeU64.cpp
View File

@ -10,12 +10,6 @@
#include "SkUtils.h"
#include "SkXfermode.h"
static void sk_memset64(uint64_t dst[], uint64_t value, int count) {
for (int i = 0; i < count; ++i) {
dst[i] = value;
}
}
enum DstType {
kU16_Dst,
kF16_Dst,

25
src/effects/gradients/Sk4fGradientBase.cpp
View File

@ -6,7 +6,6 @@
*/
#include "Sk4fGradientBase.h"
#include "Sk4fGradientPriv.h"
#include <functional>
@ -277,22 +276,22 @@ GradientShaderBase4fContext::addMirrorIntervals(const SkGradientShaderBase& shad
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[],
@ -303,23 +302,23 @@ GradientShaderBase4fContext::shadePremulSpan(int x, int y,
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[],
@ -334,7 +333,7 @@ GradientShaderBase4fContext::shadeSpanInternal(int x, int y,
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;
@ -424,8 +423,8 @@ private:
}
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;

5
src/effects/gradients/Sk4fGradientBase.h
View File

@ -8,6 +8,7 @@
#ifndef Sk4fGradientBase_DEFINED
#define Sk4fGradientBase_DEFINED
#include "Sk4fGradientPriv.h"
#include "SkColor.h"
#include "SkGradientShaderPriv.h"
#include "SkMatrix.h"
@ -61,10 +62,10 @@ private:
template<typename DstType, SkShader::TileMode tileMode>
class TSampler;
template <typename DstType, bool do_premul>
template <typename DstType, ApplyPremul>
void shadePremulSpan(int x, int y, DstType[], int count) const;
template <typename DstType, bool do_premul, SkShader::TileMode tileMode>
template <typename DstType, ApplyPremul, SkShader::TileMode tileMode>
void shadeSpanInternal(int x, int y, DstType[], int count) const;
};

93
src/effects/gradients/Sk4fGradientPriv.h
View File

@ -9,85 +9,115 @@
#define Sk4fGradientPriv_DEFINED
#include "SkColor.h"
#include "SkHalf.h"
#include "SkImageInfo.h"
#include "SkNx.h"
#include "SkPM4f.h"
#include "SkPM4fPriv.h"
// Templates shared by various 4f gradient flavors.
namespace {
enum class ApplyPremul { True, False };
inline Sk4f premul_4f(const Sk4f& c) {
const float alpha = c[SkPM4f::A];
// FIXME: portable swizzle?
return c * Sk4f(alpha, alpha, alpha, 1);
}
template <bool do_premul>
inline SkPMColor trunc_from_255(const Sk4f& c) {
template <ApplyPremul premul>
inline SkPMColor trunc_from_4f_255(const Sk4f& c) {
SkPMColor pmc;
SkNx_cast<uint8_t>(c).store(&pmc);
if (do_premul) {
if (premul == ApplyPremul::True) {
pmc = SkPreMultiplyARGB(SkGetPackedA32(pmc), SkGetPackedR32(pmc),
SkGetPackedG32(pmc), SkGetPackedB32(pmc));
}
return pmc;
}
template<typename DstType, bool do_premul>
template<typename DstType, SkColorProfileType, ApplyPremul premul>
void store(const Sk4f& color, DstType* dst);
template<>
inline void store<SkPM4f, false>(const Sk4f& c, SkPM4f* dst) {
inline void store<SkPM4f, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, SkPM4f* dst) {
c.store(dst);
}
template<>
inline void store<SkPM4f, true>(const Sk4f& c, SkPM4f* dst) {
store<SkPM4f, false>(premul_4f(c), dst);
inline void store<SkPM4f, kLinear_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, SkPM4f* dst) {
premul_4f(c).store(dst);
}
template<>
inline void store<SkPMColor, false>(const Sk4f& c, SkPMColor* dst) {
*dst = trunc_from_255<false>(c);
inline void store<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, SkPMColor* dst) {
*dst = trunc_from_4f_255<ApplyPremul::False>(c);
}
template<>
inline void store<SkPMColor, true>(const Sk4f& c, SkPMColor* dst) {
*dst = trunc_from_255<true>(c);
inline void store<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, SkPMColor* dst) {
*dst = trunc_from_4f_255<ApplyPremul::True>(c);
}
template<typename DstType, bool do_premul>
template<>
inline void store<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, SkPMColor* dst) {
// FIXME: this assumes opaque colors. Handle unpremultiplication.
*dst = Sk4f_toS32(c);
}
template<>
inline void store<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, SkPMColor* dst) {
*dst = Sk4f_toS32(premul_4f(c));
}
template<>
inline void store<uint64_t, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, uint64_t* dst) {
*dst = SkFloatToHalf_01(c);
}
template<>
inline void store<uint64_t, kLinear_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, uint64_t* dst) {
*dst = SkFloatToHalf_01(premul_4f(c));
}
template<typename DstType, SkColorProfileType profile, ApplyPremul premul>
inline void store4x(const Sk4f& c0,
const Sk4f& c1,
const Sk4f& c2,
const Sk4f& c3,
DstType* dst) {
store<DstType, do_premul>(c0, dst++);
store<DstType, do_premul>(c1, dst++);
store<DstType, do_premul>(c2, dst++);
store<DstType, do_premul>(c3, dst++);
store<DstType, profile, premul>(c0, dst++);
store<DstType, profile, premul>(c1, dst++);
store<DstType, profile, premul>(c2, dst++);
store<DstType, profile, premul>(c3, dst++);
}
template<>
inline void store4x<SkPMColor, false>(const Sk4f& c0,
const Sk4f& c1,
const Sk4f& c2,
const Sk4f& c3,
SkPMColor* dst) {
inline void store4x<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c0, const Sk4f& c1,
const Sk4f& c2, const Sk4f& c3,
SkPMColor* dst) {
Sk4f_ToBytes((uint8_t*)dst, c0, c1, c2, c3);
}
template<typename DstType>
float dst_component_scale();
template<>
inline float dst_component_scale<SkPM4f>() {
return 1;
template<typename DstType, SkColorProfileType>
Sk4f scale_for_dest(const Sk4f& c) {
return c;
}
template<>
inline float dst_component_scale<SkPMColor>() {
return 255;
inline Sk4f scale_for_dest<SkPMColor, kLinear_SkColorProfileType>(const Sk4f& c) {
return c * 255;
}
template<typename DstType>
@ -103,6 +133,11 @@ inline Sk4f dst_swizzle<SkPMColor>(const SkPM4f& c) {
return c.to4f_pmorder();
}
template<>
inline Sk4f dst_swizzle<uint64_t>(const SkPM4f& c) {
return c.to4f();
}
}
#endif // Sk4fGradientPriv_DEFINED

186
src/effects/gradients/Sk4fLinearGradient.cpp
View File

@ -5,16 +5,18 @@
* found in the LICENSE file.
*/
#include "Sk4fGradientPriv.h"
#include "Sk4fLinearGradient.h"
#include "SkUtils.h"
#include "SkXfermode.h"
namespace {
template<typename DstType, bool do_premul>
template<typename DstType, SkColorProfileType, ApplyPremul>
void fill(const Sk4f& c, DstType* dst, int n);
template<>
void fill<SkPM4f, false>(const Sk4f& c, SkPM4f* dst, int n) {
void fill<SkPM4f, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, SkPM4f* dst, int n) {
while (n > 0) {
c.store(dst++);
n--;
@ -22,21 +24,49 @@ void fill<SkPM4f, false>(const Sk4f& c, SkPM4f* dst, int n) {
}
template<>
void fill<SkPM4f, true>(const Sk4f& c, SkPM4f* dst, int n) {
fill<SkPM4f, false>(premul_4f(c), dst, n);
void fill<SkPM4f, kLinear_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, SkPM4f* dst, int n) {
fill<SkPM4f, kLinear_SkColorProfileType, ApplyPremul::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);
void fill<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, SkPMColor* dst, int n) {
sk_memset32(dst, trunc_from_4f_255<ApplyPremul::False>(c), n);
}
template<>
void fill<SkPMColor, true>(const Sk4f& c, SkPMColor* dst, int n) {
sk_memset32(dst, trunc_from_255<true>(c), n);
void fill<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, SkPMColor* dst, int n) {
sk_memset32(dst, trunc_from_4f_255<ApplyPremul::True>(c), n);
}
template<typename DstType, bool do_premul>
template<>
void fill<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, SkPMColor* dst, int n) {
// FIXME: this assumes opaque colors. Handle unpremultiplication.
sk_memset32(dst, Sk4f_toS32(c), n);
}
template<>
void fill<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, SkPMColor* dst, int n) {
sk_memset32(dst, Sk4f_toS32(premul_4f(c)), n);
}
template<>
void fill<uint64_t, kLinear_SkColorProfileType, ApplyPremul::False>
(const Sk4f& c, uint64_t* dst, int n) {
sk_memset64(dst, SkFloatToHalf_01(c), n);
}
template<>
void fill<uint64_t, kLinear_SkColorProfileType, ApplyPremul::True>
(const Sk4f& c, uint64_t* dst, int n) {
sk_memset64(dst, SkFloatToHalf_01(premul_4f(c)), n);
}
template<typename DstType, SkColorProfileType profile, ApplyPremul premul>
void ramp(const Sk4f& c, const Sk4f& dc, DstType* dst, int n) {
SkASSERT(n > 0);
@ -49,7 +79,7 @@ void ramp(const Sk4f& c, const Sk4f& dc, DstType* dst, int n) {
Sk4f c3 = c1 + dc2;
while (n >= 4) {
store4x<DstType, do_premul>(c0, c1, c2, c3, dst);
store4x<DstType, profile, premul>(c0, c1, c2, c3, dst);
dst += 4;
c0 = c0 + dc4;
@ -59,12 +89,12 @@ void ramp(const Sk4f& c, const Sk4f& dc, DstType* dst, int n) {
n -= 4;
}
if (n & 2) {
store<DstType, do_premul>(c0, dst++);
store<DstType, do_premul>(c1, dst++);
store<DstType, profile, premul>(c0, dst++);
store<DstType, profile, premul>(c1, dst++);
c0 = c0 + dc2;
}
if (n & 1) {
store<DstType, do_premul>(c0, dst);
store<DstType, profile, premul>(c0, dst);
}
}
@ -163,9 +193,13 @@ LinearGradient4fContext::shadeSpan(int x, int y, SkPMColor dst[], int count) {
// TODO: plumb dithering
SkASSERT(count > 0);
if (fColorsArePremul) {
this->shadePremulSpan<SkPMColor, false>(x, y, dst, count);
this->shadePremulSpan<SkPMColor,
kLinear_SkColorProfileType,
ApplyPremul::False>(x, y, dst, count);
} else {
this->shadePremulSpan<SkPMColor, true>(x, y, dst, count);
this->shadePremulSpan<SkPMColor,
kLinear_SkColorProfileType,
ApplyPremul::True>(x, y, dst, count);
}
}
@ -179,13 +213,17 @@ LinearGradient4fContext::shadeSpan4f(int x, int y, SkPM4f dst[], int count) {
// TONOTDO: plumb dithering
SkASSERT(count > 0);
if (fColorsArePremul) {
this->shadePremulSpan<SkPM4f, false>(x, y, dst, count);
this->shadePremulSpan<SkPM4f,
kLinear_SkColorProfileType,
ApplyPremul::False>(x, y, dst, count);
} else {
this->shadePremulSpan<SkPM4f, true>(x, y, dst, count);
this->shadePremulSpan<SkPM4f,
kLinear_SkColorProfileType,
ApplyPremul::True>(x, y, dst, count);
}
}
template<typename DstType, bool do_premul>
template<typename DstType, SkColorProfileType profile, ApplyPremul premul>
void SkLinearGradient::
LinearGradient4fContext::shadePremulSpan(int x, int y,
DstType dst[],
@ -195,23 +233,27 @@ LinearGradient4fContext::shadePremulSpan(int x, int y,
switch (shader.fTileMode) {
case kClamp_TileMode:
this->shadeSpanInternal<DstType,
do_premul,
profile,
premul,
kClamp_TileMode>(x, y, dst, count);
break;
case kRepeat_TileMode:
this->shadeSpanInternal<DstType,
do_premul,
profile,
premul,
kRepeat_TileMode>(x, y, dst, count);
break;
case kMirror_TileMode:
this->shadeSpanInternal<DstType,
do_premul,
profile,
premul,
kMirror_TileMode>(x, y, dst, count);
break;
}
}
template<typename DstType, bool do_premul, SkShader::TileMode tileMode>
template<typename DstType, SkColorProfileType profile, ApplyPremul premul,
SkShader::TileMode tileMode>
void SkLinearGradient::
LinearGradient4fContext::shadeSpanInternal(int x, int y,
DstType dst[],
@ -223,12 +265,12 @@ LinearGradient4fContext::shadeSpanInternal(int x, int y,
&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, profile, 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.
@ -243,12 +285,12 @@ LinearGradient4fContext::shadeSpanInternal(int x, int y,
|| (n == count && proc.currentRampIsZero()));
if (proc.currentRampIsZero()) {
fill<DstType, do_premul>(proc.currentColor(),
dst, n);
fill<DstType, profile, premul>(proc.currentColor(),
dst, n);
} else {
ramp<DstType, do_premul>(proc.currentColor(),
proc.currentColorGrad(),
dst, n);
ramp<DstType, profile, premul>(proc.currentColor(),
proc.currentColorGrad(),
dst, n);
}
proc.advance(SkIntToScalar(n));
@ -257,7 +299,7 @@ LinearGradient4fContext::shadeSpanInternal(int x, int y,
}
}
template<typename DstType, SkShader::TileMode tileMode>
template<typename DstType, SkColorProfileType profile, SkShader::TileMode tileMode>
class SkLinearGradient::
LinearGradient4fContext::LinearIntervalProcessor {
public:
@ -267,8 +309,7 @@ public:
SkScalar fx,
SkScalar dx,
bool is_vertical)
: fDstComponentScale(dst_component_scale<DstType>())
, fAdvX((i->fP1 - fx) / dx)
: fAdvX((i->fP1 - fx) / dx)
, fFirstInterval(firstInterval)
, fLastInterval(lastInterval)
, fInterval(i)
@ -308,8 +349,8 @@ private:
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);
fCc = scale_for_dest<DstType, profile>(fCc);
fDcDx = scale_for_dest<DstType, profile>(fDc * Sk4f(fDx));
fZeroRamp = fIsVertical || fInterval->isZeroRamp();
}
@ -342,8 +383,6 @@ private:
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)
@ -402,3 +441,68 @@ LinearGradient4fContext::mapTs(int x, int y, SkScalar ts[], int count) const {
}
}
}
SkShader::Context::BlitProc SkLinearGradient::
LinearGradient4fContext::onChooseBlitProc(const SkImageInfo& info, BlitState* state) {
SkXfermode::Mode mode;
if (!SkXfermode::AsMode(state->fXfer, &mode)) {
return nullptr;
}
const SkGradientShaderBase& shader = static_cast<const SkGradientShaderBase&>(fShader);
if (mode != SkXfermode::kSrc_Mode &&
!(mode == SkXfermode::kSrcOver_Mode && shader.colorsAreOpaque())) {
return nullptr;
}
switch (info.colorType()) {
case kN32_SkColorType:
return D32_BlitProc;
case kRGBA_F16_SkColorType:
return D64_BlitProc;
default:
return nullptr;
}
}
void SkLinearGradient::
LinearGradient4fContext::D32_BlitProc(BlitState* state, int x, int y, const SkPixmap& dst,
int count, const SkAlpha aa[]) {
// FIXME: ignoring coverage for now
const LinearGradient4fContext* ctx =
static_cast<const LinearGradient4fContext*>(state->fCtx);
if (dst.info().isLinear()) {
if (ctx->fColorsArePremul) {
ctx->shadePremulSpan<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::False>(
x, y, dst.writable_addr32(x, y), count);
} else {
ctx->shadePremulSpan<SkPMColor, kLinear_SkColorProfileType, ApplyPremul::True>(
x, y, dst.writable_addr32(x, y), count);
}
} else {
if (ctx->fColorsArePremul) {
ctx->shadePremulSpan<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::False>(
x, y, dst.writable_addr32(x, y), count);
} else {
ctx->shadePremulSpan<SkPMColor, kSRGB_SkColorProfileType, ApplyPremul::True>(
x, y, dst.writable_addr32(x, y), count);
}
}
}
void SkLinearGradient::
LinearGradient4fContext::D64_BlitProc(BlitState* state, int x, int y, const SkPixmap& dst,
int count, const SkAlpha aa[]) {
// FIXME: ignoring coverage for now
const LinearGradient4fContext* ctx =
static_cast<const LinearGradient4fContext*>(state->fCtx);
if (ctx->fColorsArePremul) {
ctx->shadePremulSpan<uint64_t, kLinear_SkColorProfileType, ApplyPremul::False>(
x, y, dst.writable_addr64(x, y), count);
} else {
ctx->shadePremulSpan<uint64_t, kLinear_SkColorProfileType, ApplyPremul::True>(
x, y, dst.writable_addr64(x, y), count);
}
}

13
src/effects/gradients/Sk4fLinearGradient.h
View File

@ -22,22 +22,29 @@ public:
protected:
void mapTs(int x, int y, SkScalar ts[], int count) const override;
BlitProc onChooseBlitProc(const SkImageInfo&, BlitState*) override;
private:
using INHERITED = GradientShaderBase4fContext;
template<typename DstType, TileMode>
template<typename DstType, SkColorProfileType, TileMode>
class LinearIntervalProcessor;
template <typename DstType, bool premul>
template <typename DstType, SkColorProfileType, ApplyPremul>
void shadePremulSpan(int x, int y, DstType[], int count) const;
template <typename DstType, bool premul, SkShader::TileMode tileMode>
template <typename DstType, SkColorProfileType, ApplyPremul, SkShader::TileMode tileMode>
void shadeSpanInternal(int x, int y, DstType[], int count) const;
const Interval* findInterval(SkScalar fx) const;
bool isFast() const { return fDstToPosClass == kLinear_MatrixClass; }
static void D32_BlitProc(BlitState* state, int x, int y, const SkPixmap& dst,
int count, const SkAlpha aa[]);
static void D64_BlitProc(BlitState*, int x, int y, const SkPixmap& dst,
int count, const SkAlpha aa[]);
mutable const Interval* fCachedInterval;
};