#include "include/core/SkTypes.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkSpan_impl.h"
#include "include/private/base/SkTemplates.h"
#include "modules/skcms/skcms.h"
#include "src/base/SkUtils.h"
#include "src/core/SkRasterPipeline.h"
#include "src/core/SkRasterPipelineContextUtils.h"
#include "src/shaders/SkPerlinNoiseShaderType.h"
#include "src/sksl/tracing/SkSLTraceHook.h"
#include <cstdint>
#include <type_traits>
#include <math.h>

Classes
struct	Ctx

struct	SK_OPTS_NS::Params

struct	SK_OPTS_NS::RGB

Namespaces
namespace	SK_OPTS_NS

namespace	SK_OPTS_NS::lowp

Macros
#define	SI static inline

#define	SK_UNROLL

#define	JUMPER_IS_SCALAR

#define	ABI

#define	JUMPER_NARROW_STAGES 1

#define	JUMPER_MUSTTAIL

#define	DECLARE_STAGE(name, ARG, STAGE_RET, INC, OFFSET, MUSTTAIL)

#define	STAGE(name, arg) DECLARE_STAGE(name, arg, void, ++program, /no offset/, /no musttail/)

#define	STAGE_TAIL(name, arg) DECLARE_STAGE(name, arg, void, ++program, /no offset/, JUMPER_MUSTTAIL)

#define	STAGE_BRANCH(name, arg) DECLARE_STAGE(name, arg, int, /no increment/, program +=, JUMPER_MUSTTAIL)

#define	BLEND_MODE(name)

#define	BLEND_MODE(name)

#define	execution_mask() sk_bit_cast<I32>(a)

#define	update_execution_mask()

#define	DECLARE_UNARY_FLOAT(name)

#define	DECLARE_UNARY_INT(name)

#define	DECLARE_UNARY_UINT(name)

#define	DECLARE_N_WAY_BINARY_FLOAT(name)

#define	DECLARE_BINARY_FLOAT(name)

#define	DECLARE_N_WAY_BINARY_INT(name)

#define	DECLARE_BINARY_INT(name)

#define	DECLARE_N_WAY_BINARY_UINT(name)

#define	DECLARE_BINARY_UINT(name)

#define	DECLARE_IMM_BINARY_FLOAT(name)

#define	DECLARE_IMM_BINARY_INT(name)

#define	DECLARE_MULTI_IMM_BINARY_INT(name)

#define	DECLARE_IMM_BINARY_UINT(name)

#define	DECLARE_N_WAY_TERNARY_FLOAT(name)

#define	DECLARE_TERNARY_FLOAT(name)

#define	DECLARE_TERNARY_INT(name)

#define	M(st) static void (*st)(void) = nullptr;

Typedefs
using	NoCtx = const void *

using	SK_OPTS_NS::F = float

using	SK_OPTS_NS::I32 = int32_t

using	SK_OPTS_NS::U64 = uint64_t

using	SK_OPTS_NS::U32 = uint32_t

using	SK_OPTS_NS::U16 = uint16_t

using	SK_OPTS_NS::U8 = uint8_t

using	SK_OPTS_NS::Stage = void(ABI )(Params , SkRasterPipelineStage *program, F r, F g, F b, F a)

Functions
template<typename Dst , typename Src >
SI Dst	widen_cast (const Src &src)

SI F	SK_OPTS_NS::min (F a, F b)

SI I32	SK_OPTS_NS::min (I32 a, I32 b)

SI U32	SK_OPTS_NS::min (U32 a, U32 b)

SI F	SK_OPTS_NS::max (F a, F b)

SI I32	SK_OPTS_NS::max (I32 a, I32 b)

SI U32	SK_OPTS_NS::max (U32 a, U32 b)

SI F	SK_OPTS_NS::mad (F f, F m, F a)

SI F	SK_OPTS_NS::nmad (F f, F m, F a)

SI F	SK_OPTS_NS::abs_ (F v)

SI I32	SK_OPTS_NS::abs_ (I32 v)

SI F	SK_OPTS_NS::floor_ (F v)

SI F	SK_OPTS_NS::ceil_ (F v)

SI F	SK_OPTS_NS::rcp_approx (F v)

SI F	SK_OPTS_NS::rsqrt_approx (F v)

SI F	SK_OPTS_NS::sqrt_ (F v)

SI F	SK_OPTS_NS::rcp_precise (F v)

SI I32	SK_OPTS_NS::iround (F v)

SI U32	SK_OPTS_NS::round (F v)

SI U32	SK_OPTS_NS::round (F v, F scale)

SI U16	SK_OPTS_NS::pack (U32 v)

SI U8	SK_OPTS_NS::pack (U16 v)

SI F	SK_OPTS_NS::if_then_else (I32 c, F t, F e)

SI I32	SK_OPTS_NS::if_then_else (I32 c, I32 t, I32 e)

SI bool	SK_OPTS_NS::any (I32 c)

SI bool	SK_OPTS_NS::all (I32 c)

template<typename T >
SI T	SK_OPTS_NS::gather (const T *p, U32 ix)

SI void	SK_OPTS_NS::scatter_masked (I32 src, int *dst, U32 ix, I32 mask)

SI void	SK_OPTS_NS::load2 (const uint16_t ptr, U16 r, U16 *g)

SI void	SK_OPTS_NS::store2 (uint16_t *ptr, U16 r, U16 g)

SI void	SK_OPTS_NS::load4 (const uint16_t ptr, U16 r, U16 g, U16 b, U16 *a)

SI void	SK_OPTS_NS::store4 (uint16_t *ptr, U16 r, U16 g, U16 b, U16 a)

SI void	SK_OPTS_NS::load4 (const float ptr, F r, F g, F b, F *a)

SI void	SK_OPTS_NS::store4 (float *ptr, F r, F g, F b, F a)

SI constexpr F	SK_OPTS_NS::F_ (float x)

SI constexpr I32	SK_OPTS_NS::I32_ (int32_t x)

SI constexpr U32	SK_OPTS_NS::U32_ (uint32_t x)

SI F	SK_OPTS_NS::cast (U32 v)

SI F	SK_OPTS_NS::cast64 (U64 v)

SI U32	SK_OPTS_NS::trunc_ (F v)

SI U32	SK_OPTS_NS::expand (U16 v)

SI U32	SK_OPTS_NS::expand (U8 v)

SI F	SK_OPTS_NS::fract (F v)

SI F	SK_OPTS_NS::approx_log2 (F x)

SI F	SK_OPTS_NS::approx_log (F x)

SI F	SK_OPTS_NS::approx_pow2 (F x)

SI F	SK_OPTS_NS::approx_exp (F x)

SI F	SK_OPTS_NS::approx_powf (F x, F y)

SI F	SK_OPTS_NS::from_half (U16 h)

SI U16	SK_OPTS_NS::to_half (F f)

static void	SK_OPTS_NS::patch_memory_contexts (SkSpan< SkRasterPipeline_MemoryCtxPatch > memoryCtxPatches, size_t dx, size_t dy, size_t tail)

static void	SK_OPTS_NS::restore_memory_contexts (SkSpan< SkRasterPipeline_MemoryCtxPatch > memoryCtxPatches, size_t dx, size_t dy, size_t tail)

SI F	SK_OPTS_NS::rcp_fast (F v)

SI F	SK_OPTS_NS::rsqrt (F v)

static void	SK_OPTS_NS::start_pipeline (size_t dx, size_t dy, size_t xlimit, size_t ylimit, SkRasterPipelineStage program, SkSpan< SkRasterPipeline_MemoryCtxPatch > memoryCtxPatches, uint8_t tailPointer)

static void ABI	SK_OPTS_NS::just_return (Params , SkRasterPipelineStage , F, F, F, F)

static void ABI	SK_OPTS_NS::stack_checkpoint (Params params, SkRasterPipelineStage program, F r, F g, F b, F a)

static void ABI	SK_OPTS_NS::stack_rewind (Params params, SkRasterPipelineStage program, F r, F g, F b, F a)

template<typename V , typename T >
SI V	SK_OPTS_NS::load (const T *src)

template<typename V , typename T >
SI void	SK_OPTS_NS::store (T *dst, V v)

SI F	SK_OPTS_NS::from_byte (U8 b)

SI F	SK_OPTS_NS::from_short (U16 s)

SI void	SK_OPTS_NS::from_565 (U16 _565, F r, F g, F *b)

SI void	SK_OPTS_NS::from_4444 (U16 _4444, F r, F g, F b, F a)

SI void	SK_OPTS_NS::from_8888 (U32 _8888, F r, F g, F b, F a)

SI void	SK_OPTS_NS::from_88 (U16 _88, F r, F g)

SI void	SK_OPTS_NS::from_1010102 (U32 rgba, F r, F g, F b, F a)

SI void	SK_OPTS_NS::from_1010102_xr (U32 rgba, F r, F g, F b, F a)

SI void	SK_OPTS_NS::from_10101010_xr (U64 _10x6, F r, F g, F b, F a)

SI void	SK_OPTS_NS::from_10x6 (U64 _10x6, F r, F g, F b, F a)

SI void	SK_OPTS_NS::from_1616 (U32 _1616, F r, F g)

SI void	SK_OPTS_NS::from_16161616 (U64 _16161616, F r, F g, F b, F a)

template<typename T >
SI T *	SK_OPTS_NS::ptr_at_xy (const SkRasterPipeline_MemoryCtx *ctx, size_t dx, size_t dy)

SI F	SK_OPTS_NS::clamp (F v, F limit)

SI F	SK_OPTS_NS::clamp_ex (F v, float limit)

SI F	SK_OPTS_NS::sin5q_ (F x)

SI F	SK_OPTS_NS::sin_ (F x)

SI F	SK_OPTS_NS::cos_ (F x)

SI F	SK_OPTS_NS::tan_ (F x)

SI F	SK_OPTS_NS::approx_atan_unit (F x)

SI F	SK_OPTS_NS::atan_ (F x)

SI F	SK_OPTS_NS::asin_ (F x)

SI F	SK_OPTS_NS::acos_ (F x)

SI F	SK_OPTS_NS::atan2_ (F y0, F x0)

template<typename T >
SI U32	SK_OPTS_NS::ix_and_ptr (T *ptr, const SkRasterPipeline_GatherCtx ctx, F x, F y)

SI U32	SK_OPTS_NS::to_unorm (F v, float scale, float bias=1.0f)

SI I32	SK_OPTS_NS::cond_to_mask (I32 cond)

SI uint32_t	SK_OPTS_NS::select_lane (uint32_t data, int)

SI int32_t	SK_OPTS_NS::select_lane (int32_t data, int)

	SK_OPTS_NS::STAGE (seed_shader, NoCtx)

	SK_OPTS_NS::STAGE (dither, const float *rate)

	SK_OPTS_NS::STAGE (uniform_color, const SkRasterPipeline_UniformColorCtx *c)

	SK_OPTS_NS::STAGE (unbounded_uniform_color, const SkRasterPipeline_UniformColorCtx *c)

	SK_OPTS_NS::STAGE (uniform_color_dst, const SkRasterPipeline_UniformColorCtx *c)

	SK_OPTS_NS::STAGE (black_color, NoCtx)

	SK_OPTS_NS::STAGE (white_color, NoCtx)

	SK_OPTS_NS::STAGE (load_src, const float *ptr)

	SK_OPTS_NS::STAGE (store_src, float *ptr)

	SK_OPTS_NS::STAGE (store_src_rg, float *ptr)

	SK_OPTS_NS::STAGE (load_src_rg, float *ptr)

	SK_OPTS_NS::STAGE (store_src_a, float *ptr)

	SK_OPTS_NS::STAGE (load_dst, const float *ptr)

	SK_OPTS_NS::STAGE (store_dst, float *ptr)

SI F	SK_OPTS_NS::inv (F x)

SI F	SK_OPTS_NS::two (F x)

	SK_OPTS_NS::BLEND_MODE (clear)

	SK_OPTS_NS::BLEND_MODE (srcatop)

	SK_OPTS_NS::BLEND_MODE (dstatop)

	SK_OPTS_NS::BLEND_MODE (srcin)

	SK_OPTS_NS::BLEND_MODE (dstin)

	SK_OPTS_NS::BLEND_MODE (srcout)

	SK_OPTS_NS::BLEND_MODE (dstout)

	SK_OPTS_NS::BLEND_MODE (srcover)

	SK_OPTS_NS::BLEND_MODE (dstover)

	SK_OPTS_NS::BLEND_MODE (modulate)

	SK_OPTS_NS::BLEND_MODE (multiply)

	SK_OPTS_NS::BLEND_MODE (plus_)

	SK_OPTS_NS::BLEND_MODE (screen)

	SK_OPTS_NS::BLEND_MODE (xor_)

	SK_OPTS_NS::BLEND_MODE (darken)

	SK_OPTS_NS::BLEND_MODE (lighten)

	SK_OPTS_NS::BLEND_MODE (difference)

	SK_OPTS_NS::BLEND_MODE (exclusion)

	SK_OPTS_NS::BLEND_MODE (colorburn)

	SK_OPTS_NS::BLEND_MODE (colordodge)

	SK_OPTS_NS::BLEND_MODE (hardlight)

	SK_OPTS_NS::BLEND_MODE (overlay)

	SK_OPTS_NS::BLEND_MODE (softlight)

SI F	SK_OPTS_NS::sat (F r, F g, F b)

SI F	SK_OPTS_NS::lum (F r, F g, F b)

SI void	SK_OPTS_NS::set_sat (F r, F g, F *b, F s)

SI void	SK_OPTS_NS::set_lum (F r, F g, F *b, F l)

SI F	SK_OPTS_NS::clip_channel (F c, F l, I32 clip_low, I32 clip_high, F mn_scale, F mx_scale)

SI void	SK_OPTS_NS::clip_color (F r, F g, F *b, F a)

	SK_OPTS_NS::STAGE (hue, NoCtx)

	SK_OPTS_NS::STAGE (saturation, NoCtx)

	SK_OPTS_NS::STAGE (color, NoCtx)

	SK_OPTS_NS::STAGE (luminosity, NoCtx)

	SK_OPTS_NS::STAGE (srcover_rgba_8888, const SkRasterPipeline_MemoryCtx *ctx)

SI F	SK_OPTS_NS::clamp_01_ (F v)

	SK_OPTS_NS::STAGE (clamp_01, NoCtx)

	SK_OPTS_NS::STAGE (clamp_gamut, NoCtx)

	SK_OPTS_NS::STAGE (set_rgb, const float *rgb)

	SK_OPTS_NS::STAGE (unbounded_set_rgb, const float *rgb)

	SK_OPTS_NS::STAGE (swap_rb, NoCtx)

	SK_OPTS_NS::STAGE (swap_rb_dst, NoCtx)

	SK_OPTS_NS::STAGE (move_src_dst, NoCtx)

	SK_OPTS_NS::STAGE (move_dst_src, NoCtx)

	SK_OPTS_NS::STAGE (swap_src_dst, NoCtx)

	SK_OPTS_NS::STAGE (premul, NoCtx)

	SK_OPTS_NS::STAGE (premul_dst, NoCtx)

	SK_OPTS_NS::STAGE (unpremul, NoCtx)

	SK_OPTS_NS::STAGE (unpremul_polar, NoCtx)

	SK_OPTS_NS::STAGE (force_opaque, NoCtx)

	SK_OPTS_NS::STAGE (force_opaque_dst, NoCtx)

	SK_OPTS_NS::STAGE (rgb_to_hsl, NoCtx)

	SK_OPTS_NS::STAGE (hsl_to_rgb, NoCtx)

	SK_OPTS_NS::STAGE (css_lab_to_xyz, NoCtx)

	SK_OPTS_NS::STAGE (css_oklab_to_linear_srgb, NoCtx)

	SK_OPTS_NS::STAGE (css_oklab_gamut_map_to_linear_srgb, NoCtx)

	SK_OPTS_NS::STAGE (css_hcl_to_lab, NoCtx)

SI F	SK_OPTS_NS::mod_ (F x, float y)

SI RGB	SK_OPTS_NS::css_hsl_to_srgb_ (F h, F s, F l)

	SK_OPTS_NS::STAGE (css_hsl_to_srgb, NoCtx)

	SK_OPTS_NS::STAGE (css_hwb_to_srgb, NoCtx)

SI F	SK_OPTS_NS::alpha_coverage_from_rgb_coverage (F a, F da, F cr, F cg, F cb)

	SK_OPTS_NS::STAGE (scale_1_float, const float *c)

	SK_OPTS_NS::STAGE (scale_u8, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (scale_565, const SkRasterPipeline_MemoryCtx *ctx)

SI F	SK_OPTS_NS::lerp (F from, F to, F t)

	SK_OPTS_NS::STAGE (lerp_1_float, const float *c)

	SK_OPTS_NS::STAGE (scale_native, const float scales[])

	SK_OPTS_NS::STAGE (lerp_native, const float scales[])

	SK_OPTS_NS::STAGE (lerp_u8, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (lerp_565, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (emboss, const SkRasterPipeline_EmbossCtx *ctx)

	SK_OPTS_NS::STAGE (byte_tables, const SkRasterPipeline_TablesCtx *tables)

SI F	SK_OPTS_NS::strip_sign (F x, U32 *sign)

SI F	SK_OPTS_NS::apply_sign (F x, U32 sign)

	SK_OPTS_NS::STAGE (parametric, const skcms_TransferFunction *ctx)

	SK_OPTS_NS::STAGE (gamma_, const float *G)

	SK_OPTS_NS::STAGE (PQish, const skcms_TransferFunction *ctx)

	SK_OPTS_NS::STAGE (HLGish, const skcms_TransferFunction *ctx)

	SK_OPTS_NS::STAGE (HLGinvish, const skcms_TransferFunction *ctx)

	SK_OPTS_NS::STAGE (load_a8, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_a8_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_a8, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_a8, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (store_r8, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_565, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_565_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_565, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_565, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_4444, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_4444_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_4444, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_4444, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_8888, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_8888_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_8888, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_8888, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_rg88, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_rg88_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_rg88, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_rg88, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_a16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_a16_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_a16, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_a16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_rg1616, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_rg1616_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_rg1616, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_rg1616, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_16161616, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_16161616_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_16161616, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_16161616, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_10x6, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_10x6_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_10x6, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_10x6, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_1010102, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_1010102_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_1010102_xr, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_1010102_xr_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_1010102, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (gather_1010102_xr, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (gather_10101010_xr, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (load_10101010_xr, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_10101010_xr_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (store_10101010_xr, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (store_1010102, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (store_1010102_xr, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_f16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_f16_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_f16, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_f16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_af16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_af16_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_af16, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_af16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_rgf16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_rgf16_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_rgf16, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_rgf16, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_f32, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (load_f32_dst, const SkRasterPipeline_MemoryCtx *ctx)

	SK_OPTS_NS::STAGE (gather_f32, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (store_f32, const SkRasterPipeline_MemoryCtx *ctx)

SI F	SK_OPTS_NS::exclusive_repeat (F v, const SkRasterPipeline_TileCtx *ctx)

SI F	SK_OPTS_NS::exclusive_mirror (F v, const SkRasterPipeline_TileCtx *ctx)

	SK_OPTS_NS::STAGE (repeat_x, const SkRasterPipeline_TileCtx *ctx)

	SK_OPTS_NS::STAGE (repeat_y, const SkRasterPipeline_TileCtx *ctx)

	SK_OPTS_NS::STAGE (mirror_x, const SkRasterPipeline_TileCtx *ctx)

	SK_OPTS_NS::STAGE (mirror_y, const SkRasterPipeline_TileCtx *ctx)

	SK_OPTS_NS::STAGE (clamp_x_1, NoCtx)

	SK_OPTS_NS::STAGE (repeat_x_1, NoCtx)

	SK_OPTS_NS::STAGE (mirror_x_1, NoCtx)

	SK_OPTS_NS::STAGE (clamp_x_and_y, const SkRasterPipeline_CoordClampCtx *ctx)

	SK_OPTS_NS::STAGE (decal_x, SkRasterPipeline_DecalTileCtx *ctx)

	SK_OPTS_NS::STAGE (decal_y, SkRasterPipeline_DecalTileCtx *ctx)

	SK_OPTS_NS::STAGE (decal_x_and_y, SkRasterPipeline_DecalTileCtx *ctx)

	SK_OPTS_NS::STAGE (check_decal_mask, SkRasterPipeline_DecalTileCtx *ctx)

	SK_OPTS_NS::STAGE (alpha_to_gray, NoCtx)

	SK_OPTS_NS::STAGE (alpha_to_gray_dst, NoCtx)

	SK_OPTS_NS::STAGE (alpha_to_red, NoCtx)

	SK_OPTS_NS::STAGE (alpha_to_red_dst, NoCtx)

	SK_OPTS_NS::STAGE (bt709_luminance_or_luma_to_alpha, NoCtx)

	SK_OPTS_NS::STAGE (bt709_luminance_or_luma_to_rgb, NoCtx)

	SK_OPTS_NS::STAGE (matrix_translate, const float *m)

	SK_OPTS_NS::STAGE (matrix_scale_translate, const float *m)

	SK_OPTS_NS::STAGE (matrix_2x3, const float *m)

	SK_OPTS_NS::STAGE (matrix_3x3, const float *m)

	SK_OPTS_NS::STAGE (matrix_3x4, const float *m)

	SK_OPTS_NS::STAGE (matrix_4x5, const float *m)

	SK_OPTS_NS::STAGE (matrix_4x3, const float *m)

	SK_OPTS_NS::STAGE (matrix_perspective, const float *m)

SI void	SK_OPTS_NS::gradient_lookup (const SkRasterPipeline_GradientCtx c, U32 idx, F t, F r, F g, F b, F *a)

	SK_OPTS_NS::STAGE (evenly_spaced_gradient, const SkRasterPipeline_GradientCtx *c)

	SK_OPTS_NS::STAGE (gradient, const SkRasterPipeline_GradientCtx *c)

	SK_OPTS_NS::STAGE (evenly_spaced_2_stop_gradient, const SkRasterPipeline_EvenlySpaced2StopGradientCtx *c)

	SK_OPTS_NS::STAGE (xy_to_unit_angle, NoCtx)

	SK_OPTS_NS::STAGE (xy_to_radius, NoCtx)

	SK_OPTS_NS::STAGE (negate_x, NoCtx)

	SK_OPTS_NS::STAGE (xy_to_2pt_conical_strip, const SkRasterPipeline_2PtConicalCtx *ctx)

	SK_OPTS_NS::STAGE (xy_to_2pt_conical_focal_on_circle, NoCtx)

	SK_OPTS_NS::STAGE (xy_to_2pt_conical_well_behaved, const SkRasterPipeline_2PtConicalCtx *ctx)

	SK_OPTS_NS::STAGE (xy_to_2pt_conical_greater, const SkRasterPipeline_2PtConicalCtx *ctx)

	SK_OPTS_NS::STAGE (xy_to_2pt_conical_smaller, const SkRasterPipeline_2PtConicalCtx *ctx)

	SK_OPTS_NS::STAGE (alter_2pt_conical_compensate_focal, const SkRasterPipeline_2PtConicalCtx *ctx)

	SK_OPTS_NS::STAGE (alter_2pt_conical_unswap, NoCtx)

	SK_OPTS_NS::STAGE (mask_2pt_conical_nan, SkRasterPipeline_2PtConicalCtx *c)

	SK_OPTS_NS::STAGE (mask_2pt_conical_degenerates, SkRasterPipeline_2PtConicalCtx *c)

	SK_OPTS_NS::STAGE (apply_vector_mask, const uint32_t *ctx)

SI void	SK_OPTS_NS::save_xy (F r, F g, SkRasterPipeline_SamplerCtx *c)

	SK_OPTS_NS::STAGE (accumulate, const SkRasterPipeline_SamplerCtx *c)

template<int kScale>
SI void	SK_OPTS_NS::bilinear_x (SkRasterPipeline_SamplerCtx ctx, F x)

template<int kScale>
SI void	SK_OPTS_NS::bilinear_y (SkRasterPipeline_SamplerCtx ctx, F y)

	SK_OPTS_NS::STAGE (bilinear_setup, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bilinear_nx, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bilinear_px, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bilinear_ny, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bilinear_py, SkRasterPipeline_SamplerCtx *ctx)

SI F	SK_OPTS_NS::bicubic_wts (F t, float A, float B, float C, float D)

template<int kScale>
SI void	SK_OPTS_NS::bicubic_x (SkRasterPipeline_SamplerCtx ctx, F x)

template<int kScale>
SI void	SK_OPTS_NS::bicubic_y (SkRasterPipeline_SamplerCtx ctx, F y)

	SK_OPTS_NS::STAGE (bicubic_setup, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_n3x, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_n1x, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_p1x, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_p3x, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_n3y, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_n1y, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_p1y, SkRasterPipeline_SamplerCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_p3y, SkRasterPipeline_SamplerCtx *ctx)

SI F	SK_OPTS_NS::compute_perlin_vector (U32 sample, F x, F y)

	SK_OPTS_NS::STAGE (perlin_noise, SkRasterPipeline_PerlinNoiseCtx *ctx)

	SK_OPTS_NS::STAGE (mipmap_linear_init, SkRasterPipeline_MipmapCtx *ctx)

	SK_OPTS_NS::STAGE (mipmap_linear_update, SkRasterPipeline_MipmapCtx *ctx)

	SK_OPTS_NS::STAGE (mipmap_linear_finish, SkRasterPipeline_MipmapCtx *ctx)

	SK_OPTS_NS::STAGE (callback, SkRasterPipeline_CallbackCtx *c)

	SK_OPTS_NS::STAGE_TAIL (set_base_pointer, std::byte *p)

	SK_OPTS_NS::STAGE_TAIL (init_lane_masks, SkRasterPipeline_InitLaneMasksCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (store_device_xy01, F *dst)

	SK_OPTS_NS::STAGE_TAIL (exchange_src, F *rgba)

	SK_OPTS_NS::STAGE_TAIL (load_condition_mask, F *ctx)

	SK_OPTS_NS::STAGE_TAIL (store_condition_mask, F *ctx)

	SK_OPTS_NS::STAGE_TAIL (merge_condition_mask, I32 *ptr)

	SK_OPTS_NS::STAGE_TAIL (merge_inv_condition_mask, I32 *ptr)

	SK_OPTS_NS::STAGE_TAIL (load_loop_mask, F *ctx)

	SK_OPTS_NS::STAGE_TAIL (store_loop_mask, F *ctx)

	SK_OPTS_NS::STAGE_TAIL (mask_off_loop_mask, NoCtx)

	SK_OPTS_NS::STAGE_TAIL (reenable_loop_mask, I32 *ptr)

	SK_OPTS_NS::STAGE_TAIL (merge_loop_mask, I32 *ptr)

	SK_OPTS_NS::STAGE_TAIL (continue_op, I32 *continueMask)

	SK_OPTS_NS::STAGE_TAIL (case_op, SkRasterPipeline_CaseOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (load_return_mask, F *ctx)

	SK_OPTS_NS::STAGE_TAIL (store_return_mask, F *ctx)

	SK_OPTS_NS::STAGE_TAIL (mask_off_return_mask, NoCtx)

	SK_OPTS_NS::STAGE_BRANCH (branch_if_all_lanes_active, SkRasterPipeline_BranchIfAllLanesActiveCtx *ctx)

	SK_OPTS_NS::STAGE_BRANCH (branch_if_any_lanes_active, SkRasterPipeline_BranchCtx *ctx)

	SK_OPTS_NS::STAGE_BRANCH (branch_if_no_lanes_active, SkRasterPipeline_BranchCtx *ctx)

	SK_OPTS_NS::STAGE_BRANCH (jump, SkRasterPipeline_BranchCtx *ctx)

	SK_OPTS_NS::STAGE_BRANCH (branch_if_no_active_lanes_eq, SkRasterPipeline_BranchIfEqualCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (trace_line, SkRasterPipeline_TraceLineCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (trace_enter, SkRasterPipeline_TraceFuncCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (trace_exit, SkRasterPipeline_TraceFuncCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (trace_scope, SkRasterPipeline_TraceScopeCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (trace_var, SkRasterPipeline_TraceVarCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_uniform, SkRasterPipeline_UniformCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_2_uniforms, SkRasterPipeline_UniformCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_3_uniforms, SkRasterPipeline_UniformCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_4_uniforms, SkRasterPipeline_UniformCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_constant, SkRasterPipeline_ConstantCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (splat_2_constants, SkRasterPipeline_ConstantCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (splat_3_constants, SkRasterPipeline_ConstantCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (splat_4_constants, SkRasterPipeline_ConstantCtx *packed)

template<int NumSlots>
SI void	SK_OPTS_NS::copy_n_slots_unmasked_fn (SkRasterPipeline_BinaryOpCtx packed, std::byte base)

	SK_OPTS_NS::STAGE_TAIL (copy_slot_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_2_slots_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_3_slots_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_4_slots_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

template<int NumSlots>
SI void	SK_OPTS_NS::copy_n_immutable_unmasked_fn (SkRasterPipeline_BinaryOpCtx packed, std::byte base)

	SK_OPTS_NS::STAGE_TAIL (copy_immutable_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_2_immutables_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_3_immutables_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_4_immutables_unmasked, SkRasterPipeline_BinaryOpCtx *packed)

template<int NumSlots>
SI void	SK_OPTS_NS::copy_n_slots_masked_fn (SkRasterPipeline_BinaryOpCtx packed, std::byte base, I32 mask)

	SK_OPTS_NS::STAGE_TAIL (copy_slot_masked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_2_slots_masked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_3_slots_masked, SkRasterPipeline_BinaryOpCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (copy_4_slots_masked, SkRasterPipeline_BinaryOpCtx *packed)

template<int LoopCount, typename OffsetType >
SI void	SK_OPTS_NS::shuffle_fn (std::byte ptr, OffsetType offsets, int numSlots)

template<int N>
SI void	SK_OPTS_NS::small_swizzle_fn (SkRasterPipeline_SwizzleCtx packed, std::byte base)

	SK_OPTS_NS::STAGE_TAIL (swizzle_1, SkRasterPipeline_SwizzleCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (swizzle_2, SkRasterPipeline_SwizzleCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (swizzle_3, SkRasterPipeline_SwizzleCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (swizzle_4, SkRasterPipeline_SwizzleCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (shuffle, SkRasterPipeline_ShuffleCtx *ctx)

template<int NumSlots>
SI void	SK_OPTS_NS::swizzle_copy_masked_fn (I32 dst, const I32 src, uint16_t *offsets, I32 mask)

	SK_OPTS_NS::STAGE_TAIL (swizzle_copy_slot_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (swizzle_copy_2_slots_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (swizzle_copy_3_slots_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (swizzle_copy_4_slots_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_from_indirect_unmasked, SkRasterPipeline_CopyIndirectCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_from_indirect_uniform_unmasked, SkRasterPipeline_CopyIndirectCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (copy_to_indirect_masked, SkRasterPipeline_CopyIndirectCtx *ctx)

	SK_OPTS_NS::STAGE_TAIL (swizzle_copy_to_indirect_masked, SkRasterPipeline_SwizzleCopyIndirectCtx *ctx)

template<typename T , void()(T ) ApplyFn>
SI void	SK_OPTS_NS::apply_adjacent_unary (T dst, T end)

template<typename T >
SI void	SK_OPTS_NS::cast_to_float_from_fn (T *dst)

SI void	SK_OPTS_NS::cast_to_int_from_fn (F *dst)

SI void	SK_OPTS_NS::cast_to_uint_from_fn (F *dst)

SI void	SK_OPTS_NS::abs_fn (I32 *dst)

SI void	SK_OPTS_NS::floor_fn (F *dst)

SI void	SK_OPTS_NS::ceil_fn (F *dst)

SI void	SK_OPTS_NS::invsqrt_fn (F *dst)

	SK_OPTS_NS::DECLARE_UNARY_INT (cast_to_float_from) DECLARE_UNARY_UINT(cast_to_float_from) STAGE_TAIL(sin_float

	SK_OPTS_NS::STAGE_TAIL (cos_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (tan_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (asin_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (acos_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (atan_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (sqrt_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (exp_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (exp2_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (log_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (log2_float, F *dst)

	SK_OPTS_NS::STAGE_TAIL (inverse_mat2, F *dst)

	SK_OPTS_NS::STAGE_TAIL (inverse_mat3, F *dst)

	SK_OPTS_NS::STAGE_TAIL (inverse_mat4, F *dst)

template<typename T , void()(T , T *) ApplyFn>
SI void	SK_OPTS_NS::apply_adjacent_binary (T dst, T src)

template<typename T , void()(T , T *) ApplyFn>
SI void	SK_OPTS_NS::apply_adjacent_binary_packed (SkRasterPipeline_BinaryOpCtx packed, std::byte base)

template<int N, typename V , typename S , void()(V , V *) ApplyFn>
SI void	SK_OPTS_NS::apply_binary_immediate (SkRasterPipeline_ConstantCtx packed, std::byte base)

template<typename T >
SI void	SK_OPTS_NS::add_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::sub_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::mul_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::div_fn (T dst, T src)

SI void	SK_OPTS_NS::bitwise_and_fn (I32 dst, I32 src)

SI void	SK_OPTS_NS::bitwise_or_fn (I32 dst, I32 src)

SI void	SK_OPTS_NS::bitwise_xor_fn (I32 dst, I32 src)

template<typename T >
SI void	SK_OPTS_NS::max_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::min_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::cmplt_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::cmple_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::cmpeq_fn (T dst, T src)

template<typename T >
SI void	SK_OPTS_NS::cmpne_fn (T dst, T src)

SI void	SK_OPTS_NS::atan2_fn (F dst, F src)

SI void	SK_OPTS_NS::pow_fn (F dst, F src)

SI void	SK_OPTS_NS::mod_fn (F dst, F src)

	SK_OPTS_NS::DECLARE_BINARY_FLOAT (add) DECLARE_BINARY_INT(add) DECLARE_BINARY_FLOAT(sub) DECLARE_BINARY_INT(sub) DECLARE_BINARY_FLOAT(mul) DECLARE_BINARY_INT(mul) DECLARE_BINARY_FLOAT(div) DECLARE_BINARY_INT(div) DECLARE_BINARY_UINT(div) DECLARE_BINARY_FLOAT(min) DECLARE_BINARY_INT(min) DECLARE_BINARY_UINT(min) DECLARE_BINARY_FLOAT(max) DECLARE_BINARY_INT(max) DECLARE_BINARY_UINT(max) DECLARE_BINARY_FLOAT(cmplt) DECLARE_BINARY_INT(cmplt) DECLARE_BINARY_UINT(cmplt) DECLARE_BINARY_FLOAT(cmple) DECLARE_BINARY_INT(cmple) DECLARE_BINARY_UINT(cmple) DECLARE_BINARY_FLOAT(cmpeq) DECLARE_BINARY_INT(cmpeq) DECLARE_BINARY_FLOAT(cmpne) DECLARE_BINARY_INT(cmpne) DECLARE_IMM_BINARY_FLOAT(add) DECLARE_IMM_BINARY_INT(add) DECLARE_IMM_BINARY_FLOAT(mul) DECLARE_IMM_BINARY_INT(mul) DECLARE_IMM_BINARY_FLOAT(cmplt) DECLARE_IMM_BINARY_INT(cmplt) DECLARE_IMM_BINARY_UINT(cmplt) DECLARE_IMM_BINARY_FLOAT(cmple) DECLARE_IMM_BINARY_INT(cmple) DECLARE_IMM_BINARY_UINT(cmple) DECLARE_IMM_BINARY_FLOAT(cmpeq) DECLARE_IMM_BINARY_INT(cmpeq) DECLARE_IMM_BINARY_FLOAT(cmpne) DECLARE_IMM_BINARY_INT(cmpne) STAGE_TAIL(dot_2_floats

	SK_OPTS_NS::STAGE_TAIL (dot_3_floats, F *dst)

	SK_OPTS_NS::STAGE_TAIL (dot_4_floats, F *dst)

template<int N>
SI void	SK_OPTS_NS::matrix_multiply (SkRasterPipeline_MatrixMultiplyCtx packed, std::byte base)

	SK_OPTS_NS::STAGE_TAIL (matrix_multiply_2, SkRasterPipeline_MatrixMultiplyCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (matrix_multiply_3, SkRasterPipeline_MatrixMultiplyCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (matrix_multiply_4, SkRasterPipeline_MatrixMultiplyCtx *packed)

	SK_OPTS_NS::STAGE_TAIL (refract_4_floats, F *dst)

template<typename T , void()(T , T , T ) ApplyFn>
SI void	SK_OPTS_NS::apply_adjacent_ternary (T dst, T src0, T *src1)

template<typename T , void()(T , T , T ) ApplyFn>
SI void	SK_OPTS_NS::apply_adjacent_ternary_packed (SkRasterPipeline_TernaryOpCtx packed, std::byte base)

SI void	SK_OPTS_NS::mix_fn (F a, F x, F *y)

SI void	SK_OPTS_NS::mix_fn (I32 a, I32 x, I32 *y)

SI void	SK_OPTS_NS::smoothstep_fn (F edge0, F edge1, F *x)

	SK_OPTS_NS::STAGE (gauss_a_to_rgba, NoCtx)

	SK_OPTS_NS::STAGE (bilerp_clamp_8888, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (bicubic_clamp_8888, const SkRasterPipeline_GatherCtx *ctx)

	SK_OPTS_NS::STAGE (swizzle, void *ctx)

static void	SK_OPTS_NS::lowp::start_pipeline (size_t, size_t, size_t, size_t, SkRasterPipelineStage , SkSpan< SkRasterPipeline_MemoryCtxPatch >, uint8_t tailPointer)

constexpr size_t	SK_OPTS_NS::raster_pipeline_lowp_stride ()

constexpr size_t	SK_OPTS_NS::raster_pipeline_highp_stride ()

Variables
static constexpr F	SK_OPTS_NS::F0 = F_(0.0f)

static constexpr F	SK_OPTS_NS::F1 = F_(1.0f)

static constexpr size_t	SK_OPTS_NS::N = sizeof(F) / sizeof(float)

F *	SK_OPTS_NS::dst { dst = sin_(dst)

static void(*	SK_OPTS_NS::lowp::just_return )(void) = nullptr

static constexpr size_t	SK_OPTS_NS::lowp::lowp_N = N

Macro Definition Documentation

◆ ABI

#define ABI

Definition at line 1514 of file SkRasterPipeline_opts.h.

◆ BLEND_MODE [1/2]

#define BLEND_MODE ( name )

Value:

    SI F name##_channel(F s, F d, F sa, F da); \
    STAGE(name, NoCtx) {                   \
        r = name##_channel(r,dr,a,da);         \
        g = name##_channel(g,dg,a,da);         \
        b = name##_channel(b,db,a,da);         \
        a = name##_channel(a,da,a,da);         \
    }                                          \
    SI F name##_channel(F s, F d, F sa, F da)

Definition at line 2192 of file SkRasterPipeline_opts.h.

◆ BLEND_MODE [2/2]

#define BLEND_MODE ( name )

Value:

    SI F name##_channel(F s, F d, F sa, F da); \
    STAGE(name, NoCtx) {                   \
        r = name##_channel(r,dr,a,da);         \
        g = name##_channel(g,dg,a,da);         \
        b = name##_channel(b,db,a,da);         \
        a = mad(da, inv(a), a);                \
    }                                          \
    SI F name##_channel(F s, F d, F sa, F da)

Definition at line 2192 of file SkRasterPipeline_opts.h.

◆ DECLARE_BINARY_FLOAT

#define DECLARE_BINARY_FLOAT ( name )

Value:

    STAGE_TAIL(name##_float, F* dst) { apply_adjacent_binary<F, &name##_fn>(dst, dst + 1); }    \
    STAGE_TAIL(name##_2_floats, F* dst) { apply_adjacent_binary<F, &name##_fn>(dst, dst + 2); } \
    STAGE_TAIL(name##_3_floats, F* dst) { apply_adjacent_binary<F, &name##_fn>(dst, dst + 3); } \
    STAGE_TAIL(name##_4_floats, F* dst) { apply_adjacent_binary<F, &name##_fn>(dst, dst + 4); } \
    DECLARE_N_WAY_BINARY_FLOAT(name)

Definition at line 4660 of file SkRasterPipeline_opts.h.

◆ DECLARE_BINARY_INT

#define DECLARE_BINARY_INT ( name )

Value:

    STAGE_TAIL(name##_int, I32* dst) { apply_adjacent_binary<I32, &name##_fn>(dst, dst + 1); }    \
    STAGE_TAIL(name##_2_ints, I32* dst) { apply_adjacent_binary<I32, &name##_fn>(dst, dst + 2); } \
    STAGE_TAIL(name##_3_ints, I32* dst) { apply_adjacent_binary<I32, &name##_fn>(dst, dst + 3); } \
    STAGE_TAIL(name##_4_ints, I32* dst) { apply_adjacent_binary<I32, &name##_fn>(dst, dst + 4); } \
    DECLARE_N_WAY_BINARY_INT(name)

Definition at line 4672 of file SkRasterPipeline_opts.h.

◆ DECLARE_BINARY_UINT

#define DECLARE_BINARY_UINT ( name )

Value:

    STAGE_TAIL(name##_uint, U32* dst) { apply_adjacent_binary<U32, &name##_fn>(dst, dst + 1); }    \
    STAGE_TAIL(name##_2_uints, U32* dst) { apply_adjacent_binary<U32, &name##_fn>(dst, dst + 2); } \
    STAGE_TAIL(name##_3_uints, U32* dst) { apply_adjacent_binary<U32, &name##_fn>(dst, dst + 3); } \
    STAGE_TAIL(name##_4_uints, U32* dst) { apply_adjacent_binary<U32, &name##_fn>(dst, dst + 4); } \
    DECLARE_N_WAY_BINARY_UINT(name)

Definition at line 4684 of file SkRasterPipeline_opts.h.

◆ DECLARE_IMM_BINARY_FLOAT

#define DECLARE_IMM_BINARY_FLOAT ( name )

Value:

    STAGE_TAIL(name##_imm_float, SkRasterPipeline_ConstantCtx* packed) { \
        apply_binary_immediate<1, F, float, &name##_fn>(packed, base);   \
    }

◆ DECLARE_IMM_BINARY_INT

#define DECLARE_IMM_BINARY_INT ( name )

Value:

    STAGE_TAIL(name##_imm_int, SkRasterPipeline_ConstantCtx* packed) {     \
        apply_binary_immediate<1, I32, int32_t, &name##_fn>(packed, base); \
    }

◆ DECLARE_IMM_BINARY_UINT

#define DECLARE_IMM_BINARY_UINT ( name )

Value:

    STAGE_TAIL(name##_imm_uint, SkRasterPipeline_ConstantCtx* packed) {     \
        apply_binary_immediate<1, U32, uint32_t, &name##_fn>(packed, base); \
    }

◆ DECLARE_MULTI_IMM_BINARY_INT

#define DECLARE_MULTI_IMM_BINARY_INT ( name )

Value:

    STAGE_TAIL(name##_imm_int, SkRasterPipeline_ConstantCtx* packed) {     \
        apply_binary_immediate<1, I32, int32_t, &name##_fn>(packed, base); \
    }                                                                      \
    STAGE_TAIL(name##_imm_2_ints, SkRasterPipeline_ConstantCtx* packed) {  \
        apply_binary_immediate<2, I32, int32_t, &name##_fn>(packed, base); \
    }                                                                      \
    STAGE_TAIL(name##_imm_3_ints, SkRasterPipeline_ConstantCtx* packed) {  \
        apply_binary_immediate<3, I32, int32_t, &name##_fn>(packed, base); \
    }                                                                      \
    STAGE_TAIL(name##_imm_4_ints, SkRasterPipeline_ConstantCtx* packed) {  \
        apply_binary_immediate<4, I32, int32_t, &name##_fn>(packed, base); \
    }

◆ DECLARE_N_WAY_BINARY_FLOAT

#define DECLARE_N_WAY_BINARY_FLOAT ( name )

Value:

    STAGE_TAIL(name##_n_floats, SkRasterPipeline_BinaryOpCtx* packed) { \
        apply_adjacent_binary_packed<F, &name##_fn>(packed, base);      \
    }

Definition at line 4655 of file SkRasterPipeline_opts.h.

◆ DECLARE_N_WAY_BINARY_INT

#define DECLARE_N_WAY_BINARY_INT ( name )

Value:

    STAGE_TAIL(name##_n_ints, SkRasterPipeline_BinaryOpCtx* packed) { \
        apply_adjacent_binary_packed<I32, &name##_fn>(packed, base);  \
    }

Definition at line 4667 of file SkRasterPipeline_opts.h.

◆ DECLARE_N_WAY_BINARY_UINT

#define DECLARE_N_WAY_BINARY_UINT ( name )

Value:

    STAGE_TAIL(name##_n_uints, SkRasterPipeline_BinaryOpCtx* packed) { \
        apply_adjacent_binary_packed<U32, &name##_fn>(packed, base);   \
    }

Definition at line 4679 of file SkRasterPipeline_opts.h.

◆ DECLARE_N_WAY_TERNARY_FLOAT

#define DECLARE_N_WAY_TERNARY_FLOAT ( name )

Value:

    STAGE_TAIL(name##_n_floats, SkRasterPipeline_TernaryOpCtx* packed) { \
        apply_adjacent_ternary_packed<F, &name##_fn>(packed, base);      \
    }

Definition at line 4906 of file SkRasterPipeline_opts.h.

◆ DECLARE_STAGE

#define DECLARE_STAGE	(	name,
		ARG,
		STAGE_RET,
		INC,
		OFFSET,
		MUSTTAIL
	)

Value:

        SI STAGE_RET name##_k(ARG, size_t dx, size_t dy, std::byte*& base,                 \
                              F& r, F& g, F& b, F& a, F& dr, F& dg, F& db, F& da);         \
        static void ABI name(Params* params, SkRasterPipelineStage* program,               \
                             F r, F g, F b, F a) {                                         \
            OFFSET name##_k(Ctx{program}, params->dx,params->dy,params->base,              \
                            r,g,b,a, params->dr, params->dg, params->db, params->da);      \
            INC;                                                                           \
            auto fn = (Stage)program->fn;                                                  \
            MUSTTAIL return fn(params, program, r,g,b,a);                                  \
        }                                                                                  \
        SI STAGE_RET name##_k(ARG, size_t dx, size_t dy, std::byte*& base,                 \
                              F& r, F& g, F& b, F& a, F& dr, F& dg, F& db, F& da)

Definition at line 1580 of file SkRasterPipeline_opts.h.

◆ DECLARE_TERNARY_FLOAT

#define DECLARE_TERNARY_FLOAT ( name )

Value:

    STAGE_TAIL(name##_float, F* p) { apply_adjacent_ternary<F, &name##_fn>(p, p+1, p+2); }    \
    STAGE_TAIL(name##_2_floats, F* p) { apply_adjacent_ternary<F, &name##_fn>(p, p+2, p+4); } \
    STAGE_TAIL(name##_3_floats, F* p) { apply_adjacent_ternary<F, &name##_fn>(p, p+3, p+6); } \
    STAGE_TAIL(name##_4_floats, F* p) { apply_adjacent_ternary<F, &name##_fn>(p, p+4, p+8); } \
    DECLARE_N_WAY_TERNARY_FLOAT(name)

Definition at line 4911 of file SkRasterPipeline_opts.h.

◆ DECLARE_TERNARY_INT

#define DECLARE_TERNARY_INT ( name )

Value:

    STAGE_TAIL(name##_int, I32* p) { apply_adjacent_ternary<I32, &name##_fn>(p, p+1, p+2); }    \
    STAGE_TAIL(name##_2_ints, I32* p) { apply_adjacent_ternary<I32, &name##_fn>(p, p+2, p+4); } \
    STAGE_TAIL(name##_3_ints, I32* p) { apply_adjacent_ternary<I32, &name##_fn>(p, p+3, p+6); } \
    STAGE_TAIL(name##_4_ints, I32* p) { apply_adjacent_ternary<I32, &name##_fn>(p, p+4, p+8); } \
    STAGE_TAIL(name##_n_ints, SkRasterPipeline_TernaryOpCtx* packed) {                          \
        apply_adjacent_ternary_packed<I32, &name##_fn>(packed, base);                           \
    }

Definition at line 4918 of file SkRasterPipeline_opts.h.

◆ DECLARE_UNARY_FLOAT

#define DECLARE_UNARY_FLOAT ( name )

Value:

    STAGE_TAIL(name##_float, F* dst) { apply_adjacent_unary<F, &name##_fn>(dst, dst + 1); }    \
    STAGE_TAIL(name##_2_floats, F* dst) { apply_adjacent_unary<F, &name##_fn>(dst, dst + 2); } \
    STAGE_TAIL(name##_3_floats, F* dst) { apply_adjacent_unary<F, &name##_fn>(dst, dst + 3); } \
    STAGE_TAIL(name##_4_floats, F* dst) { apply_adjacent_unary<F, &name##_fn>(dst, dst + 4); }

Definition at line 4414 of file SkRasterPipeline_opts.h.

◆ DECLARE_UNARY_INT

#define DECLARE_UNARY_INT ( name )

Value:

    STAGE_TAIL(name##_int, I32* dst) { apply_adjacent_unary<I32, &name##_fn>(dst, dst + 1); }    \
    STAGE_TAIL(name##_2_ints, I32* dst) { apply_adjacent_unary<I32, &name##_fn>(dst, dst + 2); } \
    STAGE_TAIL(name##_3_ints, I32* dst) { apply_adjacent_unary<I32, &name##_fn>(dst, dst + 3); } \
    STAGE_TAIL(name##_4_ints, I32* dst) { apply_adjacent_unary<I32, &name##_fn>(dst, dst + 4); }

Definition at line 4420 of file SkRasterPipeline_opts.h.

◆ DECLARE_UNARY_UINT

#define DECLARE_UNARY_UINT ( name )

Value:

    STAGE_TAIL(name##_uint, U32* dst) { apply_adjacent_unary<U32, &name##_fn>(dst, dst + 1); }    \
    STAGE_TAIL(name##_2_uints, U32* dst) { apply_adjacent_unary<U32, &name##_fn>(dst, dst + 2); } \
    STAGE_TAIL(name##_3_uints, U32* dst) { apply_adjacent_unary<U32, &name##_fn>(dst, dst + 3); } \
    STAGE_TAIL(name##_4_uints, U32* dst) { apply_adjacent_unary<U32, &name##_fn>(dst, dst + 4); }

Definition at line 4426 of file SkRasterPipeline_opts.h.

◆ execution_mask

#define execution_mask ( ) sk_bit_cast<I32>(a)

Definition at line 3847 of file SkRasterPipeline_opts.h.

◆ JUMPER_IS_SCALAR

#define JUMPER_IS_SCALAR

Definition at line 75 of file SkRasterPipeline_opts.h.

◆ JUMPER_MUSTTAIL

#define JUMPER_MUSTTAIL

Definition at line 1576 of file SkRasterPipeline_opts.h.

◆ JUMPER_NARROW_STAGES

#define JUMPER_NARROW_STAGES 1

Definition at line 1515 of file SkRasterPipeline_opts.h.

◆ M

#define M ( st ) static void (*st)(void) = nullptr;

Definition at line 5072 of file SkRasterPipeline_opts.h.

◆ SI

#define SI static inline

Definition at line 29 of file SkRasterPipeline_opts.h.

◆ SK_UNROLL

#define SK_UNROLL

Definition at line 35 of file SkRasterPipeline_opts.h.

◆ STAGE

#define STAGE	(	name,
		arg
	)	DECLARE_STAGE(name, arg, void, ++program, /no offset/, /no musttail/)

Definition at line 1610 of file SkRasterPipeline_opts.h.

◆ STAGE_BRANCH

#define STAGE_BRANCH	(	name,
		arg
	)	DECLARE_STAGE(name, arg, int, /no increment/, program +=, JUMPER_MUSTTAIL)

Definition at line 1620 of file SkRasterPipeline_opts.h.

◆ STAGE_TAIL

#define STAGE_TAIL	(	name,
		arg
	)	DECLARE_STAGE(name, arg, void, ++program, /no offset/, JUMPER_MUSTTAIL)

Definition at line 1616 of file SkRasterPipeline_opts.h.

◆ update_execution_mask

#define update_execution_mask ( )

Value:

                                                   a = sk_bit_cast<F>(sk_bit_cast<I32>(r) & \
                                                   sk_bit_cast<I32>(g) & \
                                                   sk_bit_cast<I32>(b))

Definition at line 3848 of file SkRasterPipeline_opts.h.

Typedef Documentation

◆ NoCtx

using NoCtx = const void*

Definition at line 68 of file SkRasterPipeline_opts.h.

Function Documentation

◆ widen_cast()

template<typename Dst , typename Src >

SI Dst widen_cast ( const Src & src )

Definition at line 50 of file SkRasterPipeline_opts.h.

                                  {
    static_assert(sizeof(Dst) > sizeof(Src));
    static_assert(std::is_trivially_copyable<Dst>::value);
    static_assert(std::is_trivially_copyable<Src>::value);
    Dst dst;
    memcpy(&dst, &src, sizeof(Src));
    return dst;
}

Classes

Namespaces

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ ABI

◆ BLEND_MODE [1/2]

◆ BLEND_MODE [2/2]

◆ DECLARE_BINARY_FLOAT

◆ DECLARE_BINARY_INT

◆ DECLARE_BINARY_UINT

◆ DECLARE_IMM_BINARY_FLOAT

◆ DECLARE_IMM_BINARY_INT

◆ DECLARE_IMM_BINARY_UINT

◆ DECLARE_MULTI_IMM_BINARY_INT

◆ DECLARE_N_WAY_BINARY_FLOAT

◆ DECLARE_N_WAY_BINARY_INT

◆ DECLARE_N_WAY_BINARY_UINT

◆ DECLARE_N_WAY_TERNARY_FLOAT

◆ DECLARE_STAGE

◆ DECLARE_TERNARY_FLOAT

◆ DECLARE_TERNARY_INT

◆ DECLARE_UNARY_FLOAT

◆ DECLARE_UNARY_INT

◆ DECLARE_UNARY_UINT

◆ execution_mask

◆ JUMPER_IS_SCALAR

◆ JUMPER_MUSTTAIL

◆ JUMPER_NARROW_STAGES

◆ M

◆ SI

◆ SK_UNROLL

◆ STAGE

◆ STAGE_BRANCH

◆ STAGE_TAIL

◆ update_execution_mask

Typedef Documentation

◆ NoCtx

Function Documentation

◆ widen_cast()