SkGradientBaseShader.cpp File Reference

#include "src/shaders/gradients/SkGradientBaseShader.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkShader.h"
#include "include/core/SkTileMode.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkArenaAlloc.h"
#include "src/base/SkFloatBits.h"
#include "src/base/SkVx.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkColorSpaceXformSteps.h"
#include "src/core/SkConvertPixels.h"
#include "src/core/SkEffectPriv.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkRasterPipelineOpContexts.h"
#include "src/core/SkRasterPipelineOpList.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkWriteBuffer.h"
#include <algorithm>
#include <cmath>
#include <optional>
#include <utility>

Go to the source code of this file.

Typedefs
using	ConvertColorProc = SkPMColor4f(*)(SkPMColor4f, bool *)
using	PremulColorProc = SkPMColor4f(*)(SkPMColor4f)

Enumerations
enum	GradientSerializationFlags {   kHasPosition_GSF = 0x80000000 , kHasLegacyLocalMatrix_GSF = 0x40000000 , kHasColorSpace_GSF = 0x20000000 , kTileModeShift_GSF = 8 ,   kTileModeMask_GSF = 0xF , kInterpolationColorSpaceShift_GSF = 4 , kInterpolationColorSpaceMask_GSF = 0xF , kInterpolationHueMethodShift_GSF = 1 ,   kInterpolationHueMethodMask_GSF = 0x7 , kInterpolationInPremul_GSF = 0x1 }

Functions
template<int N, typename T , bool MEM_MOVE>
static bool	validate_array (SkReadBuffer &buffer, size_t count, STArray< N, T, MEM_MOVE > *array)
static void	add_stop_color (SkRasterPipeline_GradientCtx *ctx, size_t stop, SkPMColor4f Fs, SkPMColor4f Bs)
static void	add_const_color (SkRasterPipeline_GradientCtx *ctx, size_t stop, SkPMColor4f color)
static void	init_stop_evenly (SkRasterPipeline_GradientCtx *ctx, float gapCount, size_t stop, SkPMColor4f c_l, SkPMColor4f c_r)
static void	init_stop_pos (SkRasterPipeline_GradientCtx *ctx, size_t stop, float t_l, float c_scale, SkPMColor4f c_l, SkPMColor4f c_r)
static sk_sp< SkColorSpace >	intermediate_color_space (SkGradientShader::Interpolation::ColorSpace cs, SkColorSpace *dst)
static SkPMColor4f	srgb_to_hsl (SkPMColor4f rgb, bool *hueIsPowerless)
static SkPMColor4f	srgb_to_hwb (SkPMColor4f rgb, bool *hueIsPowerless)
static SkPMColor4f	xyzd50_to_lab (SkPMColor4f xyz, bool *)
static SkPMColor4f	xyzd50_to_hcl (SkPMColor4f xyz, bool *hueIsPowerless)
static SkPMColor4f	lin_srgb_to_oklab (SkPMColor4f rgb, bool *)
static SkPMColor4f	lin_srgb_to_okhcl (SkPMColor4f rgb, bool *hueIsPowerless)
static SkPMColor4f	premul_polar (SkPMColor4f hsl)
static SkPMColor4f	premul_rgb (SkPMColor4f rgb)
static bool	color_space_is_polar (SkGradientShader::Interpolation::ColorSpace cs)
static SkColor4f	average_gradient_color (const SkColor4f colors[], const SkScalar pos[], int colorCount)

Typedef Documentation

ConvertColorProc

using ConvertColorProc = SkPMColor4f(*)(SkPMColor4f, bool*)

Definition at line 600 of file SkGradientBaseShader.cpp.

PremulColorProc

using PremulColorProc = SkPMColor4f(*)(SkPMColor4f)

Definition at line 601 of file SkGradientBaseShader.cpp.

Enumeration Type Documentation

GradientSerializationFlags

enum GradientSerializationFlags

Enumerator
kHasPosition_GSF
kHasLegacyLocalMatrix_GSF
kHasColorSpace_GSF
kTileModeShift_GSF
kTileModeMask_GSF
kInterpolationColorSpaceShift_GSF
kInterpolationColorSpaceMask_GSF
kInterpolationHueMethodShift_GSF
kInterpolationHueMethodMask_GSF
kInterpolationInPremul_GSF

Definition at line 45 of file SkGradientBaseShader.cpp.

                                {
    // Bits 29:31 used for various boolean flags
    kHasPosition_GSF          = 0x80000000,
    kHasLegacyLocalMatrix_GSF = 0x40000000,
    kHasColorSpace_GSF        = 0x20000000,
 
    // Bits 12:28 unused
 
    // Bits 8:11 for fTileMode
    kTileModeShift_GSF  = 8,
    kTileModeMask_GSF   = 0xF,
 
    // Bits 4:7 for fInterpolation.fColorSpace
    kInterpolationColorSpaceShift_GSF = 4,
    kInterpolationColorSpaceMask_GSF  = 0xF,
 
    // Bits 1:3 for fInterpolation.fHueMethod
    kInterpolationHueMethodShift_GSF = 1,
    kInterpolationHueMethodMask_GSF  = 0x7,
 
    // Bit 0 for fInterpolation.fInPremul
    kInterpolationInPremul_GSF = 0x1,
};

Function Documentation

add_const_color()

static void add_const_color ( SkRasterPipeline_GradientCtx *  ctx, size_t  stop, SkPMColor4f  color  )

static

Definition at line 272 of file SkGradientBaseShader.cpp.

                                                                                               {
    add_stop_color(ctx, stop, {0, 0, 0, 0}, color);
}

add_stop_color()

static void add_stop_color ( SkRasterPipeline_GradientCtx *  ctx, size_t  stop, SkPMColor4f  Fs, SkPMColor4f  Bs  )

static

Definition at line 257 of file SkGradientBaseShader.cpp.

                                           {
    (ctx->fs[0])[stop] = Fs.fR;
    (ctx->fs[1])[stop] = Fs.fG;
    (ctx->fs[2])[stop] = Fs.fB;
    (ctx->fs[3])[stop] = Fs.fA;
 
    (ctx->bs[0])[stop] = Bs.fR;
    (ctx->bs[1])[stop] = Bs.fG;
    (ctx->bs[2])[stop] = Bs.fB;
    (ctx->bs[3])[stop] = Bs.fA;
}

average_gradient_color()

static SkColor4f average_gradient_color ( const SkColor4f  colors[], const SkScalar  pos[], int  colorCount  )

static

Definition at line 972 of file SkGradientBaseShader.cpp.

                                                        {
    // The gradient is a piecewise linear interpolation between colors. For a given interval,
    // the integral between the two endpoints is 0.5 * (ci + cj) * (pj - pi), which provides that
    // intervals average color. The overall average color is thus the sum of each piece. The thing
    // to keep in mind is that the provided gradient definition may implicitly use p=0 and p=1.
    skvx::float4 blend(0.0f);
    for (int i = 0; i < colorCount - 1; ++i) {
        // Calculate the average color for the interval between pos(i) and pos(i+1)
        auto c0 = skvx::float4::Load(&colors[i]);
        auto c1 = skvx::float4::Load(&colors[i + 1]);
 
        // when pos == null, there are colorCount uniformly distributed stops, going from 0 to 1,
        // so pos[i + 1] - pos[i] = 1/(colorCount-1)
        SkScalar w;
        if (pos) {
            // Match position fixing in SkGradientShader's constructor, clamping positions outside
            // [0, 1] and forcing the sequence to be monotonic
            SkScalar p0 = SkTPin(pos[i], 0.f, 1.f);
            SkScalar p1 = SkTPin(pos[i + 1], p0, 1.f);
            w = p1 - p0;
 
            // And account for any implicit intervals at the start or end of the positions
            if (i == 0) {
                if (p0 > 0.0f) {
                    // The first color is fixed between p = 0 to pos[0], so 0.5*(ci + cj)*(pj - pi)
                    // becomes 0.5*(c + c)*(pj - 0) = c * pj
                    auto c = skvx::float4::Load(&colors[0]);
                    blend += p0 * c;
                }
            }
            if (i == colorCount - 2) {
                if (p1 < 1.f) {
                    // The last color is fixed between pos[n-1] to p = 1, so 0.5*(ci + cj)*(pj - pi)
                    // becomes 0.5*(c + c)*(1 - pi) = c * (1 - pi)
                    auto c = skvx::float4::Load(&colors[colorCount - 1]);
                    blend += (1.f - p1) * c;
                }
            }
        } else {
            w = 1.f / (colorCount - 1);
        }
 
        blend += 0.5f * w * (c1 + c0);
    }
 
    SkColor4f avg;
    blend.store(&avg);
    return avg;
}

color_space_is_polar()

static bool color_space_is_polar ( SkGradientShader::Interpolation::ColorSpace  cs )

static

Definition at line 699 of file SkGradientBaseShader.cpp.

                                                                             {
    using ColorSpace = SkGradientShader::Interpolation::ColorSpace;
    switch (cs) {
        case ColorSpace::kLCH:
        case ColorSpace::kOKLCH:
        case ColorSpace::kHSL:
        case ColorSpace::kHWB:
            return true;
        default:
            return false;
    }
}

init_stop_evenly()

static void init_stop_evenly ( SkRasterPipeline_GradientCtx *  ctx, float  gapCount, size_t  stop, SkPMColor4f  c_l, SkPMColor4f  c_r  )

static

Definition at line 278 of file SkGradientBaseShader.cpp.

                                              {
    // Clankium's GCC 4.9 targeting ARMv7 is barfing when we use Sk4f math here, so go scalar...
    SkPMColor4f Fs = {
            (c_r.fR - c_l.fR) * gapCount,
            (c_r.fG - c_l.fG) * gapCount,
            (c_r.fB - c_l.fB) * gapCount,
            (c_r.fA - c_l.fA) * gapCount,
    };
    SkPMColor4f Bs = {
            c_l.fR - Fs.fR * (stop / gapCount),
            c_l.fG - Fs.fG * (stop / gapCount),
            c_l.fB - Fs.fB * (stop / gapCount),
            c_l.fA - Fs.fA * (stop / gapCount),
    };
    add_stop_color(ctx, stop, Fs, Bs);
}

init_stop_pos()

static void init_stop_pos ( SkRasterPipeline_GradientCtx *  ctx, size_t  stop, float  t_l, float  c_scale, SkPMColor4f  c_l, SkPMColor4f  c_r  )

static

Definition at line 301 of file SkGradientBaseShader.cpp.

                                           {
    // See note about Clankium's old compiler in init_stop_evenly().
    SkPMColor4f Fs = {
            (c_r.fR - c_l.fR) * c_scale,
            (c_r.fG - c_l.fG) * c_scale,
            (c_r.fB - c_l.fB) * c_scale,
            (c_r.fA - c_l.fA) * c_scale,
    };
    SkPMColor4f Bs = {
            c_l.fR - Fs.fR * t_l,
            c_l.fG - Fs.fG * t_l,
            c_l.fB - Fs.fB * t_l,
            c_l.fA - Fs.fA * t_l,
    };
    ctx->ts[stop] = t_l;
    add_stop_color(ctx, stop, Fs, Bs);
}

intermediate_color_space()

static sk_sp< SkColorSpace > intermediate_color_space ( SkGradientShader::Interpolation::ColorSpace  cs, SkColorSpace *  dst  )

static

Definition at line 563 of file SkGradientBaseShader.cpp.

                                                                       {
    using ColorSpace = SkGradientShader::Interpolation::ColorSpace;
    switch (cs) {
        case ColorSpace::kDestination:
            return sk_ref_sp(dst);
 
        // css-color-4 allows XYZD50 and XYZD65. For gradients, those are redundant. Interpolating
        // in any linear RGB space, (regardless of white point), gives the same answer.
        case ColorSpace::kSRGBLinear:
            return SkColorSpace::MakeSRGBLinear();
 
        case ColorSpace::kSRGB:
        case ColorSpace::kHSL:
        case ColorSpace::kHWB:
            return SkColorSpace::MakeSRGB();
 
        case ColorSpace::kLab:
        case ColorSpace::kLCH:
            // Conversion to Lab (and LCH) starts with XYZD50
            return SkColorSpace::MakeRGB(SkNamedTransferFn::kLinear, SkNamedGamut::kXYZ);
 
        case ColorSpace::kOKLab:
        case ColorSpace::kOKLabGamutMap:
        case ColorSpace::kOKLCH:
        case ColorSpace::kOKLCHGamutMap:
            // The "standard" conversion to these spaces starts with XYZD65. That requires extra
            // effort to conjure. The author also has reference code for going directly from linear
            // sRGB, so we use that.
            // TODO(skia:13108): Even better would be to have an LMS color space, because the first
            // part of the conversion is a matrix multiply, which could be absorbed into the
            // color space xform.
            return SkColorSpace::MakeSRGBLinear();
    }
    SkUNREACHABLE;
}

lin_srgb_to_okhcl()

static SkPMColor4f lin_srgb_to_okhcl ( SkPMColor4f  rgb, bool *  hueIsPowerless  )

static

Definition at line 679 of file SkGradientBaseShader.cpp.

                                                                            {
    SkPMColor4f OKLab = lin_srgb_to_oklab(rgb, hueIsPowerless);
    float hue = sk_float_radians_to_degrees(atan2f(OKLab[2], OKLab[1]));
    float chroma = sqrtf(OKLab[1] * OKLab[1] + OKLab[2] * OKLab[2]);
    // The OKLCH math produces very small chroma values for achromatic colors:
    constexpr float kMaxChromaForPowerlessHue = 1e-6f;
    if (chroma <= kMaxChromaForPowerlessHue) {
        *hueIsPowerless = true;
    }
    return {hue >= 0 ? hue : hue + 360, chroma, OKLab[0], rgb.fA};
}

lin_srgb_to_oklab()

static SkPMColor4f lin_srgb_to_oklab ( SkPMColor4f  rgb, bool *    )

static

Definition at line 664 of file SkGradientBaseShader.cpp.

                                                               {
    float l = 0.4122214708f * rgb.fR + 0.5363325363f * rgb.fG + 0.0514459929f * rgb.fB;
    float m = 0.2119034982f * rgb.fR + 0.6806995451f * rgb.fG + 0.1073969566f * rgb.fB;
    float s = 0.0883024619f * rgb.fR + 0.2817188376f * rgb.fG + 0.6299787005f * rgb.fB;
    l = std::cbrtf(l);
    m = std::cbrtf(m);
    s = std::cbrtf(s);
    return {0.2104542553f * l + 0.7936177850f * m - 0.0040720468f * s,
            1.9779984951f * l - 2.4285922050f * m + 0.4505937099f * s,
            0.0259040371f * l + 0.7827717662f * m - 0.8086757660f * s,
            rgb.fA};
}

premul_polar()

static SkPMColor4f premul_polar ( SkPMColor4f  hsl )

static

Definition at line 691 of file SkGradientBaseShader.cpp.

                                                 {
    return {hsl.fR, hsl.fG * hsl.fA, hsl.fB * hsl.fA, hsl.fA};
}

premul_rgb()

static SkPMColor4f premul_rgb ( SkPMColor4f  rgb )

static

Definition at line 695 of file SkGradientBaseShader.cpp.

                                               {
    return {rgb.fR * rgb.fA, rgb.fG * rgb.fA, rgb.fB * rgb.fA, rgb.fA};
}

srgb_to_hsl()

static SkPMColor4f srgb_to_hsl ( SkPMColor4f  rgb, bool *  hueIsPowerless  )

static

Definition at line 603 of file SkGradientBaseShader.cpp.

                                                                      {
    float mx = std::max({rgb.fR, rgb.fG, rgb.fB});
    float mn = std::min({rgb.fR, rgb.fG, rgb.fB});
    float hue = 0, sat = 0, light = (mn + mx) / 2;
    float d = mx - mn;
 
    if (d != 0) {
        sat = (light == 0 || light == 1) ? 0 : (mx - light) / std::min(light, 1 - light);
        if (mx == rgb.fR) {
            hue = (rgb.fG - rgb.fB) / d + (rgb.fG < rgb.fB ? 6 : 0);
        } else if (mx == rgb.fG) {
            hue = (rgb.fB - rgb.fR) / d + 2;
        } else {
            hue = (rgb.fR - rgb.fG) / d + 4;
        }
 
        hue *= 60;
    }
    if (sat == 0) {
        *hueIsPowerless = true;
    }
    return {hue, sat * 100, light * 100, rgb.fA};
}

srgb_to_hwb()

static SkPMColor4f srgb_to_hwb ( SkPMColor4f  rgb, bool *  hueIsPowerless  )

static

Definition at line 627 of file SkGradientBaseShader.cpp.

                                                                      {
    SkPMColor4f hsl = srgb_to_hsl(rgb, hueIsPowerless);
    float white = std::min({rgb.fR, rgb.fG, rgb.fB});
    float black = 1 - std::max({rgb.fR, rgb.fG, rgb.fB});
    return {hsl.fR, white * 100, black * 100, rgb.fA};
}

validate_array()

template<int N, typename T , bool MEM_MOVE>

static bool validate_array ( SkReadBuffer &  buffer, size_t  count, STArray< N, T, MEM_MOVE > *  array  )

static

Definition at line 121 of file SkGradientBaseShader.cpp.

                                                                                               {
    if (!buffer.validateCanReadN<T>(count)) {
        return false;
    }
 
    array->resize_back(count);
    return true;
}

xyzd50_to_hcl()

static SkPMColor4f xyzd50_to_hcl ( SkPMColor4f  xyz, bool *  hueIsPowerless  )

static

Definition at line 651 of file SkGradientBaseShader.cpp.

                                                                        {
    SkPMColor4f Lab = xyzd50_to_lab(xyz, hueIsPowerless);
    float hue = sk_float_radians_to_degrees(atan2f(Lab[2], Lab[1]));
    float chroma = sqrtf(Lab[1] * Lab[1] + Lab[2] * Lab[2]);
    // The LCH math produces small-ish (but not tiny) chroma values for achromatic colors:
    constexpr float kMaxChromaForPowerlessHue = 1e-2f;
    if (chroma <= kMaxChromaForPowerlessHue) {
        *hueIsPowerless = true;
    }
    return {hue >= 0 ? hue : hue + 360, chroma, Lab[0], xyz.fA};
}

xyzd50_to_lab()

static SkPMColor4f xyzd50_to_lab ( SkPMColor4f  xyz, bool *    )

static

Definition at line 634 of file SkGradientBaseShader.cpp.

                                                           {
    constexpr float D50[3] = {0.3457f / 0.3585f, 1.0f, (1.0f - 0.3457f - 0.3585f) / 0.3585f};
 
    constexpr float e = 216.0f / 24389;
    constexpr float k = 24389.0f / 27;
 
    SkPMColor4f f;
    for (int i = 0; i < 3; ++i) {
        float v = xyz[i] / D50[i];
        f[i] = (v > e) ? std::cbrtf(v) : (k * v + 16) / 116;
    }
 
    return {(116 * f[1]) - 16, 500 * (f[0] - f[1]), 200 * (f[1] - f[2]), xyz.fA};
}