SK_OPTS_NS Namespace Reference

Namespaces
namespace	lowp

Classes
struct	Params
struct	RGB

Typedefs
using	F = float
using	I32 = int32_t
using	U64 = uint64_t
using	U32 = uint32_t
using	U16 = uint16_t
using	U8 = uint8_t
using	Stage = void(ABI *)(Params *, SkRasterPipelineStage *program, F r, F g, F b, F a)

Functions
template<typename U32 , typename Out >
static void	decode_packed_coordinates_and_weight (U32 packed, Out *v0, Out *v1, Out *w)
void	S32_alpha_D32_filter_DX (const SkBitmapProcState &s, const uint32_t *xy, int count, uint32_t *colors)
static __m128i	SkAlphaMul_lsx (__m128i x, __m128i y)
template<bool isColor>
static void	D32_A8_Opaque_Color_lsx (void *SK_RESTRICT dst, size_t dstRB, const void *SK_RESTRICT maskPtr, size_t maskRB, SkColor color, int width, int height)
static void	blit_mask_d32_a8_general (SkPMColor *dst, size_t dstRB, const SkAlpha *mask, size_t maskRB, SkColor color, int w, int h)
static void	blit_mask_d32_a8_opaque (SkPMColor *dst, size_t dstRB, const SkAlpha *mask, size_t maskRB, SkColor color, int w, int h)
static void	blit_mask_d32_a8_black (SkPMColor *dst, size_t dstRB, const SkAlpha *maskPtr, size_t maskRB, int width, int height)
void	blit_mask_d32_a8 (SkPMColor *dst, size_t dstRB, const SkAlpha *mask, size_t maskRB, SkColor color, int w, int h)
void	blit_row_s32a_opaque (SkPMColor *dst, const SkPMColor *src, int len, U8CPU alpha)
void	blit_row_color32 (SkPMColor *dst, int count, SkPMColor color)
template<typename T >
static void	memsetT (T buffer[], T value, int count)
void	memset16 (uint16_t buffer[], uint16_t value, int count)
void	memset32 (uint32_t buffer[], uint32_t value, int count)
void	memset64 (uint64_t buffer[], uint64_t value, int count)
template<typename T >
static void	rect_memsetT (T buffer[], T value, int count, size_t rowBytes, int height)
void	rect_memset16 (uint16_t buffer[], uint16_t value, int count, size_t rowBytes, int height)
void	rect_memset32 (uint32_t buffer[], uint32_t value, int count, size_t rowBytes, int height)
void	rect_memset64 (uint64_t buffer[], uint64_t value, int count, size_t rowBytes, int height)
SI F	min (F a, F b)
SI I32	min (I32 a, I32 b)
SI U32	min (U32 a, U32 b)
SI F	max (F a, F b)
SI I32	max (I32 a, I32 b)
SI U32	max (U32 a, U32 b)
SI F	mad (F f, F m, F a)
SI F	nmad (F f, F m, F a)
SI F	abs_ (F v)
SI I32	abs_ (I32 v)
SI F	floor_ (F v)
SI F	ceil_ (F v)
SI F	rcp_approx (F v)
SI F	rsqrt_approx (F v)
SI F	sqrt_ (F v)
SI F	rcp_precise (F v)
SI I32	iround (F v)
SI U32	round (F v)
SI U32	round (F v, F scale)
SI U16	pack (U32 v)
SI U8	pack (U16 v)
SI F	if_then_else (I32 c, F t, F e)
SI I32	if_then_else (I32 c, I32 t, I32 e)
SI bool	any (I32 c)
SI bool	all (I32 c)
template<typename T >
SI T	gather (const T *p, U32 ix)
SI void	scatter_masked (I32 src, int *dst, U32 ix, I32 mask)
SI void	load2 (const uint16_t *ptr, U16 *r, U16 *g)
SI void	store2 (uint16_t *ptr, U16 r, U16 g)
SI void	load4 (const uint16_t *ptr, U16 *r, U16 *g, U16 *b, U16 *a)
SI void	store4 (uint16_t *ptr, U16 r, U16 g, U16 b, U16 a)
SI void	load4 (const float *ptr, F *r, F *g, F *b, F *a)
SI void	store4 (float *ptr, F r, F g, F b, F a)
SI constexpr F	F_ (float x)
SI constexpr I32	I32_ (int32_t x)
SI constexpr U32	U32_ (uint32_t x)
SI F	cast (U32 v)
SI F	cast64 (U64 v)
SI U32	trunc_ (F v)
SI U32	expand (U16 v)
SI U32	expand (U8 v)
SI F	fract (F v)
SI F	approx_log2 (F x)
SI F	approx_log (F x)
SI F	approx_pow2 (F x)
SI F	approx_exp (F x)
SI F	approx_powf (F x, F y)
SI F	from_half (U16 h)
SI U16	to_half (F f)
static void	patch_memory_contexts (SkSpan< SkRasterPipeline_MemoryCtxPatch > memoryCtxPatches, size_t dx, size_t dy, size_t tail)
static void	restore_memory_contexts (SkSpan< SkRasterPipeline_MemoryCtxPatch > memoryCtxPatches, size_t dx, size_t dy, size_t tail)
SI F	rcp_fast (F v)
SI F	rsqrt (F v)
static void	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	just_return (Params *, SkRasterPipelineStage *, F, F, F, F)
static void ABI	stack_checkpoint (Params *params, SkRasterPipelineStage *program, F r, F g, F b, F a)
static void ABI	stack_rewind (Params *params, SkRasterPipelineStage *program, F r, F g, F b, F a)
template<typename V , typename T >
SI V	load (const T *src)
template<typename V , typename T >
SI void	store (T *dst, V v)
SI F	from_byte (U8 b)
SI F	from_short (U16 s)
SI void	from_565 (U16 _565, F *r, F *g, F *b)
SI void	from_4444 (U16 _4444, F *r, F *g, F *b, F *a)
SI void	from_8888 (U32 _8888, F *r, F *g, F *b, F *a)
SI void	from_88 (U16 _88, F *r, F *g)
SI void	from_1010102 (U32 rgba, F *r, F *g, F *b, F *a)
SI void	from_1010102_xr (U32 rgba, F *r, F *g, F *b, F *a)
SI void	from_10101010_xr (U64 _10x6, F *r, F *g, F *b, F *a)
SI void	from_10x6 (U64 _10x6, F *r, F *g, F *b, F *a)
SI void	from_1616 (U32 _1616, F *r, F *g)
SI void	from_16161616 (U64 _16161616, F *r, F *g, F *b, F *a)
template<typename T >
SI T *	ptr_at_xy (const SkRasterPipeline_MemoryCtx *ctx, size_t dx, size_t dy)
SI F	clamp (F v, F limit)
SI F	clamp_ex (F v, float limit)
SI F	sin5q_ (F x)
SI F	sin_ (F x)
SI F	cos_ (F x)
SI F	tan_ (F x)
SI F	approx_atan_unit (F x)
SI F	atan_ (F x)
SI F	asin_ (F x)
SI F	acos_ (F x)
SI F	atan2_ (F y0, F x0)
template<typename T >
SI U32	ix_and_ptr (T **ptr, const SkRasterPipeline_GatherCtx *ctx, F x, F y)
SI U32	to_unorm (F v, float scale, float bias=1.0f)
SI I32	cond_to_mask (I32 cond)
SI uint32_t	select_lane (uint32_t data, int)
SI int32_t	select_lane (int32_t data, int)
	STAGE (seed_shader, NoCtx)
	STAGE (dither, const float *rate)
	STAGE (uniform_color, const SkRasterPipeline_UniformColorCtx *c)
	STAGE (unbounded_uniform_color, const SkRasterPipeline_UniformColorCtx *c)
	STAGE (uniform_color_dst, const SkRasterPipeline_UniformColorCtx *c)
	STAGE (black_color, NoCtx)
	STAGE (white_color, NoCtx)
	STAGE (load_src, const float *ptr)
	STAGE (store_src, float *ptr)
	STAGE (store_src_rg, float *ptr)
	STAGE (load_src_rg, float *ptr)
	STAGE (store_src_a, float *ptr)
	STAGE (load_dst, const float *ptr)
	STAGE (store_dst, float *ptr)
SI F	inv (F x)
SI F	two (F x)
	BLEND_MODE (clear)
	BLEND_MODE (srcatop)
	BLEND_MODE (dstatop)
	BLEND_MODE (srcin)
	BLEND_MODE (dstin)
	BLEND_MODE (srcout)
	BLEND_MODE (dstout)
	BLEND_MODE (srcover)
	BLEND_MODE (dstover)
	BLEND_MODE (modulate)
	BLEND_MODE (multiply)
	BLEND_MODE (plus_)
	BLEND_MODE (screen)
	BLEND_MODE (xor_)
	BLEND_MODE (darken)
	BLEND_MODE (lighten)
	BLEND_MODE (difference)
	BLEND_MODE (exclusion)
	BLEND_MODE (colorburn)
	BLEND_MODE (colordodge)
	BLEND_MODE (hardlight)
	BLEND_MODE (overlay)
	BLEND_MODE (softlight)
SI F	sat (F r, F g, F b)
SI F	lum (F r, F g, F b)
SI void	set_sat (F *r, F *g, F *b, F s)
SI void	set_lum (F *r, F *g, F *b, F l)
SI F	clip_channel (F c, F l, I32 clip_low, I32 clip_high, F mn_scale, F mx_scale)
SI void	clip_color (F *r, F *g, F *b, F a)
	STAGE (hue, NoCtx)
	STAGE (saturation, NoCtx)
	STAGE (color, NoCtx)
	STAGE (luminosity, NoCtx)
	STAGE (srcover_rgba_8888, const SkRasterPipeline_MemoryCtx *ctx)
SI F	clamp_01_ (F v)
	STAGE (clamp_01, NoCtx)
	STAGE (clamp_gamut, NoCtx)
	STAGE (set_rgb, const float *rgb)
	STAGE (unbounded_set_rgb, const float *rgb)
	STAGE (swap_rb, NoCtx)
	STAGE (swap_rb_dst, NoCtx)
	STAGE (move_src_dst, NoCtx)
	STAGE (move_dst_src, NoCtx)
	STAGE (swap_src_dst, NoCtx)
	STAGE (premul, NoCtx)
	STAGE (premul_dst, NoCtx)
	STAGE (unpremul, NoCtx)
	STAGE (unpremul_polar, NoCtx)
	STAGE (force_opaque, NoCtx)
	STAGE (force_opaque_dst, NoCtx)
	STAGE (rgb_to_hsl, NoCtx)
	STAGE (hsl_to_rgb, NoCtx)
	STAGE (css_lab_to_xyz, NoCtx)
	STAGE (css_oklab_to_linear_srgb, NoCtx)
	STAGE (css_oklab_gamut_map_to_linear_srgb, NoCtx)
	STAGE (css_hcl_to_lab, NoCtx)
SI F	mod_ (F x, float y)
SI RGB	css_hsl_to_srgb_ (F h, F s, F l)
	STAGE (css_hsl_to_srgb, NoCtx)
	STAGE (css_hwb_to_srgb, NoCtx)
SI F	alpha_coverage_from_rgb_coverage (F a, F da, F cr, F cg, F cb)
	STAGE (scale_1_float, const float *c)
	STAGE (scale_u8, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (scale_565, const SkRasterPipeline_MemoryCtx *ctx)
SI F	lerp (F from, F to, F t)
	STAGE (lerp_1_float, const float *c)
	STAGE (scale_native, const float scales[])
	STAGE (lerp_native, const float scales[])
	STAGE (lerp_u8, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (lerp_565, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (emboss, const SkRasterPipeline_EmbossCtx *ctx)
	STAGE (byte_tables, const SkRasterPipeline_TablesCtx *tables)
SI F	strip_sign (F x, U32 *sign)
SI F	apply_sign (F x, U32 sign)
	STAGE (parametric, const skcms_TransferFunction *ctx)
	STAGE (gamma_, const float *G)
	STAGE (PQish, const skcms_TransferFunction *ctx)
	STAGE (HLGish, const skcms_TransferFunction *ctx)
	STAGE (HLGinvish, const skcms_TransferFunction *ctx)
	STAGE (load_a8, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_a8_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_a8, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_a8, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (store_r8, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_565, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_565_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_565, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_565, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_4444, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_4444_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_4444, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_4444, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_8888, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_8888_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_8888, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_8888, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_rg88, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_rg88_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_rg88, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_rg88, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_a16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_a16_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_a16, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_a16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_rg1616, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_rg1616_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_rg1616, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_rg1616, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_16161616, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_16161616_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_16161616, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_16161616, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_10x6, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_10x6_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_10x6, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_10x6, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_1010102, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_1010102_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_1010102_xr, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_1010102_xr_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_1010102, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (gather_1010102_xr, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (gather_10101010_xr, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (load_10101010_xr, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_10101010_xr_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (store_10101010_xr, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (store_1010102, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (store_1010102_xr, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_f16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_f16_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_f16, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_f16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_af16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_af16_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_af16, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_af16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_rgf16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_rgf16_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_rgf16, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_rgf16, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_f32, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (load_f32_dst, const SkRasterPipeline_MemoryCtx *ctx)
	STAGE (gather_f32, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (store_f32, const SkRasterPipeline_MemoryCtx *ctx)
SI F	exclusive_repeat (F v, const SkRasterPipeline_TileCtx *ctx)
SI F	exclusive_mirror (F v, const SkRasterPipeline_TileCtx *ctx)
	STAGE (repeat_x, const SkRasterPipeline_TileCtx *ctx)
	STAGE (repeat_y, const SkRasterPipeline_TileCtx *ctx)
	STAGE (mirror_x, const SkRasterPipeline_TileCtx *ctx)
	STAGE (mirror_y, const SkRasterPipeline_TileCtx *ctx)
	STAGE (clamp_x_1, NoCtx)
	STAGE (repeat_x_1, NoCtx)
	STAGE (mirror_x_1, NoCtx)
	STAGE (clamp_x_and_y, const SkRasterPipeline_CoordClampCtx *ctx)
	STAGE (decal_x, SkRasterPipeline_DecalTileCtx *ctx)
	STAGE (decal_y, SkRasterPipeline_DecalTileCtx *ctx)
	STAGE (decal_x_and_y, SkRasterPipeline_DecalTileCtx *ctx)
	STAGE (check_decal_mask, SkRasterPipeline_DecalTileCtx *ctx)
	STAGE (alpha_to_gray, NoCtx)
	STAGE (alpha_to_gray_dst, NoCtx)
	STAGE (alpha_to_red, NoCtx)
	STAGE (alpha_to_red_dst, NoCtx)
	STAGE (bt709_luminance_or_luma_to_alpha, NoCtx)
	STAGE (bt709_luminance_or_luma_to_rgb, NoCtx)
	STAGE (matrix_translate, const float *m)
	STAGE (matrix_scale_translate, const float *m)
	STAGE (matrix_2x3, const float *m)
	STAGE (matrix_3x3, const float *m)
	STAGE (matrix_3x4, const float *m)
	STAGE (matrix_4x5, const float *m)
	STAGE (matrix_4x3, const float *m)
	STAGE (matrix_perspective, const float *m)
SI void	gradient_lookup (const SkRasterPipeline_GradientCtx *c, U32 idx, F t, F *r, F *g, F *b, F *a)
	STAGE (evenly_spaced_gradient, const SkRasterPipeline_GradientCtx *c)
	STAGE (gradient, const SkRasterPipeline_GradientCtx *c)
	STAGE (evenly_spaced_2_stop_gradient, const SkRasterPipeline_EvenlySpaced2StopGradientCtx *c)
	STAGE (xy_to_unit_angle, NoCtx)
	STAGE (xy_to_radius, NoCtx)
	STAGE (negate_x, NoCtx)
	STAGE (xy_to_2pt_conical_strip, const SkRasterPipeline_2PtConicalCtx *ctx)
	STAGE (xy_to_2pt_conical_focal_on_circle, NoCtx)
	STAGE (xy_to_2pt_conical_well_behaved, const SkRasterPipeline_2PtConicalCtx *ctx)
	STAGE (xy_to_2pt_conical_greater, const SkRasterPipeline_2PtConicalCtx *ctx)
	STAGE (xy_to_2pt_conical_smaller, const SkRasterPipeline_2PtConicalCtx *ctx)
	STAGE (alter_2pt_conical_compensate_focal, const SkRasterPipeline_2PtConicalCtx *ctx)
	STAGE (alter_2pt_conical_unswap, NoCtx)
	STAGE (mask_2pt_conical_nan, SkRasterPipeline_2PtConicalCtx *c)
	STAGE (mask_2pt_conical_degenerates, SkRasterPipeline_2PtConicalCtx *c)
	STAGE (apply_vector_mask, const uint32_t *ctx)
SI void	save_xy (F *r, F *g, SkRasterPipeline_SamplerCtx *c)
	STAGE (accumulate, const SkRasterPipeline_SamplerCtx *c)
template<int kScale>
SI void	bilinear_x (SkRasterPipeline_SamplerCtx *ctx, F *x)
template<int kScale>
SI void	bilinear_y (SkRasterPipeline_SamplerCtx *ctx, F *y)
	STAGE (bilinear_setup, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bilinear_nx, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bilinear_px, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bilinear_ny, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bilinear_py, SkRasterPipeline_SamplerCtx *ctx)
SI F	bicubic_wts (F t, float A, float B, float C, float D)
template<int kScale>
SI void	bicubic_x (SkRasterPipeline_SamplerCtx *ctx, F *x)
template<int kScale>
SI void	bicubic_y (SkRasterPipeline_SamplerCtx *ctx, F *y)
	STAGE (bicubic_setup, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_n3x, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_n1x, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_p1x, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_p3x, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_n3y, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_n1y, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_p1y, SkRasterPipeline_SamplerCtx *ctx)
	STAGE (bicubic_p3y, SkRasterPipeline_SamplerCtx *ctx)
SI F	compute_perlin_vector (U32 sample, F x, F y)
	STAGE (perlin_noise, SkRasterPipeline_PerlinNoiseCtx *ctx)
	STAGE (mipmap_linear_init, SkRasterPipeline_MipmapCtx *ctx)
	STAGE (mipmap_linear_update, SkRasterPipeline_MipmapCtx *ctx)
	STAGE (mipmap_linear_finish, SkRasterPipeline_MipmapCtx *ctx)
	STAGE (callback, SkRasterPipeline_CallbackCtx *c)
	STAGE_TAIL (set_base_pointer, std::byte *p)
	STAGE_TAIL (init_lane_masks, SkRasterPipeline_InitLaneMasksCtx *ctx)
	STAGE_TAIL (store_device_xy01, F *dst)
	STAGE_TAIL (exchange_src, F *rgba)
	STAGE_TAIL (load_condition_mask, F *ctx)
	STAGE_TAIL (store_condition_mask, F *ctx)
	STAGE_TAIL (merge_condition_mask, I32 *ptr)
	STAGE_TAIL (merge_inv_condition_mask, I32 *ptr)
	STAGE_TAIL (load_loop_mask, F *ctx)
	STAGE_TAIL (store_loop_mask, F *ctx)
	STAGE_TAIL (mask_off_loop_mask, NoCtx)
	STAGE_TAIL (reenable_loop_mask, I32 *ptr)
	STAGE_TAIL (merge_loop_mask, I32 *ptr)
	STAGE_TAIL (continue_op, I32 *continueMask)
	STAGE_TAIL (case_op, SkRasterPipeline_CaseOpCtx *packed)
	STAGE_TAIL (load_return_mask, F *ctx)
	STAGE_TAIL (store_return_mask, F *ctx)
	STAGE_TAIL (mask_off_return_mask, NoCtx)
	STAGE_BRANCH (branch_if_all_lanes_active, SkRasterPipeline_BranchIfAllLanesActiveCtx *ctx)
	STAGE_BRANCH (branch_if_any_lanes_active, SkRasterPipeline_BranchCtx *ctx)
	STAGE_BRANCH (branch_if_no_lanes_active, SkRasterPipeline_BranchCtx *ctx)
	STAGE_BRANCH (jump, SkRasterPipeline_BranchCtx *ctx)
	STAGE_BRANCH (branch_if_no_active_lanes_eq, SkRasterPipeline_BranchIfEqualCtx *ctx)
	STAGE_TAIL (trace_line, SkRasterPipeline_TraceLineCtx *ctx)
	STAGE_TAIL (trace_enter, SkRasterPipeline_TraceFuncCtx *ctx)
	STAGE_TAIL (trace_exit, SkRasterPipeline_TraceFuncCtx *ctx)
	STAGE_TAIL (trace_scope, SkRasterPipeline_TraceScopeCtx *ctx)
	STAGE_TAIL (trace_var, SkRasterPipeline_TraceVarCtx *ctx)
	STAGE_TAIL (copy_uniform, SkRasterPipeline_UniformCtx *ctx)
	STAGE_TAIL (copy_2_uniforms, SkRasterPipeline_UniformCtx *ctx)
	STAGE_TAIL (copy_3_uniforms, SkRasterPipeline_UniformCtx *ctx)
	STAGE_TAIL (copy_4_uniforms, SkRasterPipeline_UniformCtx *ctx)
	STAGE_TAIL (copy_constant, SkRasterPipeline_ConstantCtx *packed)
	STAGE_TAIL (splat_2_constants, SkRasterPipeline_ConstantCtx *packed)
	STAGE_TAIL (splat_3_constants, SkRasterPipeline_ConstantCtx *packed)
	STAGE_TAIL (splat_4_constants, SkRasterPipeline_ConstantCtx *packed)
template<int NumSlots>
SI void	copy_n_slots_unmasked_fn (SkRasterPipeline_BinaryOpCtx *packed, std::byte *base)
	STAGE_TAIL (copy_slot_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_2_slots_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_3_slots_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_4_slots_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
template<int NumSlots>
SI void	copy_n_immutable_unmasked_fn (SkRasterPipeline_BinaryOpCtx *packed, std::byte *base)
	STAGE_TAIL (copy_immutable_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_2_immutables_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_3_immutables_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_4_immutables_unmasked, SkRasterPipeline_BinaryOpCtx *packed)
template<int NumSlots>
SI void	copy_n_slots_masked_fn (SkRasterPipeline_BinaryOpCtx *packed, std::byte *base, I32 mask)
	STAGE_TAIL (copy_slot_masked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_2_slots_masked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_3_slots_masked, SkRasterPipeline_BinaryOpCtx *packed)
	STAGE_TAIL (copy_4_slots_masked, SkRasterPipeline_BinaryOpCtx *packed)
template<int LoopCount, typename OffsetType >
SI void	shuffle_fn (std::byte *ptr, OffsetType *offsets, int numSlots)
template<int N>
SI void	small_swizzle_fn (SkRasterPipeline_SwizzleCtx *packed, std::byte *base)
	STAGE_TAIL (swizzle_1, SkRasterPipeline_SwizzleCtx *packed)
	STAGE_TAIL (swizzle_2, SkRasterPipeline_SwizzleCtx *packed)
	STAGE_TAIL (swizzle_3, SkRasterPipeline_SwizzleCtx *packed)
	STAGE_TAIL (swizzle_4, SkRasterPipeline_SwizzleCtx *packed)
	STAGE_TAIL (shuffle, SkRasterPipeline_ShuffleCtx *ctx)
template<int NumSlots>
SI void	swizzle_copy_masked_fn (I32 *dst, const I32 *src, uint16_t *offsets, I32 mask)
	STAGE_TAIL (swizzle_copy_slot_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)
	STAGE_TAIL (swizzle_copy_2_slots_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)
	STAGE_TAIL (swizzle_copy_3_slots_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)
	STAGE_TAIL (swizzle_copy_4_slots_masked, SkRasterPipeline_SwizzleCopyCtx *ctx)
	STAGE_TAIL (copy_from_indirect_unmasked, SkRasterPipeline_CopyIndirectCtx *ctx)
	STAGE_TAIL (copy_from_indirect_uniform_unmasked, SkRasterPipeline_CopyIndirectCtx *ctx)
	STAGE_TAIL (copy_to_indirect_masked, SkRasterPipeline_CopyIndirectCtx *ctx)
	STAGE_TAIL (swizzle_copy_to_indirect_masked, SkRasterPipeline_SwizzleCopyIndirectCtx *ctx)
template<typename T , void(*)(T *) ApplyFn>
SI void	apply_adjacent_unary (T *dst, T *end)
template<typename T >
SI void	cast_to_float_from_fn (T *dst)
SI void	cast_to_int_from_fn (F *dst)
SI void	cast_to_uint_from_fn (F *dst)
SI void	abs_fn (I32 *dst)
SI void	floor_fn (F *dst)
SI void	ceil_fn (F *dst)
SI void	invsqrt_fn (F *dst)
	DECLARE_UNARY_INT (cast_to_float_from) DECLARE_UNARY_UINT(cast_to_float_from) STAGE_TAIL(sin_float
	STAGE_TAIL (cos_float, F *dst)
	STAGE_TAIL (tan_float, F *dst)
	STAGE_TAIL (asin_float, F *dst)
	STAGE_TAIL (acos_float, F *dst)
	STAGE_TAIL (atan_float, F *dst)
	STAGE_TAIL (sqrt_float, F *dst)
	STAGE_TAIL (exp_float, F *dst)
	STAGE_TAIL (exp2_float, F *dst)
	STAGE_TAIL (log_float, F *dst)
	STAGE_TAIL (log2_float, F *dst)
	STAGE_TAIL (inverse_mat2, F *dst)
	STAGE_TAIL (inverse_mat3, F *dst)
	STAGE_TAIL (inverse_mat4, F *dst)
template<typename T , void(*)(T *, T *) ApplyFn>
SI void	apply_adjacent_binary (T *dst, T *src)
template<typename T , void(*)(T *, T *) ApplyFn>
SI void	apply_adjacent_binary_packed (SkRasterPipeline_BinaryOpCtx *packed, std::byte *base)
template<int N, typename V , typename S , void(*)(V *, V *) ApplyFn>
SI void	apply_binary_immediate (SkRasterPipeline_ConstantCtx *packed, std::byte *base)
template<typename T >
SI void	add_fn (T *dst, T *src)
template<typename T >
SI void	sub_fn (T *dst, T *src)
template<typename T >
SI void	mul_fn (T *dst, T *src)
template<typename T >
SI void	div_fn (T *dst, T *src)
SI void	bitwise_and_fn (I32 *dst, I32 *src)
SI void	bitwise_or_fn (I32 *dst, I32 *src)
SI void	bitwise_xor_fn (I32 *dst, I32 *src)
template<typename T >
SI void	max_fn (T *dst, T *src)
template<typename T >
SI void	min_fn (T *dst, T *src)
template<typename T >
SI void	cmplt_fn (T *dst, T *src)
template<typename T >
SI void	cmple_fn (T *dst, T *src)
template<typename T >
SI void	cmpeq_fn (T *dst, T *src)
template<typename T >
SI void	cmpne_fn (T *dst, T *src)
SI void	atan2_fn (F *dst, F *src)
SI void	pow_fn (F *dst, F *src)
SI void	mod_fn (F *dst, F *src)
	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
	STAGE_TAIL (dot_3_floats, F *dst)
	STAGE_TAIL (dot_4_floats, F *dst)
template<int N>
SI void	matrix_multiply (SkRasterPipeline_MatrixMultiplyCtx *packed, std::byte *base)
	STAGE_TAIL (matrix_multiply_2, SkRasterPipeline_MatrixMultiplyCtx *packed)
	STAGE_TAIL (matrix_multiply_3, SkRasterPipeline_MatrixMultiplyCtx *packed)
	STAGE_TAIL (matrix_multiply_4, SkRasterPipeline_MatrixMultiplyCtx *packed)
	STAGE_TAIL (refract_4_floats, F *dst)
template<typename T , void(*)(T *, T *, T *) ApplyFn>
SI void	apply_adjacent_ternary (T *dst, T *src0, T *src1)
template<typename T , void(*)(T *, T *, T *) ApplyFn>
SI void	apply_adjacent_ternary_packed (SkRasterPipeline_TernaryOpCtx *packed, std::byte *base)
SI void	mix_fn (F *a, F *x, F *y)
SI void	mix_fn (I32 *a, I32 *x, I32 *y)
SI void	smoothstep_fn (F *edge0, F *edge1, F *x)
	STAGE (gauss_a_to_rgba, NoCtx)
	STAGE (bilerp_clamp_8888, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (bicubic_clamp_8888, const SkRasterPipeline_GatherCtx *ctx)
	STAGE (swizzle, void *ctx)
constexpr size_t	raster_pipeline_lowp_stride ()
constexpr size_t	raster_pipeline_highp_stride ()

Variables
static constexpr void(*	S32_alpha_D32_filter_DXDY )(const SkBitmapProcState &, const uint32_t *, int, SkPMColor *) = nullptr
static constexpr F	F0 = F_(0.0f)
static constexpr F	F1 = F_(1.0f)
static constexpr size_t	N = sizeof(F) / sizeof(float)
F *	dst { *dst = sin_(*dst)

Typedef Documentation

F

using SK_OPTS_NS::F = typedef float

Definition at line 134 of file SkRasterPipeline_opts.h.

I32

using SK_OPTS_NS::I32 = typedef int32_t

Definition at line 135 of file SkRasterPipeline_opts.h.

Stage

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

Definition at line 1524 of file SkRasterPipeline_opts.h.

U16

using SK_OPTS_NS::U16 = typedef uint16_t

Definition at line 138 of file SkRasterPipeline_opts.h.

U32

using SK_OPTS_NS::U32 = typedef uint32_t

Definition at line 137 of file SkRasterPipeline_opts.h.

U64

using SK_OPTS_NS::U64 = typedef uint64_t

Definition at line 136 of file SkRasterPipeline_opts.h.

U8

using SK_OPTS_NS::U8 = typedef uint8_t

Definition at line 139 of file SkRasterPipeline_opts.h.

Function Documentation

abs_() [1/2]

SI F SK_OPTS_NS::abs_

(

F

v

)

Definition at line 150 of file SkRasterPipeline_opts.h.

{ return fabsf(v); }

abs_() [2/2]

SI I32 SK_OPTS_NS::abs_

(

I32

v

)

Definition at line 151 of file SkRasterPipeline_opts.h.

{ return v < 0 ? -v : v; }

abs_fn()

SI void SK_OPTS_NS::abs_fn

(

I32 *

dst

)

Definition at line 4398 of file SkRasterPipeline_opts.h.

                         {
    *dst = abs_(*dst);
}

acos_()

SI F SK_OPTS_NS::acos_

(

F

x

)

Definition at line 1957 of file SkRasterPipeline_opts.h.

                {
    return SK_FloatPI/2 - asin_(x);
}

add_fn()

template<typename T >

SI void SK_OPTS_NS::add_fn	(	T *	dst,
		T *	src
	)

Definition at line 4569 of file SkRasterPipeline_opts.h.

                               {
    *dst += *src;
}

all()

SI bool SK_OPTS_NS::all

(

I32

c

)

Definition at line 169 of file SkRasterPipeline_opts.h.

{ return c != 0; }

alpha_coverage_from_rgb_coverage()

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

Definition at line 2615 of file SkRasterPipeline_opts.h.

                                                                   {
    return if_then_else(a < da, min(cr, min(cg,cb))
                              , max(cr, max(cg,cb)));
}

any()

SI bool SK_OPTS_NS::any

(

I32

c

)

Definition at line 168 of file SkRasterPipeline_opts.h.

{ return c != 0; }

apply_adjacent_binary()

template<typename T , void(*)(T *, T *) ApplyFn>

SI void SK_OPTS_NS::apply_adjacent_binary	(	T *	dst,
		T *	src
	)

Definition at line 4539 of file SkRasterPipeline_opts.h.

                                              {
    T* end = src;
    do {
        ApplyFn(dst, src);
        dst += 1;
        src += 1;
    } while (dst != end);
}

apply_adjacent_binary_packed()

template<typename T , void(*)(T *, T *) ApplyFn>

SI void SK_OPTS_NS::apply_adjacent_binary_packed	(	SkRasterPipeline_BinaryOpCtx *	packed,
		std::byte *	base
	)

Definition at line 4549 of file SkRasterPipeline_opts.h.

                                                                                          {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    std::byte* dst = base + ctx.dst;
    std::byte* src = base + ctx.src;
    apply_adjacent_binary<T, ApplyFn>((T*)dst, (T*)src);
}

apply_adjacent_ternary()

template<typename T , void(*)(T *, T *, T *) ApplyFn>

SI void SK_OPTS_NS::apply_adjacent_ternary	(	T *	dst,
		T *	src0,
		T *	src1
	)

Definition at line 4868 of file SkRasterPipeline_opts.h.

                                                         {
    int count = src0 - dst;
#if !defined(JUMPER_IS_SCALAR)
    SK_ASSUME(count >= 1);
#endif
 
    for (int index = 0; index < count; ++index) {
        ApplyFn(dst, src0, src1);
        dst += 1;
        src0 += 1;
        src1 += 1;
    }
}

apply_adjacent_ternary_packed()

template<typename T , void(*)(T *, T *, T *) ApplyFn>

SI void SK_OPTS_NS::apply_adjacent_ternary_packed	(	SkRasterPipeline_TernaryOpCtx *	packed,
		std::byte *	base
	)

Definition at line 4883 of file SkRasterPipeline_opts.h.

                                                                                            {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    std::byte* dst  = base + ctx.dst;
    std::byte* src0 = dst  + ctx.delta;
    std::byte* src1 = src0 + ctx.delta;
    apply_adjacent_ternary<T, ApplyFn>((T*)dst, (T*)src0, (T*)src1);
}

apply_adjacent_unary()

template<typename T , void(*)(T *) ApplyFn>

SI void SK_OPTS_NS::apply_adjacent_unary	(	T *	dst,
		T *	end
	)

Definition at line 4367 of file SkRasterPipeline_opts.h.

                                             {
    do {
        ApplyFn(dst);
        dst += 1;
    } while (dst != end);
}

apply_binary_immediate()

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
	)

Definition at line 4557 of file SkRasterPipeline_opts.h.

                                                                                    {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    V* dst = (V*)(base + ctx.dst);         // get a pointer to the destination
    S scalar = sk_bit_cast<S>(ctx.value);  // bit-pun the constant value as desired
    V src = scalar - V();                  // broadcast the constant value into a vector
    SK_UNROLL for (int index = 0; index < N; ++index) {
        ApplyFn(dst, &src);                // perform the operation
        dst += 1;
    }
}

apply_sign()

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

Definition at line 2725 of file SkRasterPipeline_opts.h.

                               {
    return sk_bit_cast<F>(sign | sk_bit_cast<U32>(x));
}

approx_atan_unit()

SI F SK_OPTS_NS::approx_atan_unit

(

F

x

)

Definition at line 1915 of file SkRasterPipeline_opts.h.

                           {
    // y =   0.14130025741326729 x⁴
    //     - 0.34312835980675116 x³
    //     - 0.016172900528248768 x²
    //     + 1.00376969762003850 x
    //     - 0.00014758242182738969
    const float c4 =  0.14130025741326729f;
    const float c3 = -0.34312835980675116f;
    const float c2 = -0.016172900528248768f;
    const float c1 =  1.0037696976200385f;
    const float c0 = -0.00014758242182738969f;
    return mad(x, mad(x, mad(x, mad(x, c4, c3), c2), c1), c0);
}

approx_exp()

SI F SK_OPTS_NS::approx_exp

(

F

x

)

Definition at line 1386 of file SkRasterPipeline_opts.h.

                     {
    const float log2_e = 1.4426950408889634074f;
    return approx_pow2(log2_e * x);
}

approx_log()

SI F SK_OPTS_NS::approx_log

(

F

x

)

Definition at line 1369 of file SkRasterPipeline_opts.h.

                     {
    const float ln2 = 0.69314718f;
    return ln2 * approx_log2(x);
}

approx_log2()

SI F SK_OPTS_NS::approx_log2

(

F

x

)

Definition at line 1359 of file SkRasterPipeline_opts.h.

                      {
    // e - 127 is a fair approximation of log2(x) in its own right...
    F e = cast(sk_bit_cast<U32>(x)) * (1.0f / (1<<23));
 
    // ... but using the mantissa to refine its error is _much_ better.
    F m = sk_bit_cast<F>((sk_bit_cast<U32>(x) & 0x007fffff) | 0x3f000000);
 
    return nmad(m, 1.498030302f, e - 124.225514990f) - 1.725879990f / (0.3520887068f + m);
}

approx_pow2()

SI F SK_OPTS_NS::approx_pow2

(

F

x

)

Definition at line 1374 of file SkRasterPipeline_opts.h.

                      {
    constexpr float kInfinityBits = 0x7f800000;
 
    F f = fract(x);
    F approx = nmad(f, 1.490129070f, x + 121.274057500f);
      approx += 27.728023300f / (4.84252568f - f);
      approx *= 1.0f * (1<<23);
      approx  = min(max(approx, F0), F_(kInfinityBits));  // guard against underflow/overflow
 
    return sk_bit_cast<F>(round(approx));
}

approx_powf()

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

Definition at line 1391 of file SkRasterPipeline_opts.h.

                           {
    return if_then_else((x == 0)|(x == 1), x
                                         , approx_pow2(approx_log2(x) * y));
}

asin_()

SI F SK_OPTS_NS::asin_

(

F

x

)

Definition at line 1944 of file SkRasterPipeline_opts.h.

                {
    I32 neg = (x < 0.0f);
    x = if_then_else(neg, -x, x);
    const float c3 = -0.0187293f;
    const float c2 = 0.0742610f;
    const float c1 = -0.2121144f;
    const float c0 = 1.5707288f;
    F poly = mad(x, mad(x, mad(x, c3, c2), c1), c0);
    x = nmad(sqrt_(1 - x), poly, SK_FloatPI/2);
    x = if_then_else(neg, -x, x);
    return x;
}

atan2_()

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

Definition at line 1965 of file SkRasterPipeline_opts.h.

                        {
    I32 flip = (abs_(y0) > abs_(x0));
    F   y = if_then_else(flip, x0, y0);
    F   x = if_then_else(flip, y0, x0);
    F   arg = y/x;
 
    I32 neg = (arg < 0.0f);
    arg = if_then_else(neg, -arg, arg);
 
    F r = approx_atan_unit(arg);
    r = if_then_else(flip, SK_FloatPI/2 - r, r);
    r = if_then_else(neg, -r, r);
 
    // handle quadrant distinctions
    r = if_then_else((y0 >= 0) & (x0  < 0), r + SK_FloatPI, r);
    r = if_then_else((y0  < 0) & (x0 <= 0), r - SK_FloatPI, r);
    // Note: we don't try to handle 0,0 or infinities
    return r;
}

atan2_fn()

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

Definition at line 4643 of file SkRasterPipeline_opts.h.

                                 {
    *dst = atan2_(*dst, *src);
}

atan_()

SI F SK_OPTS_NS::atan_

(

F

x

)

Definition at line 1930 of file SkRasterPipeline_opts.h.

                {
    I32 neg = (x < 0.0f);
    x = if_then_else(neg, -x, x);
    I32 flip = (x > 1.0f);
    x = if_then_else(flip, 1/x, x);
    x = approx_atan_unit(x);
    x = if_then_else(flip, SK_FloatPI/2 - x, x);
    x = if_then_else(neg, -x, x);
    return x;
}

bicubic_wts()

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

Definition at line 3633 of file SkRasterPipeline_opts.h.

                                                          {
    return mad(t, mad(t, mad(t, D, C), B), A);
}

bicubic_x()

template<int kScale>

SI void SK_OPTS_NS::bicubic_x	(	SkRasterPipeline_SamplerCtx *	ctx,
		F *	x
	)

Definition at line 3638 of file SkRasterPipeline_opts.h.

                                                          {
    *x = sk_unaligned_load<F>(ctx->x) + (kScale * 0.5f);
 
    F scalex;
    if (kScale == -3) { scalex = sk_unaligned_load<F>(ctx->wx[0]); }
    if (kScale == -1) { scalex = sk_unaligned_load<F>(ctx->wx[1]); }
    if (kScale == +1) { scalex = sk_unaligned_load<F>(ctx->wx[2]); }
    if (kScale == +3) { scalex = sk_unaligned_load<F>(ctx->wx[3]); }
    sk_unaligned_store(ctx->scalex, scalex);
}

bicubic_y()

template<int kScale>

SI void SK_OPTS_NS::bicubic_y	(	SkRasterPipeline_SamplerCtx *	ctx,
		F *	y
	)

Definition at line 3649 of file SkRasterPipeline_opts.h.

                                                          {
    *y = sk_unaligned_load<F>(ctx->y) + (kScale * 0.5f);
 
    F scaley;
    if (kScale == -3) { scaley = sk_unaligned_load<F>(ctx->wy[0]); }
    if (kScale == -1) { scaley = sk_unaligned_load<F>(ctx->wy[1]); }
    if (kScale == +1) { scaley = sk_unaligned_load<F>(ctx->wy[2]); }
    if (kScale == +3) { scaley = sk_unaligned_load<F>(ctx->wy[3]); }
    sk_unaligned_store(ctx->scaley, scaley);
}

bilinear_x()

template<int kScale>

SI void SK_OPTS_NS::bilinear_x	(	SkRasterPipeline_SamplerCtx *	ctx,
		F *	x
	)

Definition at line 3595 of file SkRasterPipeline_opts.h.

                                                           {
    *x = sk_unaligned_load<F>(ctx->x) + (kScale * 0.5f);
    F fx = sk_unaligned_load<F>(ctx->fx);
 
    F scalex;
    if (kScale == -1) { scalex = 1.0f - fx; }
    if (kScale == +1) { scalex =        fx; }
    sk_unaligned_store(ctx->scalex, scalex);
}

bilinear_y()

template<int kScale>

SI void SK_OPTS_NS::bilinear_y	(	SkRasterPipeline_SamplerCtx *	ctx,
		F *	y
	)

Definition at line 3605 of file SkRasterPipeline_opts.h.

                                                           {
    *y = sk_unaligned_load<F>(ctx->y) + (kScale * 0.5f);
    F fy = sk_unaligned_load<F>(ctx->fy);
 
    F scaley;
    if (kScale == -1) { scaley = 1.0f - fy; }
    if (kScale == +1) { scaley =        fy; }
    sk_unaligned_store(ctx->scaley, scaley);
}

bitwise_and_fn()

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

Definition at line 4593 of file SkRasterPipeline_opts.h.

                                           {
    *dst &= *src;
}

bitwise_or_fn()

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

Definition at line 4597 of file SkRasterPipeline_opts.h.

                                          {
    *dst |= *src;
}

bitwise_xor_fn()

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

Definition at line 4601 of file SkRasterPipeline_opts.h.

                                           {
    *dst ^= *src;
}

BLEND_MODE() [1/23]

SK_OPTS_NS::BLEND_MODE

(

clear

)

Definition at line 2174 of file SkRasterPipeline_opts.h.

{ return F0; }

BLEND_MODE() [2/23]

SK_OPTS_NS::BLEND_MODE

(

colorburn

)

Definition at line 2207 of file SkRasterPipeline_opts.h.

                      {
    return if_then_else(d == da,    d +    s*inv(da),
           if_then_else(s ==  0, /* s + */ d*inv(sa),
                                sa*(da - min(da, (da-d)*sa*rcp_fast(s))) + s*inv(da) + d*inv(sa)));
}

BLEND_MODE() [3/23]

SK_OPTS_NS::BLEND_MODE

(

colordodge

)

Definition at line 2212 of file SkRasterPipeline_opts.h.

                       {
    return if_then_else(d ==  0, /* d + */ s*inv(da),
           if_then_else(s == sa,    s +    d*inv(sa),
                                 sa*min(da, (d*sa)*rcp_fast(sa - s)) + s*inv(da) + d*inv(sa)));
}

BLEND_MODE() [4/23]

SK_OPTS_NS::BLEND_MODE

(

darken

)

Definition at line 2202 of file SkRasterPipeline_opts.h.

{ return s + d -     max(s*da, d*sa) ; }

BLEND_MODE() [5/23]

SK_OPTS_NS::BLEND_MODE

(

difference

)

Definition at line 2204 of file SkRasterPipeline_opts.h.

{ return s + d - two(min(s*da, d*sa)); }

BLEND_MODE() [6/23]

SK_OPTS_NS::BLEND_MODE

(

dstatop

)

Definition at line 2176 of file SkRasterPipeline_opts.h.

{ return mad(d, sa, s*inv(da)); }

BLEND_MODE() [7/23]

SK_OPTS_NS::BLEND_MODE

(

dstin

)

Definition at line 2178 of file SkRasterPipeline_opts.h.

{ return d * sa; }

BLEND_MODE() [8/23]

SK_OPTS_NS::BLEND_MODE

(

dstout

)

Definition at line 2180 of file SkRasterPipeline_opts.h.

{ return d * inv(sa); }

BLEND_MODE() [9/23]

SK_OPTS_NS::BLEND_MODE

(

dstover

)

Definition at line 2182 of file SkRasterPipeline_opts.h.

{ return mad(s, inv(da), d); }

BLEND_MODE() [10/23]

SK_OPTS_NS::BLEND_MODE

(

exclusion

)

Definition at line 2205 of file SkRasterPipeline_opts.h.

{ return s + d - two(s*d); }

BLEND_MODE() [11/23]

SK_OPTS_NS::BLEND_MODE

(

hardlight

)

Definition at line 2217 of file SkRasterPipeline_opts.h.

                      {
    return s*inv(da) + d*inv(sa)
         + if_then_else(two(s) <= sa, two(s*d), sa*da - two((da-d)*(sa-s)));
}

BLEND_MODE() [12/23]

SK_OPTS_NS::BLEND_MODE

(

lighten

)

Definition at line 2203 of file SkRasterPipeline_opts.h.

{ return s + d -     min(s*da, d*sa) ; }

BLEND_MODE() [13/23]

SK_OPTS_NS::BLEND_MODE

(

modulate

)

Definition at line 2184 of file SkRasterPipeline_opts.h.

{ return s*d; }

BLEND_MODE() [14/23]

SK_OPTS_NS::BLEND_MODE

(

multiply

)

Definition at line 2185 of file SkRasterPipeline_opts.h.

{ return mad(s, d, mad(s, inv(da), d*inv(sa))); }

BLEND_MODE() [15/23]

SK_OPTS_NS::BLEND_MODE

(

overlay

)

Definition at line 2221 of file SkRasterPipeline_opts.h.

                    {
    return s*inv(da) + d*inv(sa)
         + if_then_else(two(d) <= da, two(s*d), sa*da - two((da-d)*(sa-s)));
}

BLEND_MODE() [16/23]

SK_OPTS_NS::BLEND_MODE

(

plus_

)

Definition at line 2186 of file SkRasterPipeline_opts.h.

{ return min(s + d, 1.0f); }  // We can clamp to either 1 or sa.

BLEND_MODE() [17/23]

SK_OPTS_NS::BLEND_MODE

(

screen

)

Definition at line 2187 of file SkRasterPipeline_opts.h.

{ return nmad(s, d, s + d); }

BLEND_MODE() [18/23]

SK_OPTS_NS::BLEND_MODE

(

softlight

)

Definition at line 2226 of file SkRasterPipeline_opts.h.

                      {
    F m  = if_then_else(da > 0, d / da, 0.0f),
      s2 = two(s),
      m4 = two(two(m));
 
    // The logic forks three ways:
    //    1. dark src?
    //    2. light src, dark dst?
    //    3. light src, light dst?
    F darkSrc = d*(sa + (s2 - sa)*(1.0f - m)),     // Used in case 1.
      darkDst = (m4*m4 + m4)*(m - 1.0f) + 7.0f*m,  // Used in case 2.
      liteDst = sqrt_(m) - m,
      liteSrc = d*sa + da*(s2 - sa) * if_then_else(two(two(d)) <= da, darkDst, liteDst); // 2 or 3?
    return s*inv(da) + d*inv(sa) + if_then_else(s2 <= sa, darkSrc, liteSrc);      // 1 or (2 or 3)?
}

BLEND_MODE() [19/23]

SK_OPTS_NS::BLEND_MODE

(

srcatop

)

Definition at line 2175 of file SkRasterPipeline_opts.h.

{ return mad(s, da, d*inv(sa)); }

BLEND_MODE() [20/23]

SK_OPTS_NS::BLEND_MODE

(

srcin

)

Definition at line 2177 of file SkRasterPipeline_opts.h.

{ return s * da; }

BLEND_MODE() [21/23]

SK_OPTS_NS::BLEND_MODE

(

srcout

)

Definition at line 2179 of file SkRasterPipeline_opts.h.

{ return s * inv(da); }

BLEND_MODE() [22/23]

SK_OPTS_NS::BLEND_MODE

(

srcover

)

Definition at line 2181 of file SkRasterPipeline_opts.h.

{ return mad(d, inv(sa), s); }

BLEND_MODE() [23/23]

SK_OPTS_NS::BLEND_MODE

(

xor_

)

Definition at line 2188 of file SkRasterPipeline_opts.h.

{ return mad(s, inv(da), d*inv(sa)); }

blit_mask_d32_a8()

void SK_OPTS_NS::blit_mask_d32_a8 ( SkPMColor *  dst, size_t  dstRB, const SkAlpha *  mask, size_t  maskRB, SkColor  color, int  w, int  h  )

inline

Definition at line 400 of file SkBlitMask_opts.h.

                                                                         {
    if (color == SK_ColorBLACK) {
        blit_mask_d32_a8_black(dst, dstRB, mask, maskRB, w, h);
    } else if (SkColorGetA(color) == 0xFF) {
        blit_mask_d32_a8_opaque(dst, dstRB, mask, maskRB, color, w, h);
    } else {
        blit_mask_d32_a8_general(dst, dstRB, mask, maskRB, color, w, h);
    }
}

blit_mask_d32_a8_black()

static void SK_OPTS_NS::blit_mask_d32_a8_black ( SkPMColor *  dst, size_t  dstRB, const SkAlpha *  maskPtr, size_t  maskRB, int  width, int  height  )

static

Definition at line 275 of file SkBlitMask_opts.h.

                                                              {
        SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
        const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
 
        // Nine patch may set maskRB to 0 to blit the same row repeatedly.
        ptrdiff_t mask_adjust = (ptrdiff_t)maskRB - width;
        dstRB -= (width << 2);
        const __m128i zeros = __lsx_vldi(0);
        __m128i planar = __lsx_vldi(0);
        planar = __lsx_vinsgr2vr_d(planar, 0x0d0905010c080400, 0);
        planar = __lsx_vinsgr2vr_d(planar, 0x0f0b07030e0a0602, 1);
 
        do {
            int w = width;
            while (w >= 8) {
                __m128i vmask = __lsx_vld(mask, 0);
                vmask = __lsx_vilvl_b(zeros, vmask);
                __m128i vscale = __lsx_vsub_h(__lsx_vreplgr2vr_h(256), vmask);
                __m128i lo = __lsx_vld(device, 0);         // bgra bgra bgra bgra
                __m128i hi = __lsx_vld(device, 16);        // BGRA BGRA BGRA BGRA
                lo = __lsx_vshuf_b(zeros, lo, planar);     // bbbb gggg rrrr aaaa
                hi = __lsx_vshuf_b(zeros, hi, planar);     // BBBB GGGG RRRR AAAA
                __m128i bg = __lsx_vilvl_w(hi, lo),        // bbbb BBBB gggg GGGG
                        ra = __lsx_vilvh_w(hi, lo);        // rrrr RRRR aaaa AAAA
 
                __m128i b = __lsx_vilvl_b(zeros, bg),      // _b_b _b_b _B_B _B_B
                        g = __lsx_vilvh_b(zeros, bg),      // _g_g _g_g _G_G _G_G
                        r = __lsx_vilvl_b(zeros, ra),      // _r_r _r_r _R_R _R_R
                        a = __lsx_vilvh_b(zeros, ra);      // _a_a _a_a _A_A _A_A
 
                b = SkAlphaMul_lsx(b, vscale);
                g = SkAlphaMul_lsx(g, vscale);
                r = SkAlphaMul_lsx(r, vscale);
                a = SkAlphaMul_lsx(a, vscale);
 
                a += vmask;
 
                bg = __lsx_vor_v(b, __lsx_vslli_h(g, 8));  // bgbg bgbg BGBG BGBG
                ra = __lsx_vor_v(r, __lsx_vslli_h(a, 8));  // rara rara RARA RARA
                lo = __lsx_vilvl_h(ra, bg);                // bgra bgra bgra bgra
                hi = __lsx_vilvh_h(ra, bg);                // BGRA BGRA BGRA BGRA
 
                __lsx_vst(lo, device, 0);
                __lsx_vst(hi, device, 16);
 
                mask += 8;
                device += 8;
                w -= 8;
            }
 
            while (w-- > 0) {
                unsigned aa = *mask++;
                *device = (aa << SK_A32_SHIFT)
                            + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
                device += 1;
            }
 
            device = (uint32_t*)((char*)device + dstRB);
            mask += mask_adjust;
 
        } while (--height != 0);
    }

blit_mask_d32_a8_general()

static void SK_OPTS_NS::blit_mask_d32_a8_general ( SkPMColor *  dst, size_t  dstRB, const SkAlpha *  mask, size_t  maskRB, SkColor  color, int  w, int  h  )

static

Definition at line 262 of file SkBlitMask_opts.h.

                                                                      {
        D32_A8_Opaque_Color_lsx<true>(dst, dstRB, mask, maskRB, color, w, h);
    }

blit_mask_d32_a8_opaque()

static void SK_OPTS_NS::blit_mask_d32_a8_opaque ( SkPMColor *  dst, size_t  dstRB, const SkAlpha *  mask, size_t  maskRB, SkColor  color, int  w, int  h  )

static

Definition at line 268 of file SkBlitMask_opts.h.

                                                                      {
        D32_A8_Opaque_Color_lsx<false>(dst, dstRB, mask, maskRB, color, w, h);
    }

blit_row_color32()

void SK_OPTS_NS::blit_row_color32 ( SkPMColor *  dst, int  count, SkPMColor  color  )

inline

Definition at line 243 of file SkBlitRow_opts.h.

                                                                         {
    constexpr int N = 4;  // 8, 16 also reasonable choices
    using U32 = skvx::Vec<  N, uint32_t>;
    using U16 = skvx::Vec<4*N, uint16_t>;
    using U8  = skvx::Vec<4*N, uint8_t>;
 
    auto kernel = [color](U32 src) {
        unsigned invA = 255 - SkGetPackedA32(color);
        invA += invA >> 7;
        SkASSERT(0 < invA && invA < 256);  // We handle alpha == 0 or alpha == 255 specially.
 
        // (src * invA + (color << 8) + 128) >> 8
        // Should all fit in 16 bits.
        U8 s = sk_bit_cast<U8>(src),
           a = U8(invA);
        U16 c = skvx::cast<uint16_t>(sk_bit_cast<U8>(U32(color))),
            d = (mull(s,a) + (c << 8) + 128)>>8;
        return sk_bit_cast<U32>(skvx::cast<uint8_t>(d));
    };
 
    while (count >= N) {
        kernel(U32::Load(dst)).store(dst);
        dst   += N;
        count -= N;
    }
    while (count --> 0) {
        *dst = kernel(U32{*dst})[0];
        dst++;
    }
}

blit_row_s32a_opaque()

void SK_OPTS_NS::blit_row_s32a_opaque ( SkPMColor *  dst, const SkPMColor *  src, int  len, U8CPU  alpha  )

inline

Definition at line 164 of file SkBlitRow_opts.h.

                                                                                             {
    SkASSERT(alpha == 0xFF);
    sk_msan_assert_initialized(src, src+len);
 
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_AVX2
    while (len >= 8) {
        _mm256_storeu_si256((__m256i*)dst,
                            SkPMSrcOver_AVX2(_mm256_loadu_si256((const __m256i*)src),
                                             _mm256_loadu_si256((const __m256i*)dst)));
        src += 8;
        dst += 8;
        len -= 8;
    }
#endif
 
#if SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSE2
    while (len >= 4) {
        _mm_storeu_si128((__m128i*)dst, SkPMSrcOver_SSE2(_mm_loadu_si128((const __m128i*)src),
                                                         _mm_loadu_si128((const __m128i*)dst)));
        src += 4;
        dst += 4;
        len -= 4;
    }
#endif
 
#if defined(SK_ARM_HAS_NEON)
    while (len >= 8) {
        vst4_u8((uint8_t*)dst, SkPMSrcOver_neon8(vld4_u8((const uint8_t*)dst),
                                                 vld4_u8((const uint8_t*)src)));
        src += 8;
        dst += 8;
        len -= 8;
    }
 
    while (len >= 2) {
        vst1_u8((uint8_t*)dst, SkPMSrcOver_neon2(vld1_u8((const uint8_t*)dst),
                                                 vld1_u8((const uint8_t*)src)));
        src += 2;
        dst += 2;
        len -= 2;
    }
 
    if (len != 0) {
        uint8x8_t result = SkPMSrcOver_neon2(vcreate_u8((uint64_t)*dst),
                                             vcreate_u8((uint64_t)*src));
        vst1_lane_u32(dst, vreinterpret_u32_u8(result), 0);
    }
    return;
#endif
 
#if SK_CPU_LSX_LEVEL >= SK_CPU_LSX_LEVEL_LASX
    while (len >= 8) {
        __lasx_xvst(SkPMSrcOver_LASX(__lasx_xvld(src, 0),
                                     __lasx_xvld(dst, 0)), (__m256i*)dst, 0);
        src += 8;
        dst += 8;
        len -= 8;
    }
#endif
 
#if SK_CPU_LSX_LEVEL >= SK_CPU_LSX_LEVEL_LSX
    while (len >= 4) {
        __lsx_vst(SkPMSrcOver_LSX(__lsx_vld(src, 0),
                                  __lsx_vld(dst, 0)), (__m128i*)dst, 0);
        src += 4;
        dst += 4;
        len -= 4;
    }
#endif
 
    while (len --> 0) {
        *dst = SkPMSrcOver(*src, *dst);
        src++;
        dst++;
    }
}

cast()

SI F SK_OPTS_NS::cast

(

U32

v

)

Definition at line 1337 of file SkRasterPipeline_opts.h.

{ return   (F)v; }

cast64()

SI F SK_OPTS_NS::cast64

(

U64

v

)

Definition at line 1338 of file SkRasterPipeline_opts.h.

{ return   (F)v; }

cast_to_float_from_fn()

template<typename T >

SI void SK_OPTS_NS::cast_to_float_from_fn

(

T *

dst

)

Definition at line 4376 of file SkRasterPipeline_opts.h.

                                      {
    *dst = sk_bit_cast<T>((F)*dst);
}

cast_to_int_from_fn()

SI void SK_OPTS_NS::cast_to_int_from_fn

(

F *

dst

)

Definition at line 4379 of file SkRasterPipeline_opts.h.

                                    {
    *dst = sk_bit_cast<F>((I32)*dst);
}

cast_to_uint_from_fn()

SI void SK_OPTS_NS::cast_to_uint_from_fn

(

F *

dst

)

Definition at line 4382 of file SkRasterPipeline_opts.h.

                                     {
    *dst = sk_bit_cast<F>((U32)*dst);
}

ceil_()

SI F SK_OPTS_NS::ceil_

(

F

v

)

Definition at line 153 of file SkRasterPipeline_opts.h.

{ return ceilf(v); }

ceil_fn()

SI void SK_OPTS_NS::ceil_fn

(

F *

dst

)

Definition at line 4406 of file SkRasterPipeline_opts.h.

                        {
    *dst = ceil_(*dst);
}

clamp()

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

Definition at line 1825 of file SkRasterPipeline_opts.h.

                         {
    F inclusive = sk_bit_cast<F>(sk_bit_cast<U32>(limit) - 1);  // Exclusive -> inclusive.
    return min(max(0.0f, v), inclusive);
}

clamp_01_()

SI F SK_OPTS_NS::clamp_01_

(

F

v

)

Definition at line 2371 of file SkRasterPipeline_opts.h.

{ return min(max(0.0f, v), 1.0f); }

clamp_ex()

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

Definition at line 1831 of file SkRasterPipeline_opts.h.

                                {
    const F inclusiveZ = F_(std::numeric_limits<float>::min()),
            inclusiveL = sk_bit_cast<F>( sk_bit_cast<U32>(F_(limit)) - 1 );
    return min(max(inclusiveZ, v), inclusiveL);
}

clip_channel()

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

Definition at line 2271 of file SkRasterPipeline_opts.h.

                                                                                 {
    c = if_then_else(clip_low,  mad(mn_scale, c - l, l), c);
    c = if_then_else(clip_high, mad(mx_scale, c - l, l), c);
    c = max(c, 0.0f);  // Sometimes without this we may dip just a little negative.
    return c;
}

clip_color()

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

Definition at line 2277 of file SkRasterPipeline_opts.h.

                                          {
    F   mn        = min(*r, min(*g, *b)),
        mx        = max(*r, max(*g, *b)),
        l         = lum(*r, *g, *b),
        mn_scale  = (    l) * rcp_fast(l - mn),
        mx_scale  = (a - l) * rcp_fast(mx - l);
    I32 clip_low  = cond_to_mask(mn < 0 && l != mn),
        clip_high = cond_to_mask(mx > a && l != mx);
 
    *r = clip_channel(*r, l, clip_low, clip_high, mn_scale, mx_scale);
    *g = clip_channel(*g, l, clip_low, clip_high, mn_scale, mx_scale);
    *b = clip_channel(*b, l, clip_low, clip_high, mn_scale, mx_scale);
}

cmpeq_fn()

template<typename T >

SI void SK_OPTS_NS::cmpeq_fn	(	T *	dst,
		T *	src
	)

Definition at line 4630 of file SkRasterPipeline_opts.h.

                                 {
    static_assert(sizeof(T) == sizeof(I32));
    I32 result = cond_to_mask(*dst == *src);
    memcpy(dst, &result, sizeof(I32));
}

cmple_fn()

template<typename T >

SI void SK_OPTS_NS::cmple_fn	(	T *	dst,
		T *	src
	)

Definition at line 4623 of file SkRasterPipeline_opts.h.

                                 {
    static_assert(sizeof(T) == sizeof(I32));
    I32 result = cond_to_mask(*dst <= *src);
    memcpy(dst, &result, sizeof(I32));
}

cmplt_fn()

template<typename T >

SI void SK_OPTS_NS::cmplt_fn	(	T *	dst,
		T *	src
	)

Definition at line 4616 of file SkRasterPipeline_opts.h.

                                 {
    static_assert(sizeof(T) == sizeof(I32));
    I32 result = cond_to_mask(*dst < *src);
    memcpy(dst, &result, sizeof(I32));
}

cmpne_fn()

template<typename T >

SI void SK_OPTS_NS::cmpne_fn	(	T *	dst,
		T *	src
	)

Definition at line 4637 of file SkRasterPipeline_opts.h.

                                 {
    static_assert(sizeof(T) == sizeof(I32));
    I32 result = cond_to_mask(*dst != *src);
    memcpy(dst, &result, sizeof(I32));
}

compute_perlin_vector()

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

Definition at line 3691 of file SkRasterPipeline_opts.h.

                                                 {
    // We're relying on the packing of uint16s within a uint32, which will vary based on endianness.
#ifdef SK_CPU_BENDIAN
    U32 sampleLo = sample >> 16;
    U32 sampleHi = sample & 0xFFFF;
#else
    U32 sampleLo = sample & 0xFFFF;
    U32 sampleHi = sample >> 16;
#endif
 
    // Convert 32-bit sample value into two floats in the [-1..1] range.
    F vecX = mad(cast(sampleLo), 2.0f / 65535.0f, -1.0f);
    F vecY = mad(cast(sampleHi), 2.0f / 65535.0f, -1.0f);
 
    // Return the dot of the sample and the passed-in vector.
    return mad(vecX,  x,
               vecY * y);
}

cond_to_mask()

SI I32 SK_OPTS_NS::cond_to_mask

(

I32

cond

)

Definition at line 2010 of file SkRasterPipeline_opts.h.

                              {
#if defined(JUMPER_IS_SCALAR)
    // In scalar mode, conditions are bools (0 or 1), but we want to store and operate on masks
    // (eg, using bitwise operations to select values).
    return if_then_else(cond, I32(~0), I32(0));
#else
    // In SIMD mode, our various instruction sets already represent conditions as masks.
    return cond;
#endif
}

copy_n_immutable_unmasked_fn()

template<int NumSlots>

SI void SK_OPTS_NS::copy_n_immutable_unmasked_fn	(	SkRasterPipeline_BinaryOpCtx *	packed,
		std::byte *	base
	)

Definition at line 4139 of file SkRasterPipeline_opts.h.

                                                                                          {
    auto ctx = SkRPCtxUtils::Unpack(packed);
 
    // Load the scalar values.
    float* src = (float*)(base + ctx.src);
    float values[NumSlots];
    SK_UNROLL for (int index = 0; index < NumSlots; ++index) {
        values[index] = src[index];
    }
    // Broadcast the scalars into the destination.
    F* dst = (F*)(base + ctx.dst);
    SK_UNROLL for (int index = 0; index < NumSlots; ++index) {
        dst[index] = F_(values[index]);
    }
}

copy_n_slots_masked_fn()

template<int NumSlots>

SI void SK_OPTS_NS::copy_n_slots_masked_fn	(	SkRasterPipeline_BinaryOpCtx *	packed,
		std::byte *	base,
		I32	mask
	)

Definition at line 4169 of file SkRasterPipeline_opts.h.

                                                                                              {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    I32* dst = (I32*)(base + ctx.dst);
    I32* src = (I32*)(base + ctx.src);
    SK_UNROLL for (int count = 0; count < NumSlots; ++count) {
        *dst = if_then_else(mask, *src, *dst);
        dst += 1;
        src += 1;
    }
}

copy_n_slots_unmasked_fn()

template<int NumSlots>

SI void SK_OPTS_NS::copy_n_slots_unmasked_fn	(	SkRasterPipeline_BinaryOpCtx *	packed,
		std::byte *	base
	)

Definition at line 4118 of file SkRasterPipeline_opts.h.

                                                                                      {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    F* dst = (F*)(base + ctx.dst);
    F* src = (F*)(base + ctx.src);
    memcpy(dst, src, sizeof(F) * NumSlots);
}

cos_()

SI F SK_OPTS_NS::cos_

(

F

x

)

Definition at line 1857 of file SkRasterPipeline_opts.h.

               {
    constexpr float one_over_pi2 = 1 / (2 * SK_FloatPI);
    x *= one_over_pi2;
    x = 0.25f - abs_(x - floor_(x + 0.5f));
    return sin5q_(x);
}

css_hsl_to_srgb_()

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

Definition at line 2570 of file SkRasterPipeline_opts.h.

                                       {
    h = mod_(h, 360);
 
    s *= 0.01f;
    l *= 0.01f;
 
    F k[3] = {
        mod_(0 + h * (1 / 30.0f), 12),
        mod_(8 + h * (1 / 30.0f), 12),
        mod_(4 + h * (1 / 30.0f), 12)
    };
    F a  = s * min(l, 1 - l);
    return {
        l - a * max(-1.0f, min(min(k[0] - 3.0f, 9.0f - k[0]), 1.0f)),
        l - a * max(-1.0f, min(min(k[1] - 3.0f, 9.0f - k[1]), 1.0f)),
        l - a * max(-1.0f, min(min(k[2] - 3.0f, 9.0f - k[2]), 1.0f))
    };
}

D32_A8_Opaque_Color_lsx()

template<bool isColor>

static void SK_OPTS_NS::D32_A8_Opaque_Color_lsx ( void *SK_RESTRICT  dst, size_t  dstRB, const void *SK_RESTRICT  maskPtr, size_t  maskRB, SkColor  color, int  width, int  height  )

static

Definition at line 174 of file SkBlitMask_opts.h.

                                                                               {
        SkPMColor pmc = SkPreMultiplyColor(color);
        SkPMColor* SK_RESTRICT device = (SkPMColor*)dst;
        const uint8_t* SK_RESTRICT mask = (const uint8_t*)maskPtr;
        __m128i vpmc_b = __lsx_vldi(0);
        __m128i vpmc_g = __lsx_vldi(0);
        __m128i vpmc_r = __lsx_vldi(0);
        __m128i vpmc_a = __lsx_vldi(0);
 
        // Nine patch may set maskRB to 0 to blit the same row repeatedly.
        ptrdiff_t mask_adjust = (ptrdiff_t)maskRB - width;
        dstRB -= (width << 2);
 
        if (width >= 8) {
            vpmc_b = __lsx_vreplgr2vr_h(SkGetPackedB32(pmc));
            vpmc_g = __lsx_vreplgr2vr_h(SkGetPackedG32(pmc));
            vpmc_r = __lsx_vreplgr2vr_h(SkGetPackedR32(pmc));
            vpmc_a = __lsx_vreplgr2vr_h(SkGetPackedA32(pmc));
        }
 
        const __m128i zeros = __lsx_vldi(0);
        __m128i planar = __lsx_vldi(0);
        planar = __lsx_vinsgr2vr_d(planar, 0x0d0905010c080400, 0);
        planar = __lsx_vinsgr2vr_d(planar, 0x0f0b07030e0a0602, 1);
 
        do{
            int w = width;
            while(w >= 8){
                __m128i lo = __lsx_vld(device, 0);         // bgra bgra bgra bgra
                __m128i hi = __lsx_vld(device, 16);        // BGRA BGRA BGRA BGRA
                lo = __lsx_vshuf_b(zeros, lo, planar);     // bbbb gggg rrrr aaaa
                hi = __lsx_vshuf_b(zeros, hi, planar);     // BBBB GGGG RRRR AAAA
                __m128i bg = __lsx_vilvl_w(hi, lo),        // bbbb BBBB gggg GGGG
                        ra = __lsx_vilvh_w(hi, lo);        // rrrr RRRR aaaa AAAA
 
                __m128i b = __lsx_vilvl_b(zeros, bg),      // _b_b _b_b _B_B _B_B
                        g = __lsx_vilvh_b(zeros, bg),      // _g_g _g_g _G_G _G_G
                        r = __lsx_vilvl_b(zeros, ra),      // _r_r _r_r _R_R _R_R
                        a = __lsx_vilvh_b(zeros, ra);      // _a_a _a_a _A_A _A_A
 
                __m128i vmask = __lsx_vld(mask, 0);
                vmask = __lsx_vilvl_b(zeros, vmask);
                __m128i vscale, vmask256 = __lsx_vadd_h(vmask, __lsx_vreplgr2vr_h(1));
 
                if (isColor) {
                    __m128i tmp = SkAlphaMul_lsx(vpmc_a, vmask256);
                    vscale = __lsx_vsub_h(__lsx_vreplgr2vr_h(256), tmp);
                } else {
                    vscale = __lsx_vsub_h(__lsx_vreplgr2vr_h(256), vmask);
                }
 
                b = SkAlphaMul_lsx(vpmc_b, vmask256) + SkAlphaMul_lsx(b, vscale);
                g = SkAlphaMul_lsx(vpmc_g, vmask256) + SkAlphaMul_lsx(g, vscale);
                r = SkAlphaMul_lsx(vpmc_r, vmask256) + SkAlphaMul_lsx(r, vscale);
                a = SkAlphaMul_lsx(vpmc_a, vmask256) + SkAlphaMul_lsx(a, vscale);
 
                bg = __lsx_vor_v(b, __lsx_vslli_h(g, 8));  // bgbg bgbg BGBG BGBG
                ra = __lsx_vor_v(r, __lsx_vslli_h(a, 8));  // rara rara RARA RARA
                lo = __lsx_vilvl_h(ra, bg);                // bgra bgra bgra bgra
                hi = __lsx_vilvh_h(ra, bg);                // BGRA BGRA BGRA BGRA
 
                __lsx_vst(lo, device, 0);
                __lsx_vst(hi, device, 16);
 
                mask += 8;
                device += 8;
                w -= 8;
            }
 
            while (w--) {
                unsigned aa = *mask++;
                if (isColor) {
                    *device = SkBlendARGB32(pmc, *device, aa);
                } else {
                    *device = SkAlphaMulQ(pmc, SkAlpha255To256(aa))
                        + SkAlphaMulQ(*device, SkAlpha255To256(255 - aa));
                }
                device += 1;
            }
 
            device = (uint32_t *)((char*)device + dstRB);
            mask += mask_adjust;
 
        } while (--height != 0);
    }

DECLARE_BINARY_FLOAT()

SK_OPTS_NS::DECLARE_BINARY_FLOAT

(

add

)

DECLARE_UNARY_INT()

SK_OPTS_NS::DECLARE_UNARY_INT

(

cast_to_float_from

)

decode_packed_coordinates_and_weight()

template<typename U32 , typename Out >

static void SK_OPTS_NS::decode_packed_coordinates_and_weight ( U32  packed, Out *  v0, Out *  v1, Out *  w  )

static

Definition at line 38 of file SkBitmapProcState_opts.h.

                                                                                       {
    *v0 = (packed >> 18);       // Integer coordinate x0 or y0.
    *v1 = (packed & 0x3fff);    // Integer coordinate x1 or y1.
    *w  = (packed >> 14) & 0xf; // Lerp weight for v1; weight for v0 is 16-w.
}

div_fn()

template<typename T >

SI void SK_OPTS_NS::div_fn	(	T *	dst,
		T *	src
	)

Definition at line 4584 of file SkRasterPipeline_opts.h.

                               {
    T divisor = *src;
    if constexpr (!std::is_same_v<T, F>) {
        // We will crash if we integer-divide against zero. Convert 0 to ~0 to avoid this.
        divisor |= (T)cond_to_mask(divisor == 0);
    }
    *dst /= divisor;
}

exclusive_mirror()

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

Definition at line 3238 of file SkRasterPipeline_opts.h.

                                                                {
    auto limit = ctx->scale;
    auto invLimit = ctx->invScale;
 
    // This is "repeat" over the range 0..2*limit
    auto u = v - floor_(v*invLimit*0.5f)*2*limit;
    // s will be 0 when moving forward (e.g. [0, limit)) and 1 when moving backward (e.g.
    // [limit, 2*limit)).
    auto s = floor_(u*invLimit);
    // This is the mirror result.
    auto m = u - 2*s*(u - limit);
    // Apply a bias to m if moving backwards so that we snap consistently at exact integer coords in
    // the logical infinite image. This is tested by mirror_tile GM. Note that all values
    // that have a non-zero bias applied are > 0.
    auto biasInUlps = trunc_(s);
    return sk_bit_cast<F>(sk_bit_cast<U32>(m) + ctx->mirrorBiasDir*biasInUlps);
}

exclusive_repeat()

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

Definition at line 3235 of file SkRasterPipeline_opts.h.

                                                                {
    return v - floor_(v*ctx->invScale)*ctx->scale;
}

expand() [1/2]

SI U32 SK_OPTS_NS::expand

(

U16

v

)

Definition at line 1340 of file SkRasterPipeline_opts.h.

{ return (U32)v; }

expand() [2/2]

SI U32 SK_OPTS_NS::expand

(

U8

v

)

Definition at line 1341 of file SkRasterPipeline_opts.h.

{ return (U32)v; }

F_()

SI constexpr F SK_OPTS_NS::F_ ( float  x )

constexpr

Definition at line 1299 of file SkRasterPipeline_opts.h.

{ return x; }

floor_()

SI F SK_OPTS_NS::floor_

(

F

v

)

Definition at line 152 of file SkRasterPipeline_opts.h.

{ return floorf(v); }

floor_fn()

SI void SK_OPTS_NS::floor_fn

(

F *

dst

)

Definition at line 4402 of file SkRasterPipeline_opts.h.

                         {
    *dst = floor_(*dst);
}

fract()

SI F SK_OPTS_NS::fract

(

F

v

)

Definition at line 1356 of file SkRasterPipeline_opts.h.

{ return v - floor_(v); }

from_10101010_xr()

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

Definition at line 1795 of file SkRasterPipeline_opts.h.

                                                            {
    *r = (cast64((_10x6 >>  6) & 0x3ff) - 384.f) / 510.f;
    *g = (cast64((_10x6 >> 22) & 0x3ff) - 384.f) / 510.f;
    *b = (cast64((_10x6 >> 38) & 0x3ff) - 384.f) / 510.f;
    *a = (cast64((_10x6 >> 54) & 0x3ff) - 384.f) / 510.f;
}

from_1010102()

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

Definition at line 1780 of file SkRasterPipeline_opts.h.

                                                       {
    *r = cast((rgba      ) & 0x3ff) * (1/1023.0f);
    *g = cast((rgba >> 10) & 0x3ff) * (1/1023.0f);
    *b = cast((rgba >> 20) & 0x3ff) * (1/1023.0f);
    *a = cast((rgba >> 30)        ) * (1/   3.0f);
}

from_1010102_xr()

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

Definition at line 1786 of file SkRasterPipeline_opts.h.

                                                          {
    static constexpr float min = -0.752941f;
    static constexpr float max = 1.25098f;
    static constexpr float range = max - min;
    *r = cast((rgba      ) & 0x3ff) * (1/1023.0f) * range + min;
    *g = cast((rgba >> 10) & 0x3ff) * (1/1023.0f) * range + min;
    *b = cast((rgba >> 20) & 0x3ff) * (1/1023.0f) * range + min;
    *a = cast((rgba >> 30)        ) * (1/   3.0f);
}

from_10x6()

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

Definition at line 1801 of file SkRasterPipeline_opts.h.

                                                     {
    *r = cast64((_10x6 >>  6) & 0x3ff) * (1/1023.0f);
    *g = cast64((_10x6 >> 22) & 0x3ff) * (1/1023.0f);
    *b = cast64((_10x6 >> 38) & 0x3ff) * (1/1023.0f);
    *a = cast64((_10x6 >> 54) & 0x3ff) * (1/1023.0f);
}

from_1616()

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

Definition at line 1807 of file SkRasterPipeline_opts.h.

                                         {
    *r = cast((_1616      ) & 0xffff) * (1/65535.0f);
    *g = cast((_1616 >> 16) & 0xffff) * (1/65535.0f);
}

from_16161616()

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

Definition at line 1811 of file SkRasterPipeline_opts.h.

                                                             {
    *r = cast64((_16161616      ) & 0xffff) * (1/65535.0f);
    *g = cast64((_16161616 >> 16) & 0xffff) * (1/65535.0f);
    *b = cast64((_16161616 >> 32) & 0xffff) * (1/65535.0f);
    *a = cast64((_16161616 >> 48) & 0xffff) * (1/65535.0f);
}

from_4444()

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

Definition at line 1762 of file SkRasterPipeline_opts.h.

                                                     {
    U32 wide = expand(_4444);
    *r = cast(wide & (15<<12)) * (1.0f / (15<<12));
    *g = cast(wide & (15<< 8)) * (1.0f / (15<< 8));
    *b = cast(wide & (15<< 4)) * (1.0f / (15<< 4));
    *a = cast(wide & (15<< 0)) * (1.0f / (15<< 0));
}

from_565()

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

Definition at line 1756 of file SkRasterPipeline_opts.h.

                                             {
    U32 wide = expand(_565);
    *r = cast(wide & (31<<11)) * (1.0f / (31<<11));
    *g = cast(wide & (63<< 5)) * (1.0f / (63<< 5));
    *b = cast(wide & (31<< 0)) * (1.0f / (31<< 0));
}

from_88()

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

Definition at line 1775 of file SkRasterPipeline_opts.h.

                                     {
    U32 wide = expand(_88);
    *r = cast((wide      ) & 0xff) * (1/255.0f);
    *g = cast((wide >>  8) & 0xff) * (1/255.0f);
}

from_8888()

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

Definition at line 1769 of file SkRasterPipeline_opts.h.

                                                     {
    *r = cast((_8888      ) & 0xff) * (1/255.0f);
    *g = cast((_8888 >>  8) & 0xff) * (1/255.0f);
    *b = cast((_8888 >> 16) & 0xff) * (1/255.0f);
    *a = cast((_8888 >> 24)       ) * (1/255.0f);
}

from_byte()

SI F SK_OPTS_NS::from_byte

(

U8

b

)

Definition at line 1750 of file SkRasterPipeline_opts.h.

                     {
    return cast(expand(b)) * (1/255.0f);
}

from_half()

SI F SK_OPTS_NS::from_half

(

U16

h

)

Definition at line 1399 of file SkRasterPipeline_opts.h.

                      {
#if defined(JUMPER_IS_NEON) && defined(SK_CPU_ARM64)
    return vcvt_f32_f16((float16x4_t)h);
 
#elif defined(JUMPER_IS_SKX)
    return _mm512_cvtph_ps((__m256i)h);
 
#elif defined(JUMPER_IS_HSW)
    return _mm256_cvtph_ps((__m128i)h);
 
#else
    // Remember, a half is 1-5-10 (sign-exponent-mantissa) with 15 exponent bias.
    U32 sem = expand(h),
        s   = sem & 0x8000,
         em = sem ^ s;
 
    // Convert to 1-8-23 float with 127 bias, flushing denorm halfs (including zero) to zero.
    auto denorm = (I32)em < 0x0400;      // I32 comparison is often quicker, and always safe here.
    return if_then_else(denorm, F0
                              , sk_bit_cast<F>( (s<<16) + (em<<13) + ((127-15)<<23) ));
#endif
}

from_short()

SI F SK_OPTS_NS::from_short

(

U16

s

)

Definition at line 1753 of file SkRasterPipeline_opts.h.

                       {
    return cast(expand(s)) * (1/65535.0f);
}

gather()

template<typename T >

SI T SK_OPTS_NS::gather	(	const T *	p,
		U32	ix
	)

Definition at line 172 of file SkRasterPipeline_opts.h.

{ return p[ix]; }

gradient_lookup()

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

Definition at line 3390 of file SkRasterPipeline_opts.h.

                                                {
    F fr, br, fg, bg, fb, bb, fa, ba;
#if defined(JUMPER_IS_HSW)
    if (c->stopCount <=8) {
        fr = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->fs[0]), (__m256i)idx);
        br = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->bs[0]), (__m256i)idx);
        fg = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->fs[1]), (__m256i)idx);
        bg = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->bs[1]), (__m256i)idx);
        fb = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->fs[2]), (__m256i)idx);
        bb = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->bs[2]), (__m256i)idx);
        fa = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->fs[3]), (__m256i)idx);
        ba = _mm256_permutevar8x32_ps(_mm256_loadu_ps(c->bs[3]), (__m256i)idx);
    } else
#elif defined(JUMPER_IS_LASX)
    if (c->stopCount <= 8) {
        fr = (__m256)__lasx_xvperm_w(__lasx_xvld(c->fs[0], 0), idx);
        br = (__m256)__lasx_xvperm_w(__lasx_xvld(c->bs[0], 0), idx);
        fg = (__m256)__lasx_xvperm_w(__lasx_xvld(c->fs[1], 0), idx);
        bg = (__m256)__lasx_xvperm_w(__lasx_xvld(c->bs[1], 0), idx);
        fb = (__m256)__lasx_xvperm_w(__lasx_xvld(c->fs[2], 0), idx);
        bb = (__m256)__lasx_xvperm_w(__lasx_xvld(c->bs[2], 0), idx);
        fa = (__m256)__lasx_xvperm_w(__lasx_xvld(c->fs[3], 0), idx);
        ba = (__m256)__lasx_xvperm_w(__lasx_xvld(c->bs[3], 0), idx);
    } else
#elif defined(JUMPER_IS_LSX)
    if (c->stopCount <= 4) {
        __m128i zero = __lsx_vldi(0);
        fr = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->fs[0], 0));
        br = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->bs[0], 0));
        fg = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->fs[1], 0));
        bg = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->bs[1], 0));
        fb = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->fs[2], 0));
        bb = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->bs[2], 0));
        fa = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->fs[3], 0));
        ba = (__m128)__lsx_vshuf_w(idx, zero, __lsx_vld(c->bs[3], 0));
    } else
#endif
    {
        fr = gather(c->fs[0], idx);
        br = gather(c->bs[0], idx);
        fg = gather(c->fs[1], idx);
        bg = gather(c->bs[1], idx);
        fb = gather(c->fs[2], idx);
        bb = gather(c->bs[2], idx);
        fa = gather(c->fs[3], idx);
        ba = gather(c->bs[3], idx);
    }
 
    *r = mad(t, fr, br);
    *g = mad(t, fg, bg);
    *b = mad(t, fb, bb);
    *a = mad(t, fa, ba);
}

I32_()

SI constexpr I32 SK_OPTS_NS::I32_ ( int32_t  x )

constexpr

Definition at line 1300 of file SkRasterPipeline_opts.h.

{ return x; }

if_then_else() [1/2]

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

Definition at line 165 of file SkRasterPipeline_opts.h.

{ return c ? t : e; }

if_then_else() [2/2]

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

Definition at line 166 of file SkRasterPipeline_opts.h.

{ return c ? t : e; }

inv()

SI F SK_OPTS_NS::inv

(

F

x

)

Definition at line 2171 of file SkRasterPipeline_opts.h.

{ return 1.0f - x; }

invsqrt_fn()

SI void SK_OPTS_NS::invsqrt_fn

(

F *

dst

)

Definition at line 4410 of file SkRasterPipeline_opts.h.

                           {
    *dst = rsqrt(*dst);
}

iround()

SI I32 SK_OPTS_NS::iround

(

F

v

)

Definition at line 159 of file SkRasterPipeline_opts.h.

{ return (I32)(v + 0.5f); }

ix_and_ptr()

template<typename T >

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

Definition at line 1987 of file SkRasterPipeline_opts.h.

                                                                            {
    // We use exclusive clamp so that our min value is > 0 because ULP subtraction using U32 would
    // produce a NaN if applied to +0.f.
    x = clamp_ex(x, ctx->width );
    y = clamp_ex(y, ctx->height);
    x = sk_bit_cast<F>(sk_bit_cast<U32>(x) - (uint32_t)ctx->roundDownAtInteger);
    y = sk_bit_cast<F>(sk_bit_cast<U32>(y) - (uint32_t)ctx->roundDownAtInteger);
    *ptr = (const T*)ctx->pixels;
    return trunc_(y)*ctx->stride + trunc_(x);
}

just_return()

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

static

Definition at line 1626 of file SkRasterPipeline_opts.h.

{}

lerp()

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

Definition at line 2651 of file SkRasterPipeline_opts.h.

                             {
    return mad(to-from, t, from);
}

load()

template<typename V , typename T >

SI V SK_OPTS_NS::load

(

const T *

src

)

Definition at line 1741 of file SkRasterPipeline_opts.h.

                        {
    return sk_unaligned_load<V>(src);
}

load2()

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

Definition at line 178 of file SkRasterPipeline_opts.h.

                                                       {
        *r = ptr[0];
        *g = ptr[1];
    }

load4() [1/2]

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

Definition at line 199 of file SkRasterPipeline_opts.h.

                                                            {
        *r = ptr[0];
        *g = ptr[1];
        *b = ptr[2];
        *a = ptr[3];
    }

load4() [2/2]

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

Definition at line 186 of file SkRasterPipeline_opts.h.

                                                                       {
        *r = ptr[0];
        *g = ptr[1];
        *b = ptr[2];
        *a = ptr[3];
    }

lum()

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

Definition at line 2252 of file SkRasterPipeline_opts.h.

{ return mad(r, 0.30f, mad(g, 0.59f, b*0.11f)); }

mad()

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

Definition at line 148 of file SkRasterPipeline_opts.h.

{ return a+f*m; }

matrix_multiply()

template<int N>

SI void SK_OPTS_NS::matrix_multiply	(	SkRasterPipeline_MatrixMultiplyCtx *	packed,
		std::byte *	base
	)

Definition at line 4785 of file SkRasterPipeline_opts.h.

                                                                                   {
    auto ctx = SkRPCtxUtils::Unpack(packed);
 
    int outColumns   = ctx.rightColumns,
        outRows      = ctx.leftRows;
 
    SkASSERT(outColumns >= 1);
    SkASSERT(outRows    >= 1);
    SkASSERT(outColumns <= 4);
    SkASSERT(outRows    <= 4);
 
    SkASSERT(ctx.leftColumns == ctx.rightRows);
    SkASSERT(N == ctx.leftColumns);  // N should match the result width
 
#if !defined(JUMPER_IS_SCALAR)
    // This prevents Clang from generating early-out checks for zero-sized matrices.
    SK_ASSUME(outColumns >= 1);
    SK_ASSUME(outRows    >= 1);
    SK_ASSUME(outColumns <= 4);
    SK_ASSUME(outRows    <= 4);
#endif
 
    // Get pointers to the adjacent left- and right-matrices.
    F* resultMtx  = (F*)(base + ctx.dst);
    F* leftMtx    = &resultMtx[ctx.rightColumns * ctx.leftRows];
    F* rightMtx   = &leftMtx[N * ctx.leftRows];
 
    // Emit each matrix element.
    for (int c = 0; c < outColumns; ++c) {
        for (int r = 0; r < outRows; ++r) {
            // Dot a vector from leftMtx[*][r] with rightMtx[c][*].
            F* leftRow     = &leftMtx [r];
            F* rightColumn = &rightMtx[c * N];
 
            F element = *leftRow * *rightColumn;
            for (int idx = 1; idx < N; ++idx) {
                leftRow     += outRows;
                rightColumn += 1;
                element = mad(*leftRow, *rightColumn, element);
            }
 
            *resultMtx++ = element;
        }
    }
}

max() [1/3]

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

Definition at line 144 of file SkRasterPipeline_opts.h.

{ return fmaxf(a,b); }

max() [2/3]

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

Definition at line 145 of file SkRasterPipeline_opts.h.

{ return a > b ? a : b; }

max() [3/3]

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

Definition at line 146 of file SkRasterPipeline_opts.h.

{ return a > b ? a : b; }

max_fn()

template<typename T >

SI void SK_OPTS_NS::max_fn	(	T *	dst,
		T *	src
	)

Definition at line 4606 of file SkRasterPipeline_opts.h.

                               {
    *dst = max(*dst, *src);
}

memset16()

void SK_OPTS_NS::memset16 ( uint16_t  buffer[], uint16_t  value, int  count  )

inline

Definition at line 38 of file SkMemset_opts.h.

                                                                         {
        memsetT(buffer, value, count);
    }

memset32()

void SK_OPTS_NS::memset32 ( uint32_t  buffer[], uint32_t  value, int  count  )

inline

Definition at line 41 of file SkMemset_opts.h.

                                                                         {
        memsetT(buffer, value, count);
    }

memset64()

void SK_OPTS_NS::memset64 ( uint64_t  buffer[], uint64_t  value, int  count  )

inline

Definition at line 44 of file SkMemset_opts.h.

                                                                         {
        memsetT(buffer, value, count);
    }

memsetT()

template<typename T >

static void SK_OPTS_NS::memsetT ( T  buffer[], T  value, int  count  )

static

Definition at line 17 of file SkMemset_opts.h.

                                                        {
    #if defined(SK_CPU_SSE_LEVEL) && SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_AVX
        static constexpr int VecSize = 32 / sizeof(T);
    #else
        static constexpr int VecSize = 16 / sizeof(T);
    #endif
        static_assert(VecSize > 0, "T is too big for memsetT");
        // Create an vectorized version of value
        skvx::Vec<VecSize,T> wideValue(value);
        while (count >= VecSize) {
            // Copy the value into the destination buffer (VecSize elements at a time)
            wideValue.store(buffer);
            buffer += VecSize;
            count  -= VecSize;
        }
        // If count was not an even multiple of VecSize, take care of the last few.
        while (count-- > 0) {
            *buffer++ = value;
        }
    }

min() [1/3]

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

Definition at line 141 of file SkRasterPipeline_opts.h.

{ return fminf(a,b); }

min() [2/3]

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

Definition at line 142 of file SkRasterPipeline_opts.h.

{ return a < b ? a : b; }

min() [3/3]

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

Definition at line 143 of file SkRasterPipeline_opts.h.

{ return a < b ? a : b; }

min_fn()

template<typename T >

SI void SK_OPTS_NS::min_fn	(	T *	dst,
		T *	src
	)

Definition at line 4611 of file SkRasterPipeline_opts.h.

                               {
    *dst = min(*dst, *src);
}

mix_fn() [1/2]

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

Definition at line 4891 of file SkRasterPipeline_opts.h.

                                 {
    // We reorder the arguments here to match lerp's GLSL-style order (interpolation point last).
    *a = lerp(*x, *y, *a);
}

mix_fn() [2/2]

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

Definition at line 4896 of file SkRasterPipeline_opts.h.

                                       {
    // We reorder the arguments here to match if_then_else's expected order (y before x).
    *a = if_then_else(*a, *y, *x);
}

mod_()

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

Definition at line 2564 of file SkRasterPipeline_opts.h.

                        {
    return nmad(y, floor_(x * (1 / y)), x);
}

mod_fn()

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

Definition at line 4651 of file SkRasterPipeline_opts.h.

                               {
    *dst = nmad(*src, floor_(*dst / *src), *dst);
}

mul_fn()

template<typename T >

SI void SK_OPTS_NS::mul_fn	(	T *	dst,
		T *	src
	)

Definition at line 4579 of file SkRasterPipeline_opts.h.

                               {
    *dst *= *src;
}

nmad()

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

Definition at line 149 of file SkRasterPipeline_opts.h.

{ return a-f*m; }

pack() [1/2]

SI U8 SK_OPTS_NS::pack

(

U16

v

)

Definition at line 163 of file SkRasterPipeline_opts.h.

{ return  (U8)v; }

pack() [2/2]

SI U16 SK_OPTS_NS::pack

(

U32

v

)

Definition at line 162 of file SkRasterPipeline_opts.h.

{ return (U16)v; }

patch_memory_contexts()

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

static

Definition at line 1445 of file SkRasterPipeline_opts.h.

                                                                     {
    for (SkRasterPipeline_MemoryCtxPatch& patch : memoryCtxPatches) {
        SkRasterPipeline_MemoryCtx* ctx = patch.info.context;
 
        const ptrdiff_t offset = patch.info.bytesPerPixel * (dy * ctx->stride + dx);
        if (patch.info.load) {
            void* ctxData = SkTAddOffset<void>(ctx->pixels, offset);
            memcpy(patch.scratch, ctxData, patch.info.bytesPerPixel * tail);
        }
 
        SkASSERT(patch.backup == nullptr);
        void* scratchFakeBase = SkTAddOffset<void>(patch.scratch, -offset);
        patch.backup = ctx->pixels;
        ctx->pixels = scratchFakeBase;
    }
}

pow_fn()

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

Definition at line 4647 of file SkRasterPipeline_opts.h.

                               {
    *dst = approx_powf(*dst, *src);
}

ptr_at_xy()

template<typename T >

SI T * SK_OPTS_NS::ptr_at_xy	(	const SkRasterPipeline_MemoryCtx *	ctx,
		size_t	dx,
		size_t	dy
	)

Definition at line 1820 of file SkRasterPipeline_opts.h.

                                                                             {
    return (T*)ctx->pixels + dy*ctx->stride + dx;
}

raster_pipeline_highp_stride()

constexpr size_t SK_OPTS_NS::raster_pipeline_highp_stride ( )

constexpr

Definition at line 6608 of file SkRasterPipeline_opts.h.

{ return N; }

raster_pipeline_lowp_stride()

constexpr size_t SK_OPTS_NS::raster_pipeline_lowp_stride ( )

constexpr

Allow outside code to access the Raster Pipeline pixel stride.

Definition at line 6607 of file SkRasterPipeline_opts.h.

{ return lowp::lowp_N; }

rcp_approx()

SI F SK_OPTS_NS::rcp_approx

(

F

v

)

Definition at line 154 of file SkRasterPipeline_opts.h.

{ return 1.0f / v; }  // use rcp_fast instead

rcp_fast()

SI F SK_OPTS_NS::rcp_fast

(

F

v

)

Definition at line 1483 of file SkRasterPipeline_opts.h.

{ return rcp_precise(v); }

rcp_precise()

SI F SK_OPTS_NS::rcp_precise

(

F

v

)

Definition at line 157 of file SkRasterPipeline_opts.h.

{ return 1.0f / v; }

rect_memset16()

void SK_OPTS_NS::rect_memset16 ( uint16_t  buffer[], uint16_t  value, int  count, size_t  rowBytes, int  height  )

inline

Definition at line 56 of file SkMemset_opts.h.

                                                                          {
        rect_memsetT(buffer, value, count, rowBytes, height);
    }

rect_memset32()

void SK_OPTS_NS::rect_memset32 ( uint32_t  buffer[], uint32_t  value, int  count, size_t  rowBytes, int  height  )

inline

Definition at line 60 of file SkMemset_opts.h.

                                                                          {
        rect_memsetT(buffer, value, count, rowBytes, height);
    }

rect_memset64()

void SK_OPTS_NS::rect_memset64 ( uint64_t  buffer[], uint64_t  value, int  count, size_t  rowBytes, int  height  )

inline

Definition at line 64 of file SkMemset_opts.h.

                                                                          {
        rect_memsetT(buffer, value, count, rowBytes, height);
    }

rect_memsetT()

template<typename T >

static void SK_OPTS_NS::rect_memsetT ( T  buffer[], T  value, int  count, size_t  rowBytes, int  height  )

static

Definition at line 49 of file SkMemset_opts.h.

                                                                                          {
        while (height --> 0) {
            memsetT(buffer, value, count);
            buffer = (T*)((char*)buffer + rowBytes);
        }
    }

restore_memory_contexts()

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

static

Definition at line 1463 of file SkRasterPipeline_opts.h.

                                                                       {
    for (SkRasterPipeline_MemoryCtxPatch& patch : memoryCtxPatches) {
        SkRasterPipeline_MemoryCtx* ctx = patch.info.context;
 
        SkASSERT(patch.backup != nullptr);
        ctx->pixels = patch.backup;
        patch.backup = nullptr;
 
        const ptrdiff_t offset = patch.info.bytesPerPixel * (dy * ctx->stride + dx);
        if (patch.info.store) {
            void* ctxData = SkTAddOffset<void>(ctx->pixels, offset);
            memcpy(ctxData, patch.scratch, patch.info.bytesPerPixel * tail);
        }
    }
}

round() [1/2]

SI U32 SK_OPTS_NS::round

(

F

v

)

Definition at line 160 of file SkRasterPipeline_opts.h.

{ return (U32)(v + 0.5f); }

round() [2/2]

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

Definition at line 161 of file SkRasterPipeline_opts.h.

{ return (U32)(v*scale + 0.5f); }

rsqrt()

SI F SK_OPTS_NS::rsqrt

(

F

v

)

Definition at line 1484 of file SkRasterPipeline_opts.h.

{ return rcp_precise(sqrt_(v)); }

rsqrt_approx()

SI F SK_OPTS_NS::rsqrt_approx

(

F

v

)

Definition at line 155 of file SkRasterPipeline_opts.h.

{ return 1.0f / sqrtf(v); }

S32_alpha_D32_filter_DX()

void SK_OPTS_NS::S32_alpha_D32_filter_DX ( const SkBitmapProcState &  s, const uint32_t *  xy, int  count, uint32_t *  colors  )

inline

Definition at line 47 of file SkBitmapProcState_opts.h.

                                                                                  {
        SkASSERT(count > 0 && colors != nullptr);
        SkASSERT(s.fBilerp);
        SkASSERT(kN32_SkColorType == s.fPixmap.colorType());
        SkASSERT(s.fAlphaScale <= 256);
 
        // interpolate_in_x() is the crux of the SSSE3 implementation,
        // interpolating in X for up to two output pixels (A and B) using _mm_maddubs_epi16().
        auto interpolate_in_x = [](uint32_t A0, uint32_t A1,
                                   uint32_t B0, uint32_t B1,
                                   __m128i interlaced_x_weights) {
            // _mm_maddubs_epi16() is a little idiosyncratic, but great as the core of a lerp.
            //
            // It takes two arguments interlaced byte-wise:
            //    - first  arg: [ l,r, ... 7 more pairs of unsigned 8-bit values ...]
            //    - second arg: [ w,W, ... 7 more pairs of   signed 8-bit values ...]
            // and returns 8 signed 16-bit values: [ l*w + r*W, ... 7 more ... ].
            //
            // That's why we go to all this trouble to make interlaced_x_weights,
            // and here we're about to interlace A0 with A1 and B0 with B1 to match.
            //
            // Our interlaced_x_weights are all in [0,16], and so we need not worry about
            // the signedness of that input nor about the signedness of the output.
 
            __m128i interlaced_A = _mm_unpacklo_epi8(_mm_cvtsi32_si128(A0), _mm_cvtsi32_si128(A1)),
                    interlaced_B = _mm_unpacklo_epi8(_mm_cvtsi32_si128(B0), _mm_cvtsi32_si128(B1));
 
            return _mm_maddubs_epi16(_mm_unpacklo_epi64(interlaced_A, interlaced_B),
                                     interlaced_x_weights);
        };
 
        // Interpolate {A0..A3} --> output pixel A, and {B0..B3} --> output pixel B.
        // Returns two pixels, with each color channel in a 16-bit lane of the __m128i.
        auto interpolate_in_x_and_y = [&](uint32_t A0, uint32_t A1,
                                          uint32_t A2, uint32_t A3,
                                          uint32_t B0, uint32_t B1,
                                          uint32_t B2, uint32_t B3,
                                          __m128i interlaced_x_weights,
                                          int wy) {
            // Interpolate each row in X, leaving 16-bit lanes scaled by interlaced_x_weights.
            __m128i top = interpolate_in_x(A0,A1, B0,B1, interlaced_x_weights),
                    bot = interpolate_in_x(A2,A3, B2,B3, interlaced_x_weights);
 
            // Interpolate in Y.  As in the SSE2 code, we calculate top*(16-wy) + bot*wy
            // as 16*top + (bot-top)*wy to save a multiply.
            __m128i px = _mm_add_epi16(_mm_slli_epi16(top, 4),
                                       _mm_mullo_epi16(_mm_sub_epi16(bot, top),
                                                       _mm_set1_epi16(wy)));
 
            // Scale down by total max weight 16x16 = 256.
            px = _mm_srli_epi16(px, 8);
 
            // Scale by alpha if needed.
            if (s.fAlphaScale < 256) {
                px = _mm_srli_epi16(_mm_mullo_epi16(px, _mm_set1_epi16(s.fAlphaScale)), 8);
            }
            return px;
        };
 
        // We're in _DX mode here, so we're only varying in X.
        // That means the first entry of xy is our constant pair of Y coordinates and weight in Y.
        // All the other entries in xy will be pairs of X coordinates and the X weight.
        int y0, y1, wy;
        decode_packed_coordinates_and_weight(*xy++, &y0, &y1, &wy);
 
        auto row0 = (const uint32_t*)((const uint8_t*)s.fPixmap.addr() + y0 * s.fPixmap.rowBytes()),
             row1 = (const uint32_t*)((const uint8_t*)s.fPixmap.addr() + y1 * s.fPixmap.rowBytes());
 
        while (count >= 4) {
            // We can really get going, loading 4 X-pairs at a time to produce 4 output pixels.
            int x0[4],
                x1[4];
            __m128i wx;
 
            // decode_packed_coordinates_and_weight(), 4x.
            __m128i packed = _mm_loadu_si128((const __m128i*)xy);
            _mm_storeu_si128((__m128i*)x0, _mm_srli_epi32(packed, 18));
            _mm_storeu_si128((__m128i*)x1, _mm_and_si128 (packed, _mm_set1_epi32(0x3fff)));
            wx = _mm_and_si128(_mm_srli_epi32(packed, 14), _mm_set1_epi32(0xf));  // [0,15]
 
            // Splat each x weight 4x (for each color channel) as wr for pixels on the right at x1,
            // and sixteen minus that as wl for pixels on the left at x0.
            __m128i wr = _mm_shuffle_epi8(wx, _mm_setr_epi8(0,0,0,0,4,4,4,4,8,8,8,8,12,12,12,12)),
                    wl = _mm_sub_epi8(_mm_set1_epi8(16), wr);
 
            // We need to interlace wl and wr for _mm_maddubs_epi16().
            __m128i interlaced_x_weights_AB = _mm_unpacklo_epi8(wl,wr),
                    interlaced_x_weights_CD = _mm_unpackhi_epi8(wl,wr);
 
            enum { A,B,C,D };
 
            // interpolate_in_x_and_y() can produce two output pixels (A and B) at a time
            // from eight input pixels {A0..A3} and {B0..B3}, arranged in a 2x2 grid for each.
            __m128i AB = interpolate_in_x_and_y(row0[x0[A]], row0[x1[A]],
                                                row1[x0[A]], row1[x1[A]],
                                                row0[x0[B]], row0[x1[B]],
                                                row1[x0[B]], row1[x1[B]],
                                                interlaced_x_weights_AB, wy);
 
            // Once more with the other half of the x-weights for two more pixels C,D.
            __m128i CD = interpolate_in_x_and_y(row0[x0[C]], row0[x1[C]],
                                                row1[x0[C]], row1[x1[C]],
                                                row0[x0[D]], row0[x1[D]],
                                                row1[x0[D]], row1[x1[D]],
                                                interlaced_x_weights_CD, wy);
 
            // Scale by alpha, pack back together to 8-bit lanes, and write out four pixels!
            _mm_storeu_si128((__m128i*)colors, _mm_packus_epi16(AB, CD));
            xy     += 4;
            colors += 4;
            count  -= 4;
        }
 
        while (count --> 0) {
            // This is exactly the same flow as the count >= 4 loop above, but writing one pixel.
            int x0, x1, wx;
            decode_packed_coordinates_and_weight(*xy++, &x0, &x1, &wx);
 
            // As above, splat out wx four times as wr, and sixteen minus that as wl.
            __m128i wr = _mm_set1_epi8(wx),     // This splats it out 16 times, but that's fine.
                    wl = _mm_sub_epi8(_mm_set1_epi8(16), wr);
 
            __m128i interlaced_x_weights = _mm_unpacklo_epi8(wl, wr);
 
            __m128i A = interpolate_in_x_and_y(row0[x0], row0[x1],
                                               row1[x0], row1[x1],
                                                      0,        0,
                                                      0,        0,
                                               interlaced_x_weights, wy);
 
            *colors++ = _mm_cvtsi128_si32(_mm_packus_epi16(A, _mm_setzero_si128()));
        }
    }

sat()

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

Definition at line 2251 of file SkRasterPipeline_opts.h.

{ return max(r, max(g,b)) - min(r, min(g,b)); }

save_xy()

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

Definition at line 3564 of file SkRasterPipeline_opts.h.

                                                            {
    // Whether bilinear or bicubic, all sample points are at the same fractional offset (fx,fy).
    // They're either the 4 corners of a logical 1x1 pixel or the 16 corners of a 3x3 grid
    // surrounding (x,y) at (0.5,0.5) off-center.
    F fx = fract(*r + 0.5f),
      fy = fract(*g + 0.5f);
 
    // Samplers will need to load x and fx, or y and fy.
    sk_unaligned_store(c->x,  *r);
    sk_unaligned_store(c->y,  *g);
    sk_unaligned_store(c->fx, fx);
    sk_unaligned_store(c->fy, fy);
}

scatter_masked()

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

Definition at line 174 of file SkRasterPipeline_opts.h.

                                                                {
        dst[ix] = mask ? src : dst[ix];
    }

select_lane() [1/2]

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

Definition at line 2024 of file SkRasterPipeline_opts.h.

{ return data; }

select_lane() [2/2]

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

Definition at line 2023 of file SkRasterPipeline_opts.h.

{ return data; }

set_lum()

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

Definition at line 2265 of file SkRasterPipeline_opts.h.

                                       {
    F diff = l - lum(*r, *g, *b);
    *r += diff;
    *g += diff;
    *b += diff;
}

set_sat()

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

Definition at line 2254 of file SkRasterPipeline_opts.h.

                                       {
    F mn  = min(*r, min(*g,*b)),
      mx  = max(*r, max(*g,*b)),
      sat = mx - mn;
 
    // Map min channel to 0, max channel to s, and scale the middle proportionally.
    s = if_then_else(sat == 0.0f, 0.0f, s * rcp_fast(sat));
    *r = (*r - mn) * s;
    *g = (*g - mn) * s;
    *b = (*b - mn) * s;
}

shuffle_fn()

template<int LoopCount, typename OffsetType >

SI void SK_OPTS_NS::shuffle_fn	(	std::byte *	ptr,
		OffsetType *	offsets,
		int	numSlots
	)

Definition at line 4194 of file SkRasterPipeline_opts.h.

                                                                    {
    F scratch[16];
    SK_UNROLL for (int count = 0; count < LoopCount; ++count) {
        scratch[count] = *(F*)(ptr + offsets[count]);
    }
    // Surprisingly, this switch generates significantly better code than a memcpy (on x86-64) when
    // the number of slots is unknown at compile time, and generates roughly identical code when the
    // number of slots is hardcoded. Using a switch allows `scratch` to live in ymm0-ymm15 instead
    // of being written out to the stack and then read back in. Also, the intrinsic memcpy assumes
    // that `numSlots` could be arbitrarily large, and so it emits more code than we need.
    F* dst = (F*)ptr;
    switch (numSlots) {
        case 16: dst[15] = scratch[15]; [[fallthrough]];
        case 15: dst[14] = scratch[14]; [[fallthrough]];
        case 14: dst[13] = scratch[13]; [[fallthrough]];
        case 13: dst[12] = scratch[12]; [[fallthrough]];
        case 12: dst[11] = scratch[11]; [[fallthrough]];
        case 11: dst[10] = scratch[10]; [[fallthrough]];
        case 10: dst[ 9] = scratch[ 9]; [[fallthrough]];
        case  9: dst[ 8] = scratch[ 8]; [[fallthrough]];
        case  8: dst[ 7] = scratch[ 7]; [[fallthrough]];
        case  7: dst[ 6] = scratch[ 6]; [[fallthrough]];
        case  6: dst[ 5] = scratch[ 5]; [[fallthrough]];
        case  5: dst[ 4] = scratch[ 4]; [[fallthrough]];
        case  4: dst[ 3] = scratch[ 3]; [[fallthrough]];
        case  3: dst[ 2] = scratch[ 2]; [[fallthrough]];
        case  2: dst[ 1] = scratch[ 1]; [[fallthrough]];
        case  1: dst[ 0] = scratch[ 0];
    }
}

sin5q_()

SI F SK_OPTS_NS::sin5q_

(

F

x

)

Definition at line 1839 of file SkRasterPipeline_opts.h.

                 {
    // A * x + B * x^3 + C * x^5
    // Exact at x = 0, 1/12, 1/6, 1/4, and their negatives,
    // which correspond to x * 2 * pi = 0, pi/6, pi/3, pi/2
    constexpr float A = 6.28230858f;
    constexpr float B = -41.1693687f;
    constexpr float C = 74.4388885f;
    F x2 = x * x;
    return x * mad(mad(x2, C, B), x2, A);
}

sin_()

SI F SK_OPTS_NS::sin_

(

F

x

)

Definition at line 1850 of file SkRasterPipeline_opts.h.

               {
    constexpr float one_over_pi2 = 1 / (2 * SK_FloatPI);
    x = mad(x, -one_over_pi2, 0.25f);
    x = 0.25f - abs_(x - floor_(x + 0.5f));
    return sin5q_(x);
}

SkAlphaMul_lsx()

static __m128i SK_OPTS_NS::SkAlphaMul_lsx ( __m128i  x, __m128i  y  )

static

Definition at line 167 of file SkBlitMask_opts.h.

                                                        {
        __m128i tmp = __lsx_vmul_h(x, y);
        __m128i mask = __lsx_vreplgr2vr_h(0xff00);
        return __lsx_vsrlri_h(__lsx_vand_v(tmp, mask), 8);
    }

small_swizzle_fn()

template<int N>

SI void SK_OPTS_NS::small_swizzle_fn	(	SkRasterPipeline_SwizzleCtx *	packed,
		std::byte *	base
	)

Definition at line 4226 of file SkRasterPipeline_opts.h.

                                                                             {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    shuffle_fn<N>(base + ctx.dst, ctx.offsets, N);
}

smoothstep_fn()

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

Definition at line 4901 of file SkRasterPipeline_opts.h.

                                                {
    F t = clamp_01_((*x - *edge0) / (*edge1 - *edge0));
    *edge0 = t * t * (3.0 - 2.0 * t);
}

sqrt_()

SI F SK_OPTS_NS::sqrt_

(

F

v

)

Definition at line 156 of file SkRasterPipeline_opts.h.

{ return sqrtf(v); }

stack_checkpoint()

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

static

Definition at line 1658 of file SkRasterPipeline_opts.h.

                                                         {
        SkRasterPipeline_RewindCtx* ctx = Ctx{program};
        while (program) {
            auto next = (Stage)(++program)->fn;
 
            ctx->stage = nullptr;
            next(params, program, r, g, b, a);
            program = ctx->stage;
 
            if (program) {
                r            = sk_unaligned_load<F>(ctx->r );
                g            = sk_unaligned_load<F>(ctx->g );
                b            = sk_unaligned_load<F>(ctx->b );
                a            = sk_unaligned_load<F>(ctx->a );
                params->dr   = sk_unaligned_load<F>(ctx->dr);
                params->dg   = sk_unaligned_load<F>(ctx->dg);
                params->db   = sk_unaligned_load<F>(ctx->db);
                params->da   = sk_unaligned_load<F>(ctx->da);
                params->base = ctx->base;
            }
        }
    }

stack_rewind()

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

static

Definition at line 1681 of file SkRasterPipeline_opts.h.

                                                     {
        SkRasterPipeline_RewindCtx* ctx = Ctx{program};
        sk_unaligned_store(ctx->r , r );
        sk_unaligned_store(ctx->g , g );
        sk_unaligned_store(ctx->b , b );
        sk_unaligned_store(ctx->a , a );
        sk_unaligned_store(ctx->dr, params->dr);
        sk_unaligned_store(ctx->dg, params->dg);
        sk_unaligned_store(ctx->db, params->db);
        sk_unaligned_store(ctx->da, params->da);
        ctx->base  = params->base;
        ctx->stage = program;
    }

STAGE() [1/188]

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

Definition at line 3578 of file SkRasterPipeline_opts.h.

                                                        {
    // Bilinear and bicubic filters are both separable, so we produce independent contributions
    // from x and y, multiplying them together here to get each pixel's total scale factor.
    auto scale = sk_unaligned_load<F>(c->scalex)
               * sk_unaligned_load<F>(c->scaley);
    dr = mad(scale, r, dr);
    dg = mad(scale, g, dg);
    db = mad(scale, b, db);
    da = mad(scale, a, da);
}

STAGE() [2/188]

SK_OPTS_NS::STAGE	(	alpha_to_gray	,
		NoCtx
	)

Definition at line 3307 of file SkRasterPipeline_opts.h.

                            {
    r = g = b = a;
    a = F1;
}

STAGE() [3/188]

SK_OPTS_NS::STAGE	(	alpha_to_gray_dst	,
		NoCtx
	)

Definition at line 3311 of file SkRasterPipeline_opts.h.

                                {
    dr = dg = db = da;
    da = F1;
}

STAGE() [4/188]

SK_OPTS_NS::STAGE	(	alpha_to_red	,
		NoCtx
	)

Definition at line 3315 of file SkRasterPipeline_opts.h.

                           {
    r = a;
    a = F1;
}

STAGE() [5/188]

SK_OPTS_NS::STAGE	(	alpha_to_red_dst	,
		NoCtx
	)

Definition at line 3319 of file SkRasterPipeline_opts.h.

                               {
    dr = da;
    da = F1;
}

STAGE() [6/188]

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

Definition at line 3532 of file SkRasterPipeline_opts.h.

                                                                                     {
    F& t = r;
    t = t + ctx->fP1; // ctx->fP1 = f
}

STAGE() [7/188]

SK_OPTS_NS::STAGE	(	alter_2pt_conical_unswap	,
		NoCtx
	)

Definition at line 3537 of file SkRasterPipeline_opts.h.

                                       {
    F& t = r;
    t = 1 - t;
}

STAGE() [8/188]

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

Definition at line 3556 of file SkRasterPipeline_opts.h.

                                              {
    const U32 mask = sk_unaligned_load<U32>(ctx);
    r = sk_bit_cast<F>(sk_bit_cast<U32>(r) & mask);
    g = sk_bit_cast<F>(sk_bit_cast<U32>(g) & mask);
    b = sk_bit_cast<F>(sk_bit_cast<U32>(b) & mask);
    a = sk_bit_cast<F>(sk_bit_cast<U32>(a) & mask);
}

STAGE() [9/188]

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

Definition at line 4994 of file SkRasterPipeline_opts.h.

                                                                 {
    // (cx,cy) are the center of our sample.
    F cx = r,
      cy = g;
 
    // All sample points are at the same fractional offset (fx,fy).
    // They're the 4 corners of a logical 1x1 pixel surrounding (x,y) at (0.5,0.5) offsets.
    F fx = fract(cx + 0.5f),
      fy = fract(cy + 0.5f);
 
    // We'll accumulate the color of all four samples into {r,g,b,a} directly.
    r = g = b = a = F0;
 
    const float* w = ctx->weights;
    const F scaley[4] = {bicubic_wts(fy, w[0], w[4], w[ 8], w[12]),
                         bicubic_wts(fy, w[1], w[5], w[ 9], w[13]),
                         bicubic_wts(fy, w[2], w[6], w[10], w[14]),
                         bicubic_wts(fy, w[3], w[7], w[11], w[15])};
    const F scalex[4] = {bicubic_wts(fx, w[0], w[4], w[ 8], w[12]),
                         bicubic_wts(fx, w[1], w[5], w[ 9], w[13]),
                         bicubic_wts(fx, w[2], w[6], w[10], w[14]),
                         bicubic_wts(fx, w[3], w[7], w[11], w[15])};
 
    F sample_y = cy - 1.5f;
    for (int yy = 0; yy <= 3; ++yy) {
        F sample_x = cx - 1.5f;
        for (int xx = 0; xx <= 3; ++xx) {
            F scale = scalex[xx] * scaley[yy];
 
            // ix_and_ptr() will clamp to the image's bounds for us.
            const uint32_t* ptr;
            U32 ix = ix_and_ptr(&ptr, ctx, sample_x, sample_y);
 
            F sr,sg,sb,sa;
            from_8888(gather(ptr, ix), &sr,&sg,&sb,&sa);
 
            r = mad(scale, sr, r);
            g = mad(scale, sg, g);
            b = mad(scale, sb, b);
            a = mad(scale, sa, a);
 
            sample_x += 1;
        }
        sample_y += 1;
    }
}

STAGE() [10/188]

SK_OPTS_NS::STAGE	(	bicubic_n1x	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3682 of file SkRasterPipeline_opts.h.

{ bicubic_x<-1>(ctx, &r); }

STAGE() [11/188]

SK_OPTS_NS::STAGE	(	bicubic_n1y	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3687 of file SkRasterPipeline_opts.h.

{ bicubic_y<-1>(ctx, &g); }

STAGE() [12/188]

SK_OPTS_NS::STAGE	(	bicubic_n3x	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3681 of file SkRasterPipeline_opts.h.

{ bicubic_x<-3>(ctx, &r); }

STAGE() [13/188]

SK_OPTS_NS::STAGE	(	bicubic_n3y	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3686 of file SkRasterPipeline_opts.h.

{ bicubic_y<-3>(ctx, &g); }

STAGE() [14/188]

SK_OPTS_NS::STAGE	(	bicubic_p1x	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3683 of file SkRasterPipeline_opts.h.

{ bicubic_x<+1>(ctx, &r); }

STAGE() [15/188]

SK_OPTS_NS::STAGE	(	bicubic_p1y	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3688 of file SkRasterPipeline_opts.h.

{ bicubic_y<+1>(ctx, &g); }

STAGE() [16/188]

SK_OPTS_NS::STAGE	(	bicubic_p3x	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3684 of file SkRasterPipeline_opts.h.

{ bicubic_x<+3>(ctx, &r); }

STAGE() [17/188]

SK_OPTS_NS::STAGE	(	bicubic_p3y	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3689 of file SkRasterPipeline_opts.h.

{ bicubic_y<+3>(ctx, &g); }

STAGE() [18/188]

SK_OPTS_NS::STAGE	(	bicubic_setup	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3660 of file SkRasterPipeline_opts.h.

                                                       {
    save_xy(&r, &g, ctx);
 
    const float* w = ctx->weights;
 
    F fx = sk_unaligned_load<F>(ctx->fx);
    sk_unaligned_store(ctx->wx[0], bicubic_wts(fx, w[0], w[4], w[ 8], w[12]));
    sk_unaligned_store(ctx->wx[1], bicubic_wts(fx, w[1], w[5], w[ 9], w[13]));
    sk_unaligned_store(ctx->wx[2], bicubic_wts(fx, w[2], w[6], w[10], w[14]));
    sk_unaligned_store(ctx->wx[3], bicubic_wts(fx, w[3], w[7], w[11], w[15]));
 
    F fy = sk_unaligned_load<F>(ctx->fy);
    sk_unaligned_store(ctx->wy[0], bicubic_wts(fy, w[0], w[4], w[ 8], w[12]));
    sk_unaligned_store(ctx->wy[1], bicubic_wts(fy, w[1], w[5], w[ 9], w[13]));
    sk_unaligned_store(ctx->wy[2], bicubic_wts(fy, w[2], w[6], w[10], w[14]));
    sk_unaligned_store(ctx->wy[3], bicubic_wts(fy, w[3], w[7], w[11], w[15]));
 
    // Init for accumulate
    dr = dg = db = da = F0;
}

STAGE() [19/188]

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

Definition at line 4952 of file SkRasterPipeline_opts.h.

                                                                {
    // (cx,cy) are the center of our sample.
    F cx = r,
      cy = g;
 
    // All sample points are at the same fractional offset (fx,fy).
    // They're the 4 corners of a logical 1x1 pixel surrounding (x,y) at (0.5,0.5) offsets.
    F fx = fract(cx + 0.5f),
      fy = fract(cy + 0.5f);
 
    // We'll accumulate the color of all four samples into {r,g,b,a} directly.
    r = g = b = a = F0;
 
    for (float py = -0.5f; py <= +0.5f; py += 1.0f)
    for (float px = -0.5f; px <= +0.5f; px += 1.0f) {
        // (x,y) are the coordinates of this sample point.
        F x = cx + px,
          y = cy + py;
 
        // ix_and_ptr() will clamp to the image's bounds for us.
        const uint32_t* ptr;
        U32 ix = ix_and_ptr(&ptr, ctx, x,y);
 
        F sr,sg,sb,sa;
        from_8888(gather(ptr, ix), &sr,&sg,&sb,&sa);
 
        // In bilinear interpolation, the 4 pixels at +/- 0.5 offsets from the sample pixel center
        // are combined in direct proportion to their area overlapping that logical query pixel.
        // At positive offsets, the x-axis contribution to that rectangle is fx,
        // or (1-fx) at negative x.  Same deal for y.
        F sx = (px > 0) ? fx : 1.0f - fx,
          sy = (py > 0) ? fy : 1.0f - fy,
          area = sx * sy;
 
        r += sr * area;
        g += sg * area;
        b += sb * area;
        a += sa * area;
    }
}

STAGE() [20/188]

SK_OPTS_NS::STAGE	(	bilinear_nx	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3621 of file SkRasterPipeline_opts.h.

{ bilinear_x<-1>(ctx, &r); }

STAGE() [21/188]

SK_OPTS_NS::STAGE	(	bilinear_ny	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3623 of file SkRasterPipeline_opts.h.

{ bilinear_y<-1>(ctx, &g); }

STAGE() [22/188]

SK_OPTS_NS::STAGE	(	bilinear_px	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3622 of file SkRasterPipeline_opts.h.

{ bilinear_x<+1>(ctx, &r); }

STAGE() [23/188]

SK_OPTS_NS::STAGE	(	bilinear_py	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3624 of file SkRasterPipeline_opts.h.

{ bilinear_y<+1>(ctx, &g); }

STAGE() [24/188]

SK_OPTS_NS::STAGE	(	bilinear_setup	,
		SkRasterPipeline_SamplerCtx *	ctx
	)

Definition at line 3615 of file SkRasterPipeline_opts.h.

                                                        {
    save_xy(&r, &g, ctx);
    // Init for accumulate
    dr = dg = db = da = F0;
}

STAGE() [25/188]

SK_OPTS_NS::STAGE	(	black_color	,
		NoCtx
	)

Definition at line 2105 of file SkRasterPipeline_opts.h.

                          {
    r = g = b = F0;
    a = F1;
}

STAGE() [26/188]

SK_OPTS_NS::STAGE	(	bt709_luminance_or_luma_to_alpha	,
		NoCtx
	)

Definition at line 3324 of file SkRasterPipeline_opts.h.

                                               {
    a = r*0.2126f + g*0.7152f + b*0.0722f;
    r = g = b = F0;
}

STAGE() [27/188]

SK_OPTS_NS::STAGE	(	bt709_luminance_or_luma_to_rgb	,
		NoCtx
	)

Definition at line 3328 of file SkRasterPipeline_opts.h.

                                             {
    r = g = b = r*0.2126f + g*0.7152f + b*0.0722f;
}

STAGE() [28/188]

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

Definition at line 2712 of file SkRasterPipeline_opts.h.

                                                             {
    r = from_byte(gather(tables->r, to_unorm(r, 255)));
    g = from_byte(gather(tables->g, to_unorm(g, 255)));
    b = from_byte(gather(tables->b, to_unorm(b, 255)));
    a = from_byte(gather(tables->a, to_unorm(a, 255)));
}

STAGE() [29/188]

SK_OPTS_NS::STAGE	(	callback	,
		SkRasterPipeline_CallbackCtx *	c
	)

Definition at line 3831 of file SkRasterPipeline_opts.h.

                                                 {
    store4(c->rgba, r,g,b,a);
    c->fn(c, N);
    load4(c->read_from, &r,&g,&b,&a);
}

STAGE() [30/188]

SK_OPTS_NS::STAGE	(	check_decal_mask	,
		SkRasterPipeline_DecalTileCtx *	ctx
	)

Definition at line 3299 of file SkRasterPipeline_opts.h.

                                                            {
    auto mask = sk_unaligned_load<U32>(ctx->mask);
    r = sk_bit_cast<F>(sk_bit_cast<U32>(r) & mask);
    g = sk_bit_cast<F>(sk_bit_cast<U32>(g) & mask);
    b = sk_bit_cast<F>(sk_bit_cast<U32>(b) & mask);
    a = sk_bit_cast<F>(sk_bit_cast<U32>(a) & mask);
}

STAGE() [31/188]

SK_OPTS_NS::STAGE	(	clamp_01	,
		NoCtx
	)

Definition at line 2373 of file SkRasterPipeline_opts.h.

                       {
    r = clamp_01_(r);
    g = clamp_01_(g);
    b = clamp_01_(b);
    a = clamp_01_(a);
}

STAGE() [32/188]

SK_OPTS_NS::STAGE	(	clamp_gamut	,
		NoCtx
	)

Definition at line 2380 of file SkRasterPipeline_opts.h.

                          {
    a = min(max(a, 0.0f), 1.0f);
    r = min(max(r, 0.0f), a);
    g = min(max(g, 0.0f), a);
    b = min(max(b, 0.0f), a);
}

STAGE() [33/188]

SK_OPTS_NS::STAGE	(	clamp_x_1	,
		NoCtx
	)

Definition at line 3263 of file SkRasterPipeline_opts.h.

{ r = clamp_01_(r); }

STAGE() [34/188]

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

Definition at line 3267 of file SkRasterPipeline_opts.h.

                                                                {
    r = min(ctx->max_x, max(ctx->min_x, r));
    g = min(ctx->max_y, max(ctx->min_y, g));
}

STAGE() [35/188]

SK_OPTS_NS::STAGE	(	color	,
		NoCtx
	)

Definition at line 2319 of file SkRasterPipeline_opts.h.

                    {
    F R = r*da,
      G = g*da,
      B = b*da;
 
    set_lum(&R, &G, &B, lum(dr,dg,db)*a);
    clip_color(&R,&G,&B, a*da);
 
    r = mad(r, inv(da), mad(dr, inv(a), R));
    g = mad(g, inv(da), mad(dg, inv(a), G));
    b = mad(b, inv(da), mad(db, inv(a), B));
    a = a + nmad(a, da, da);
}

STAGE() [36/188]

SK_OPTS_NS::STAGE	(	css_hcl_to_lab	,
		NoCtx
	)

Definition at line 2552 of file SkRasterPipeline_opts.h.

                             {
    F H = r,
      C = g,
      L = b;
 
    F hueRadians = H * (SK_FloatPI / 180);
 
    r = L;
    g = C * cos_(hueRadians);
    b = C * sin_(hueRadians);
}

STAGE() [37/188]

SK_OPTS_NS::STAGE	(	css_hsl_to_srgb	,
		NoCtx
	)

Definition at line 2589 of file SkRasterPipeline_opts.h.

                              {
    RGB rgb = css_hsl_to_srgb_(r, g, b);
    r = rgb.r;
    g = rgb.g;
    b = rgb.b;
}

STAGE() [38/188]

SK_OPTS_NS::STAGE	(	css_hwb_to_srgb	,
		NoCtx
	)

Definition at line 2596 of file SkRasterPipeline_opts.h.

                              {
    g *= 0.01f;
    b *= 0.01f;
 
    F gray = g / (g + b);
 
    RGB rgb = css_hsl_to_srgb_(r, F_(100.0f), F_(50.0f));
    rgb.r = rgb.r * (1 - g - b) + g;
    rgb.g = rgb.g * (1 - g - b) + g;
    rgb.b = rgb.b * (1 - g - b) + g;
 
    auto isGray = (g + b) >= 1;
 
    r = if_then_else(isGray, gray, rgb.r);
    g = if_then_else(isGray, gray, rgb.g);
    b = if_then_else(isGray, gray, rgb.b);
}

STAGE() [39/188]

SK_OPTS_NS::STAGE	(	css_lab_to_xyz	,
		NoCtx
	)

Definition at line 2496 of file SkRasterPipeline_opts.h.

                             {
    constexpr float k = 24389 / 27.0f;
    constexpr float e = 216 / 24389.0f;
 
    F f[3];
    f[1] = (r + 16) * (1 / 116.0f);
    f[0] = (g * (1 / 500.0f)) + f[1];
    f[2] = f[1] - (b * (1 / 200.0f));
 
    F f_cubed[3] = { f[0]*f[0]*f[0], f[1]*f[1]*f[1], f[2]*f[2]*f[2] };
 
    F xyz[3] = {
        if_then_else(f_cubed[0] > e, f_cubed[0], (116 * f[0] - 16) * (1 / k)),
        if_then_else(r > k * e,      f_cubed[1], r * (1 / k)),
        if_then_else(f_cubed[2] > e, f_cubed[2], (116 * f[2] - 16) * (1 / k))
    };
 
    constexpr float D50[3] = { 0.3457f / 0.3585f, 1.0f, (1.0f - 0.3457f - 0.3585f) / 0.3585f };
    r = xyz[0]*D50[0];
    g = xyz[1]*D50[1];
    b = xyz[2]*D50[2];
}

STAGE() [40/188]

SK_OPTS_NS::STAGE	(	css_oklab_gamut_map_to_linear_srgb	,
		NoCtx
	)

Definition at line 2533 of file SkRasterPipeline_opts.h.

                                                 {
    // TODO(https://crbug.com/1508329): Add support for gamut mapping.
    // Return a greyscale value, so that accidental use is obvious.
    F l_ = r,
      m_ = r,
      s_ = r;
 
    F l = l_*l_*l_,
      m = m_*m_*m_,
      s = s_*s_*s_;
 
    r = +4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s;
    g = -1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s;
    b = -0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s;
}

STAGE() [41/188]

SK_OPTS_NS::STAGE	(	css_oklab_to_linear_srgb	,
		NoCtx
	)

Definition at line 2519 of file SkRasterPipeline_opts.h.

                                       {
    F l_ = r + 0.3963377774f * g + 0.2158037573f * b,
      m_ = r - 0.1055613458f * g - 0.0638541728f * b,
      s_ = r - 0.0894841775f * g - 1.2914855480f * b;
 
    F l = l_*l_*l_,
      m = m_*m_*m_,
      s = s_*s_*s_;
 
    r = +4.0767416621f * l - 3.3077115913f * m + 0.2309699292f * s;
    g = -1.2684380046f * l + 2.6097574011f * m - 0.3413193965f * s;
    b = -0.0041960863f * l - 0.7034186147f * m + 1.7076147010f * s;
}

STAGE() [42/188]

SK_OPTS_NS::STAGE	(	decal_x	,
		SkRasterPipeline_DecalTileCtx *	ctx
	)

Definition at line 3278 of file SkRasterPipeline_opts.h.

                                                   {
    auto w = ctx->limit_x;
    auto e = ctx->inclusiveEdge_x;
    auto cond = ((0 < r) & (r < w)) | (r == e);
    sk_unaligned_store(ctx->mask, cond_to_mask(cond));
}

STAGE() [43/188]

SK_OPTS_NS::STAGE	(	decal_x_and_y	,
		SkRasterPipeline_DecalTileCtx *	ctx
	)

Definition at line 3290 of file SkRasterPipeline_opts.h.

                                                         {
    auto w = ctx->limit_x;
    auto h = ctx->limit_y;
    auto ex = ctx->inclusiveEdge_x;
    auto ey = ctx->inclusiveEdge_y;
    auto cond = (((0 < r) & (r < w)) | (r == ex))
              & (((0 < g) & (g < h)) | (g == ey));
    sk_unaligned_store(ctx->mask, cond_to_mask(cond));
}

STAGE() [44/188]

SK_OPTS_NS::STAGE	(	decal_y	,
		SkRasterPipeline_DecalTileCtx *	ctx
	)

Definition at line 3284 of file SkRasterPipeline_opts.h.

                                                   {
    auto h = ctx->limit_y;
    auto e = ctx->inclusiveEdge_y;
    auto cond = ((0 < g) & (g < h)) | (g == e);
    sk_unaligned_store(ctx->mask, cond_to_mask(cond));
}

STAGE() [45/188]

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

Definition at line 2049 of file SkRasterPipeline_opts.h.

                                 {
    // Get [(dx,dy), (dx+1,dy), (dx+2,dy), ...] loaded up in integer vectors.
    uint32_t iota[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
 
    U32 X = U32_(dx) + sk_unaligned_load<U32>(iota),
        Y = U32_(dy);
 
    // We're doing 8x8 ordered dithering, see https://en.wikipedia.org/wiki/Ordered_dithering.
    // In this case n=8 and we're using the matrix that looks like 1/64 x [ 0 48 12 60 ... ].
 
    // We only need X and X^Y from here on, so it's easier to just think of that as "Y".
    Y ^= X;
 
    // We'll mix the bottom 3 bits of each of X and Y to make 6 bits,
    // for 2^6 == 64 == 8x8 matrix values.  If X=abc and Y=def, we make fcebda.
    U32 M = (Y & 1) << 5 | (X & 1) << 4
          | (Y & 2) << 2 | (X & 2) << 1
          | (Y & 4) >> 1 | (X & 4) >> 2;
 
    // Scale that dither to [0,1), then (-0.5,+0.5), here using 63/128 = 0.4921875 as 0.5-epsilon.
    // We want to make sure our dither is less than 0.5 in either direction to keep exact values
    // like 0 and 1 unchanged after rounding.
    F dither = mad(cast(M), 2/128.0f, -63/128.0f);
 
    r = mad(dither, *rate, r);
    g = mad(dither, *rate, g);
    b = mad(dither, *rate, b);
 
    r = max(0.0f, min(r, a));
    g = max(0.0f, min(g, a));
    b = max(0.0f, min(b, a));
}

STAGE() [46/188]

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

Definition at line 2700 of file SkRasterPipeline_opts.h.

                                                     {
    auto mptr = ptr_at_xy<const uint8_t>(&ctx->mul, dx,dy),
         aptr = ptr_at_xy<const uint8_t>(&ctx->add, dx,dy);
 
    F mul = from_byte(load<U8>(mptr)),
      add = from_byte(load<U8>(aptr));
 
    r = mad(r, mul, add);
    g = mad(g, mul, add);
    b = mad(b, mul, add);
}

STAGE() [47/188]

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

Definition at line 3463 of file SkRasterPipeline_opts.h.

                                                                                             {
    auto t = r;
    r = mad(t, c->f[0], c->b[0]);
    g = mad(t, c->f[1], c->b[1]);
    b = mad(t, c->f[2], c->b[2]);
    a = mad(t, c->f[3], c->b[3]);
}

STAGE() [48/188]

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

Definition at line 3445 of file SkRasterPipeline_opts.h.

                                                                     {
    auto t = r;
    auto idx = trunc_(t * static_cast<float>(c->stopCount-1));
    gradient_lookup(c, idx, t, &r, &g, &b, &a);
}

STAGE() [49/188]

SK_OPTS_NS::STAGE	(	force_opaque	,
		NoCtx
	)

Definition at line 2453 of file SkRasterPipeline_opts.h.

{  a = F1; }

STAGE() [50/188]

SK_OPTS_NS::STAGE	(	force_opaque_dst	,
		NoCtx
	)

Definition at line 2454 of file SkRasterPipeline_opts.h.

{ da = F1; }

STAGE() [51/188]

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

Definition at line 2743 of file SkRasterPipeline_opts.h.

                              {
    auto fn = [&](F v) {
        U32 sign;
        v = strip_sign(v, &sign);
        return apply_sign(approx_powf(v, *G), sign);
    };
    r = fn(r);
    g = fn(g);
    b = fn(b);
}

STAGE() [52/188]

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

Definition at line 3062 of file SkRasterPipeline_opts.h.

                                                                 {
    const uint64_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    from_10101010_xr(gather(ptr, ix), &r, &g, &b, &a);
}

STAGE() [53/188]

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

Definition at line 3052 of file SkRasterPipeline_opts.h.

                                                             {
    const uint32_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    from_1010102(gather(ptr, ix), &r,&g,&b,&a);
}

STAGE() [54/188]

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

Definition at line 3057 of file SkRasterPipeline_opts.h.

                                                                {
    const uint32_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    from_1010102_xr(gather(ptr, ix), &r,&g,&b,&a);
}

STAGE() [55/188]

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

Definition at line 3019 of file SkRasterPipeline_opts.h.

                                                          {
    const uint64_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    from_10x6(gather(ptr, ix), &r, &g, &b, &a);
}

STAGE() [56/188]

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

Definition at line 2995 of file SkRasterPipeline_opts.h.

                                                              {
    const uint64_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    from_16161616(gather(ptr, ix), &r, &g, &b, &a);
}

STAGE() [57/188]

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

Definition at line 2875 of file SkRasterPipeline_opts.h.

                                                          {
    const uint16_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    from_4444(gather(ptr, ix), &r,&g,&b,&a);
}

STAGE() [58/188]

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

Definition at line 2852 of file SkRasterPipeline_opts.h.

                                                         {
    const uint16_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    from_565(gather(ptr, ix), &r,&g,&b);
    a = F1;
}

STAGE() [59/188]

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

Definition at line 2897 of file SkRasterPipeline_opts.h.

                                                          {
    const uint32_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    from_8888(gather(ptr, ix), &r,&g,&b,&a);
}

STAGE() [60/188]

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

Definition at line 2947 of file SkRasterPipeline_opts.h.

                                                         {
    const uint16_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    r = g = b = F0;
    a = from_short(gather(ptr, ix));
}

STAGE() [61/188]

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

Definition at line 2821 of file SkRasterPipeline_opts.h.

                                                        {
    const uint8_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    r = g = b = F0;
    a = from_byte(gather(ptr, ix));
}

STAGE() [62/188]

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

Definition at line 3165 of file SkRasterPipeline_opts.h.

                                                          {
    const uint16_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    r = g = b = F0;
    a = from_half(gather(ptr, ix));
}

STAGE() [63/188]

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

Definition at line 3129 of file SkRasterPipeline_opts.h.

                                                         {
    const uint64_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    auto px = gather(ptr, ix);
 
    U16 R,G,B,A;
    load4((const uint16_t*)&px, &R,&G,&B,&A);
    r = from_half(R);
    g = from_half(G);
    b = from_half(B);
    a = from_half(A);
}

STAGE() [64/188]

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

Definition at line 3222 of file SkRasterPipeline_opts.h.

                                                         {
    const float* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r,g);
    r = gather(ptr, 4*ix + 0);
    g = gather(ptr, 4*ix + 1);
    b = gather(ptr, 4*ix + 2);
    a = gather(ptr, 4*ix + 3);
}

STAGE() [65/188]

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

Definition at line 2972 of file SkRasterPipeline_opts.h.

                                                            {
    const uint32_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    from_1616(gather(ptr, ix), &r, &g);
    b = F0;
    a = F1;
}

STAGE() [66/188]

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

Definition at line 2924 of file SkRasterPipeline_opts.h.

                                                          {
    const uint16_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    from_88(gather(ptr, ix), &r, &g);
    b = F0;
    a = F1;
}

STAGE() [67/188]

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

Definition at line 3196 of file SkRasterPipeline_opts.h.

                                                           {
    const uint32_t* ptr;
    U32 ix = ix_and_ptr(&ptr, ctx, r, g);
    auto px = gather(ptr, ix);
 
    U16 R,G;
    load2((const uint16_t*)&px, &R, &G);
    r = from_half(R);
    g = from_half(G);
    b = F0;
    a = F1;
}

STAGE() [68/188]

SK_OPTS_NS::STAGE	(	gauss_a_to_rgba	,
		NoCtx
	)

Definition at line 4935 of file SkRasterPipeline_opts.h.

                              {
    // x = 1 - x;
    // exp(-x * x * 4) - 0.018f;
    // ... now approximate with quartic
    //
    const float c4 = -2.26661229133605957031f;
    const float c3 = 2.89795351028442382812f;
    const float c2 = 0.21345567703247070312f;
    const float c1 = 0.15489584207534790039f;
    const float c0 = 0.00030726194381713867f;
    a = mad(a, mad(a, mad(a, mad(a, c4, c3), c2), c1), c0);
    r = a;
    g = a;
    b = a;
}

STAGE() [69/188]

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

Definition at line 3451 of file SkRasterPipeline_opts.h.

                                                       {
    auto t = r;
    U32 idx = U32_(0);
 
    // N.B. The loop starts at 1 because idx 0 is the color to use before the first stop.
    for (size_t i = 1; i < c->stopCount; i++) {
        idx += (U32)if_then_else(t >= c->ts[i], I32_(1), I32_(0));
    }
 
    gradient_lookup(c, idx, t, &r, &g, &b, &a);
}

STAGE() [70/188]

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

Definition at line 2789 of file SkRasterPipeline_opts.h.

                                                    {
    auto fn = [&](F v) {
        U32 sign;
        v = strip_sign(v, &sign);
 
        const float R = ctx->a, G = ctx->b,
                    a = ctx->c, b = ctx->d, c = ctx->e,
                    K = ctx->f + 1.0f;
 
        v /= K;
        F r = if_then_else(v <= 1, R * approx_powf(v, G)
                                 , a * approx_log(v - b) + c);
 
        return apply_sign(r, sign);
    };
    r = fn(r);
    g = fn(g);
    b = fn(b);
}

STAGE() [71/188]

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

Definition at line 2770 of file SkRasterPipeline_opts.h.

                                                 {
    auto fn = [&](F v) {
        U32 sign;
        v = strip_sign(v, &sign);
 
        const float R = ctx->a, G = ctx->b,
                    a = ctx->c, b = ctx->d, c = ctx->e,
                    K = ctx->f + 1.0f;
 
        F r = if_then_else(v*R <= 1, approx_powf(v*R, G)
                                   , approx_exp((v-c)*a) + b);
 
        return K * apply_sign(r, sign);
    };
    r = fn(r);
    g = fn(g);
    b = fn(b);
}

STAGE() [72/188]

SK_OPTS_NS::STAGE	(	hsl_to_rgb	,
		NoCtx
	)

Definition at line 2476 of file SkRasterPipeline_opts.h.

                         {
    // See GrRGBToHSLFilterEffect.fp
 
    F h = r,
      s = g,
      l = b,
      c = (1.0f - abs_(2.0f * l - 1)) * s;
 
    auto hue_to_rgb = [&](F hue) {
        F q = clamp_01_(abs_(fract(hue) * 6.0f - 3.0f) - 1.0f);
        return (q - 0.5f) * c + l;
    };
 
    r = hue_to_rgb(h + 0.0f/3.0f);
    g = hue_to_rgb(h + 2.0f/3.0f);
    b = hue_to_rgb(h + 1.0f/3.0f);
}

STAGE() [73/188]

SK_OPTS_NS::STAGE	(	hue	,
		NoCtx
	)

Definition at line 2291 of file SkRasterPipeline_opts.h.

                  {
    F R = r*a,
      G = g*a,
      B = b*a;
 
    set_sat(&R, &G, &B, sat(dr,dg,db)*a);
    set_lum(&R, &G, &B, lum(dr,dg,db)*a);
    clip_color(&R,&G,&B, a*da);
 
    r = mad(r, inv(da), mad(dr, inv(a), R));
    g = mad(g, inv(da), mad(dg, inv(a), G));
    b = mad(b, inv(da), mad(db, inv(a), B));
    a = a + nmad(a, da, da);
}

STAGE() [74/188]

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

Definition at line 2655 of file SkRasterPipeline_opts.h.

                                    {
    r = lerp(dr, r, F_(*c));
    g = lerp(dg, g, F_(*c));
    b = lerp(db, b, F_(*c));
    a = lerp(da, a, F_(*c));
}

STAGE() [75/188]

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

Definition at line 2686 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
 
    F cr,cg,cb;
    from_565(load<U16>(ptr), &cr, &cg, &cb);
 
    F ca = alpha_coverage_from_rgb_coverage(a,da, cr,cg,cb);
 
    r = lerp(dr, r, cr);
    g = lerp(dg, g, cg);
    b = lerp(db, b, cb);
    a = lerp(da, a, ca);
}

STAGE() [76/188]

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

Definition at line 2668 of file SkRasterPipeline_opts.h.

                                         {
    auto c = sk_unaligned_load<F>(scales);
    r = lerp(dr, r, c);
    g = lerp(dg, g, c);
    b = lerp(db, b, c);
    a = lerp(da, a, c);
}

STAGE() [77/188]

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

Definition at line 2675 of file SkRasterPipeline_opts.h.

                                                      {
    auto ptr = ptr_at_xy<const uint8_t>(ctx, dx,dy);
 
    auto scales = load<U8>(ptr);
    auto c = from_byte(scales);
 
    r = lerp(dr, r, c);
    g = lerp(dg, g, c);
    b = lerp(db, b, c);
    a = lerp(da, a, c);
}

STAGE() [78/188]

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

Definition at line 3067 of file SkRasterPipeline_opts.h.

                                                               {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx, dy);
    from_10101010_xr(load<U64>(ptr), &r,&g, &b, &a);
}

STAGE() [79/188]

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

Definition at line 3071 of file SkRasterPipeline_opts.h.

                                                                   {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx, dy);
    from_10101010_xr(load<U64>(ptr), &dr, &dg, &db, &da);
}

STAGE() [80/188]

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

Definition at line 3036 of file SkRasterPipeline_opts.h.

                                                           {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
    from_1010102(load<U32>(ptr), &r,&g,&b,&a);
}

STAGE() [81/188]

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

Definition at line 3040 of file SkRasterPipeline_opts.h.

                                                               {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
    from_1010102(load<U32>(ptr), &dr,&dg,&db,&da);
}

STAGE() [82/188]

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

Definition at line 3044 of file SkRasterPipeline_opts.h.

                                                              {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
    from_1010102_xr(load<U32>(ptr), &r,&g,&b,&a);
}

STAGE() [83/188]

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

Definition at line 3048 of file SkRasterPipeline_opts.h.

                                                                  {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
    from_1010102_xr(load<U32>(ptr), &dr,&dg,&db,&da);
}

STAGE() [84/188]

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

Definition at line 3011 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx, dy);
    from_10x6(load<U64>(ptr), &r,&g, &b, &a);
}

STAGE() [85/188]

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

Definition at line 3015 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx, dy);
    from_10x6(load<U64>(ptr), &dr, &dg, &db, &da);
}

STAGE() [86/188]

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

Definition at line 2987 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx, dy);
    from_16161616(load<U64>(ptr), &r,&g, &b, &a);
}

STAGE() [87/188]

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

Definition at line 2991 of file SkRasterPipeline_opts.h.

                                                                {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx, dy);
    from_16161616(load<U64>(ptr), &dr, &dg, &db, &da);
}

STAGE() [88/188]

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

Definition at line 2867 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
    from_4444(load<U16>(ptr), &r,&g,&b,&a);
}

STAGE() [89/188]

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

Definition at line 2871 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
    from_4444(load<U16>(ptr), &dr,&dg,&db,&da);
}

STAGE() [90/188]

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

Definition at line 2840 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
 
    from_565(load<U16>(ptr), &r,&g,&b);
    a = F1;
}

STAGE() [91/188]

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

Definition at line 2846 of file SkRasterPipeline_opts.h.

                                                           {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
 
    from_565(load<U16>(ptr), &dr,&dg,&db);
    da = F1;
}

STAGE() [92/188]

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

Definition at line 2889 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
    from_8888(load<U32>(ptr), &r,&g,&b,&a);
}

STAGE() [93/188]

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

Definition at line 2893 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx,dy);
    from_8888(load<U32>(ptr), &dr,&dg,&db,&da);
}

STAGE() [94/188]

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

Definition at line 2937 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
    r = g = b = F0;
    a = from_short(load<U16>(ptr));
}

STAGE() [95/188]

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

Definition at line 2942 of file SkRasterPipeline_opts.h.

                                                           {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx, dy);
    dr = dg = db = F0;
    da = from_short(load<U16>(ptr));
}

STAGE() [96/188]

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

Definition at line 2809 of file SkRasterPipeline_opts.h.

                                                      {
    auto ptr = ptr_at_xy<const uint8_t>(ctx, dx,dy);
 
    r = g = b = F0;
    a = from_byte(load<U8>(ptr));
}

STAGE() [97/188]

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

Definition at line 2815 of file SkRasterPipeline_opts.h.

                                                          {
    auto ptr = ptr_at_xy<const uint8_t>(ctx, dx,dy);
 
    dr = dg = db = F0;
    da = from_byte(load<U8>(ptr));
}

STAGE() [98/188]

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

Definition at line 3149 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
 
    U16 A = load<U16>((const uint16_t*)ptr);
    r = F0;
    g = F0;
    b = F0;
    a = from_half(A);
}

STAGE() [99/188]

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

Definition at line 3158 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx, dy);
 
    U16 A = load<U16>((const uint16_t*)ptr);
    dr = dg = db = F0;
    da = from_half(A);
}

STAGE() [100/188]

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

Definition at line 2145 of file SkRasterPipeline_opts.h.

                                  {
    dr = sk_unaligned_load<F>(ptr + 0*N);
    dg = sk_unaligned_load<F>(ptr + 1*N);
    db = sk_unaligned_load<F>(ptr + 2*N);
    da = sk_unaligned_load<F>(ptr + 3*N);
}

STAGE() [101/188]

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

Definition at line 3109 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx,dy);
 
    U16 R,G,B,A;
    load4((const uint16_t*)ptr, &R,&G,&B,&A);
    r = from_half(R);
    g = from_half(G);
    b = from_half(B);
    a = from_half(A);
}

STAGE() [102/188]

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

Definition at line 3119 of file SkRasterPipeline_opts.h.

                                                           {
    auto ptr = ptr_at_xy<const uint64_t>(ctx, dx,dy);
 
    U16 R,G,B,A;
    load4((const uint16_t*)ptr, &R,&G,&B,&A);
    dr = from_half(R);
    dg = from_half(G);
    db = from_half(B);
    da = from_half(A);
}

STAGE() [103/188]

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

Definition at line 3214 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<const float>(ctx, 4*dx,4*dy);
    load4(ptr, &r,&g,&b,&a);
}

STAGE() [104/188]

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

Definition at line 3218 of file SkRasterPipeline_opts.h.

                                                           {
    auto ptr = ptr_at_xy<const float>(ctx, 4*dx,4*dy);
    load4(ptr, &dr,&dg,&db,&da);
}

STAGE() [105/188]

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

Definition at line 2960 of file SkRasterPipeline_opts.h.

                                                          {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx, dy);
    b = F0;
    a = F1;
    from_1616(load<U32>(ptr), &r,&g);
}

STAGE() [106/188]

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

Definition at line 2966 of file SkRasterPipeline_opts.h.

                                                              {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx, dy);
    from_1616(load<U32>(ptr), &dr, &dg);
    db = F0;
    da = F1;
}

STAGE() [107/188]

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

Definition at line 2912 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx, dy);
    from_88(load<U16>(ptr), &r, &g);
    b = F0;
    a = F1;
}

STAGE() [108/188]

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

Definition at line 2918 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx, dy);
    from_88(load<U16>(ptr), &dr, &dg);
    db = F0;
    da = F1;
}

STAGE() [109/188]

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

Definition at line 3176 of file SkRasterPipeline_opts.h.

                                                         {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx, dy);
 
    U16 R,G;
    load2((const uint16_t*)ptr, &R, &G);
    r = from_half(R);
    g = from_half(G);
    b = F0;
    a = F1;
}

STAGE() [110/188]

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

Definition at line 3186 of file SkRasterPipeline_opts.h.

                                                             {
    auto ptr = ptr_at_xy<const uint32_t>(ctx, dx, dy);
 
    U16 R,G;
    load2((const uint16_t*)ptr, &R, &G);
    dr = from_half(R);
    dg = from_half(G);
    db = F0;
    da = F1;
}

STAGE() [111/188]

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

Definition at line 2115 of file SkRasterPipeline_opts.h.

                                  {
    r = sk_unaligned_load<F>(ptr + 0*N);
    g = sk_unaligned_load<F>(ptr + 1*N);
    b = sk_unaligned_load<F>(ptr + 2*N);
    a = sk_unaligned_load<F>(ptr + 3*N);
}

STAGE() [112/188]

SK_OPTS_NS::STAGE	(	load_src_rg	,
		float *	ptr
	)

Definition at line 2135 of file SkRasterPipeline_opts.h.

                               {
    r = sk_unaligned_load<F>(ptr + 0*N);
    g = sk_unaligned_load<F>(ptr + 1*N);
}

STAGE() [113/188]

SK_OPTS_NS::STAGE	(	luminosity	,
		NoCtx
	)

Definition at line 2332 of file SkRasterPipeline_opts.h.

                         {
    F R = dr*a,
      G = dg*a,
      B = db*a;
 
    set_lum(&R, &G, &B, lum(r,g,b)*da);
    clip_color(&R,&G,&B, a*da);
 
    r = mad(r, inv(da), mad(dr, inv(a), R));
    g = mad(g, inv(da), mad(dg, inv(a), G));
    b = mad(b, inv(da), mad(db, inv(a), B));
    a = a + nmad(a, da, da);
}

STAGE() [114/188]

SK_OPTS_NS::STAGE	(	mask_2pt_conical_degenerates	,
		SkRasterPipeline_2PtConicalCtx *	c
	)

Definition at line 3549 of file SkRasterPipeline_opts.h.

                                                                       {
    F& t = r;
    auto is_degenerate = (t <= 0) | (t != t);
    t = if_then_else(is_degenerate, F0, t);
    sk_unaligned_store(&c->fMask, cond_to_mask(!is_degenerate));
}

STAGE() [115/188]

SK_OPTS_NS::STAGE	(	mask_2pt_conical_nan	,
		SkRasterPipeline_2PtConicalCtx *	c
	)

Definition at line 3542 of file SkRasterPipeline_opts.h.

                                                               {
    F& t = r;
    auto is_degenerate = (t != t); // NaN
    t = if_then_else(is_degenerate, F0, t);
    sk_unaligned_store(&c->fMask, cond_to_mask(!is_degenerate));
}

STAGE() [116/188]

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

Definition at line 3340 of file SkRasterPipeline_opts.h.

                                  {
    auto R = mad(r,m[0], mad(g,m[1], m[2])),
         G = mad(r,m[3], mad(g,m[4], m[5]));
    r = R;
    g = G;
}

STAGE() [117/188]

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

Definition at line 3346 of file SkRasterPipeline_opts.h.

                                  {
    auto R = mad(r,m[0], mad(g,m[3], b*m[6])),
         G = mad(r,m[1], mad(g,m[4], b*m[7])),
         B = mad(r,m[2], mad(g,m[5], b*m[8]));
    r = R;
    g = G;
    b = B;
}

STAGE() [118/188]

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

Definition at line 3354 of file SkRasterPipeline_opts.h.

                                  {
    auto R = mad(r,m[0], mad(g,m[3], mad(b,m[6], m[ 9]))),
         G = mad(r,m[1], mad(g,m[4], mad(b,m[7], m[10]))),
         B = mad(r,m[2], mad(g,m[5], mad(b,m[8], m[11])));
    r = R;
    g = G;
    b = B;
}

STAGE() [119/188]

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

Definition at line 3372 of file SkRasterPipeline_opts.h.

                                  {
    auto X = r,
         Y = g;
 
    r = mad(X, m[0], mad(Y, m[4], m[ 8]));
    g = mad(X, m[1], mad(Y, m[5], m[ 9]));
    b = mad(X, m[2], mad(Y, m[6], m[10]));
    a = mad(X, m[3], mad(Y, m[7], m[11]));
}

STAGE() [120/188]

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

Definition at line 3362 of file SkRasterPipeline_opts.h.

                                  {
    auto R = mad(r,m[ 0], mad(g,m[ 1], mad(b,m[ 2], mad(a,m[ 3], m[ 4])))),
         G = mad(r,m[ 5], mad(g,m[ 6], mad(b,m[ 7], mad(a,m[ 8], m[ 9])))),
         B = mad(r,m[10], mad(g,m[11], mad(b,m[12], mad(a,m[13], m[14])))),
         A = mad(r,m[15], mad(g,m[16], mad(b,m[17], mad(a,m[18], m[19]))));
    r = R;
    g = G;
    b = B;
    a = A;
}

STAGE() [121/188]

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

Definition at line 3381 of file SkRasterPipeline_opts.h.

                                          {
    // N.B. Unlike the other matrix_ stages, this matrix is row-major.
    auto R = mad(r,m[0], mad(g,m[1], m[2])),
         G = mad(r,m[3], mad(g,m[4], m[5])),
         Z = mad(r,m[6], mad(g,m[7], m[8]));
    r = R * rcp_precise(Z);
    g = G * rcp_precise(Z);
}

STAGE() [122/188]

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

Definition at line 3336 of file SkRasterPipeline_opts.h.

                                              {
    r = mad(r,m[0], m[2]);
    g = mad(g,m[1], m[3]);
}

STAGE() [123/188]

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

Definition at line 3332 of file SkRasterPipeline_opts.h.

                                        {
    r += m[0];
    g += m[1];
}

STAGE() [124/188]

SK_OPTS_NS::STAGE	(	mipmap_linear_finish	,
		SkRasterPipeline_MipmapCtx *	ctx
	)

Definition at line 3824 of file SkRasterPipeline_opts.h.

                                                             {
    r = lerp(sk_unaligned_load<F>(ctx->r), r, F_(ctx->lowerWeight));
    g = lerp(sk_unaligned_load<F>(ctx->g), g, F_(ctx->lowerWeight));
    b = lerp(sk_unaligned_load<F>(ctx->b), b, F_(ctx->lowerWeight));
    a = lerp(sk_unaligned_load<F>(ctx->a), a, F_(ctx->lowerWeight));
}

STAGE() [125/188]

SK_OPTS_NS::STAGE	(	mipmap_linear_init	,
		SkRasterPipeline_MipmapCtx *	ctx
	)

Definition at line 3809 of file SkRasterPipeline_opts.h.

                                                           {
    sk_unaligned_store(ctx->x, r);
    sk_unaligned_store(ctx->y, g);
}

STAGE() [126/188]

SK_OPTS_NS::STAGE	(	mipmap_linear_update	,
		SkRasterPipeline_MipmapCtx *	ctx
	)

Definition at line 3814 of file SkRasterPipeline_opts.h.

                                                             {
    sk_unaligned_store(ctx->r, r);
    sk_unaligned_store(ctx->g, g);
    sk_unaligned_store(ctx->b, b);
    sk_unaligned_store(ctx->a, a);
 
    r = sk_unaligned_load<F>(ctx->x) * ctx->scaleX;
    g = sk_unaligned_load<F>(ctx->y) * ctx->scaleY;
}

STAGE() [127/188]

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

Definition at line 3260 of file SkRasterPipeline_opts.h.

{ r = exclusive_mirror(r, ctx); }

STAGE() [128/188]

SK_OPTS_NS::STAGE	(	mirror_x_1	,
		NoCtx
	)

Definition at line 3265 of file SkRasterPipeline_opts.h.

{ r = clamp_01_(abs_( (r-1.0f) - two(floor_((r-1.0f)*0.5f)) - 1.0f )); }

STAGE() [129/188]

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

Definition at line 3261 of file SkRasterPipeline_opts.h.

{ g = exclusive_mirror(g, ctx); }

STAGE() [130/188]

SK_OPTS_NS::STAGE	(	move_dst_src	,
		NoCtx
	)

Definition at line 2416 of file SkRasterPipeline_opts.h.

                           {
    r = dr;
    g = dg;
    b = db;
    a = da;
}

STAGE() [131/188]

SK_OPTS_NS::STAGE	(	move_src_dst	,
		NoCtx
	)

Definition at line 2410 of file SkRasterPipeline_opts.h.

                           {
    dr = r;
    dg = g;
    db = b;
    da = a;
}

STAGE() [132/188]

SK_OPTS_NS::STAGE	(	negate_x	,
		NoCtx
	)

Definition at line 3505 of file SkRasterPipeline_opts.h.

{ r = -r; }

STAGE() [133/188]

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

Definition at line 2729 of file SkRasterPipeline_opts.h.

                                                     {
    auto fn = [&](F v) {
        U32 sign;
        v = strip_sign(v, &sign);
 
        F r = if_then_else(v <= ctx->d, mad(ctx->c, v, ctx->f)
                                      , approx_powf(mad(ctx->a, v, ctx->b), ctx->g) + ctx->e);
        return apply_sign(r, sign);
    };
    r = fn(r);
    g = fn(g);
    b = fn(b);
}

STAGE() [134/188]

SK_OPTS_NS::STAGE	(	perlin_noise	,
		SkRasterPipeline_PerlinNoiseCtx *	ctx
	)

Definition at line 3710 of file SkRasterPipeline_opts.h.

                                                          {
    F noiseVecX = (r + 0.5) * ctx->baseFrequencyX;
    F noiseVecY = (g + 0.5) * ctx->baseFrequencyY;
    r = g = b = a = F0;
    F stitchDataX = F_(ctx->stitchDataInX);
    F stitchDataY = F_(ctx->stitchDataInY);
    F ratio = F1;
 
    for (int octave = 0; octave < ctx->numOctaves; ++octave) {
        // Calculate noise coordinates. (Roughly $noise_helper in Graphite)
        F floorValX = floor_(noiseVecX);
        F floorValY = floor_(noiseVecY);
        F  ceilValX = floorValX + 1.0f;
        F  ceilValY = floorValY + 1.0f;
        F fractValX = noiseVecX - floorValX;
        F fractValY = noiseVecY - floorValY;
 
        if (ctx->stitching) {
            // If we are stitching, wrap the coordinates to the stitch position.
            floorValX -= sk_bit_cast<F>(cond_to_mask(floorValX >= stitchDataX) &
                                        sk_bit_cast<I32>(stitchDataX));
            floorValY -= sk_bit_cast<F>(cond_to_mask(floorValY >= stitchDataY) &
                                        sk_bit_cast<I32>(stitchDataY));
            ceilValX -= sk_bit_cast<F>(cond_to_mask(ceilValX >= stitchDataX) &
                                       sk_bit_cast<I32>(stitchDataX));
            ceilValY -= sk_bit_cast<F>(cond_to_mask(ceilValY >= stitchDataY) &
                                       sk_bit_cast<I32>(stitchDataY));
        }
 
        U32 latticeLookup = (U32)(iround(floorValX)) & 0xFF;
        F latticeIdxX = cast(expand(gather(ctx->latticeSelector, latticeLookup)));
        latticeLookup = (U32)(iround(ceilValX)) & 0xFF;
        F latticeIdxY = cast(expand(gather(ctx->latticeSelector, latticeLookup)));
 
        U32 b00 = (U32)(iround(latticeIdxX + floorValY)) & 0xFF;
        U32 b10 = (U32)(iround(latticeIdxY + floorValY)) & 0xFF;
        U32 b01 = (U32)(iround(latticeIdxX + ceilValY)) & 0xFF;
        U32 b11 = (U32)(iround(latticeIdxY + ceilValY)) & 0xFF;
 
        // Calculate noise colors. (Roughly $noise_function in Graphite)
        // Apply Hermite interpolation to the fractional value.
        F smoothX = fractValX * fractValX * (3.0f - 2.0f * fractValX);
        F smoothY = fractValY * fractValY * (3.0f - 2.0f * fractValY);
 
        F color[4];
        const uint32_t* channelNoiseData = reinterpret_cast<const uint32_t*>(ctx->noiseData);
        for (int channel = 0; channel < 4; ++channel) {
            U32 sample00 = gather(channelNoiseData, b00);
            U32 sample10 = gather(channelNoiseData, b10);
            U32 sample01 = gather(channelNoiseData, b01);
            U32 sample11 = gather(channelNoiseData, b11);
            channelNoiseData += 256;
 
            F u = compute_perlin_vector(sample00, fractValX,        fractValY);
            F v = compute_perlin_vector(sample10, fractValX - 1.0f, fractValY);
            F A = lerp(u, v, smoothX);
 
              u = compute_perlin_vector(sample01, fractValX,        fractValY - 1.0f);
              v = compute_perlin_vector(sample11, fractValX - 1.0f, fractValY - 1.0f);
            F B = lerp(u, v, smoothX);
 
            color[channel] = lerp(A, B, smoothY);
        }
 
        if (ctx->noiseType != SkPerlinNoiseShaderType::kFractalNoise) {
            // For kTurbulence the result is: abs(noise[-1,1])
            color[0] = abs_(color[0]);
            color[1] = abs_(color[1]);
            color[2] = abs_(color[2]);
            color[3] = abs_(color[3]);
        }
 
        r = mad(color[0], ratio, r);
        g = mad(color[1], ratio, g);
        b = mad(color[2], ratio, b);
        a = mad(color[3], ratio, a);
 
        // Scale inputs for the next round.
        noiseVecX *= 2.0f;
        noiseVecY *= 2.0f;
        stitchDataX *= 2.0f;
        stitchDataY *= 2.0f;
        ratio *= 0.5f;
    }
 
    if (ctx->noiseType == SkPerlinNoiseShaderType::kFractalNoise) {
        // For kFractalNoise the result is: noise[-1,1] * 0.5 + 0.5
        r = mad(r, 0.5f, 0.5f);
        g = mad(g, 0.5f, 0.5f);
        b = mad(b, 0.5f, 0.5f);
        a = mad(a, 0.5f, 0.5f);
    }
 
    r = clamp_01_(r) * a;
    g = clamp_01_(g) * a;
    b = clamp_01_(b) * a;
    a = clamp_01_(a);
}

STAGE() [135/188]

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

Definition at line 2754 of file SkRasterPipeline_opts.h.

                                                {
    auto fn = [&](F v) {
        U32 sign;
        v = strip_sign(v, &sign);
 
        F r = approx_powf(max(mad(ctx->b, approx_powf(v, ctx->c), ctx->a), 0.0f)
                           / (mad(ctx->e, approx_powf(v, ctx->c), ctx->d)),
                        ctx->f);
 
        return apply_sign(r, sign);
    };
    r = fn(r);
    g = fn(g);
    b = fn(b);
}

STAGE() [136/188]

SK_OPTS_NS::STAGE	(	premul	,
		NoCtx
	)

Definition at line 2429 of file SkRasterPipeline_opts.h.

                     {
    r = r * a;
    g = g * a;
    b = b * a;
}

STAGE() [137/188]

SK_OPTS_NS::STAGE	(	premul_dst	,
		NoCtx
	)

Definition at line 2434 of file SkRasterPipeline_opts.h.

                         {
    dr = dr * da;
    dg = dg * da;
    db = db * da;
}

STAGE() [138/188]

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

Definition at line 3258 of file SkRasterPipeline_opts.h.

{ r = exclusive_repeat(r, ctx); }

STAGE() [139/188]

SK_OPTS_NS::STAGE	(	repeat_x_1	,
		NoCtx
	)

Definition at line 3264 of file SkRasterPipeline_opts.h.

{ r = clamp_01_(r - floor_(r)); }

STAGE() [140/188]

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

Definition at line 3259 of file SkRasterPipeline_opts.h.

{ g = exclusive_repeat(g, ctx); }

STAGE() [141/188]

SK_OPTS_NS::STAGE	(	rgb_to_hsl	,
		NoCtx
	)

Definition at line 2456 of file SkRasterPipeline_opts.h.

                         {
    F mx = max(r, max(g,b)),
      mn = min(r, min(g,b)),
      d = mx - mn,
      d_rcp = 1.0f / d;
 
    F h = (1/6.0f) *
          if_then_else(mx == mn, 0.0f,
          if_then_else(mx ==  r, (g-b)*d_rcp + if_then_else(g < b, 6.0f, 0.0f),
          if_then_else(mx ==  g, (b-r)*d_rcp + 2.0f,
                                 (r-g)*d_rcp + 4.0f)));
 
    F l = (mx + mn) * 0.5f;
    F s = if_then_else(mx == mn, 0.0f,
                       d / if_then_else(l > 0.5f, 2.0f-mx-mn, mx+mn));
 
    r = h;
    g = s;
    b = l;
}

STAGE() [142/188]

SK_OPTS_NS::STAGE	(	saturation	,
		NoCtx
	)

Definition at line 2305 of file SkRasterPipeline_opts.h.

                         {
    F R = dr*a,
      G = dg*a,
      B = db*a;
 
    set_sat(&R, &G, &B, sat( r, g, b)*da);
    set_lum(&R, &G, &B, lum(dr,dg,db)* a);  // (This is not redundant.)
    clip_color(&R,&G,&B, a*da);
 
    r = mad(r, inv(da), mad(dr, inv(a), R));
    g = mad(g, inv(da), mad(dg, inv(a), G));
    b = mad(b, inv(da), mad(db, inv(a), B));
    a = a + nmad(a, da, da);
}

STAGE() [143/188]

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

Definition at line 2620 of file SkRasterPipeline_opts.h.

                                     {
    r = r * *c;
    g = g * *c;
    b = b * *c;
    a = a * *c;
}

STAGE() [144/188]

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

Definition at line 2637 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<const uint16_t>(ctx, dx,dy);
 
    F cr,cg,cb;
    from_565(load<U16>(ptr), &cr, &cg, &cb);
 
    F ca = alpha_coverage_from_rgb_coverage(a,da, cr,cg,cb);
 
    r = r * cr;
    g = g * cg;
    b = b * cb;
    a = a * ca;
}

STAGE() [145/188]

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

Definition at line 2661 of file SkRasterPipeline_opts.h.

                                          {
    auto c = sk_unaligned_load<F>(scales);
    r = r * c;
    g = g * c;
    b = b * c;
    a = a * c;
}

STAGE() [146/188]

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

Definition at line 2626 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<const uint8_t>(ctx, dx,dy);
 
    auto scales = load<U8>(ptr);
    auto c = from_byte(scales);
 
    r = r * c;
    g = g * c;
    b = b * c;
    a = a * c;
}

STAGE() [147/188]

SK_OPTS_NS::STAGE	(	seed_shader	,
		NoCtx
	)

Definition at line 2033 of file SkRasterPipeline_opts.h.

                          {
    static constexpr float iota[] = {
        0.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 7.5f,
        8.5f, 9.5f,10.5f,11.5f,12.5f,13.5f,14.5f,15.5f,
    };
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
 
    // It's important for speed to explicitly cast(dx) and cast(dy),
    // which has the effect of splatting them to vectors before converting to floats.
    // On Intel this breaks a data dependency on previous loop iterations' registers.
    r = cast(U32_(dx)) + sk_unaligned_load<F>(iota);
    g = cast(U32_(dy)) + 0.5f;
    b = F1;  // This is w=1 for matrix multiplies by the device coords.
    a = F0;
}

STAGE() [148/188]

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

Definition at line 2387 of file SkRasterPipeline_opts.h.

                                 {
    r = F_(rgb[0]);
    g = F_(rgb[1]);
    b = F_(rgb[2]);
}

STAGE() [149/188]

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

Definition at line 2346 of file SkRasterPipeline_opts.h.

                                                                {
    auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
 
    U32 dst = load<U32>(ptr);
    dr = cast((dst      ) & 0xff);
    dg = cast((dst >>  8) & 0xff);
    db = cast((dst >> 16) & 0xff);
    da = cast((dst >> 24)       );
    // {dr,dg,db,da} are in [0,255]
    // { r, g, b, a} are in [0,  1] (but may be out of gamut)
 
    r = mad(dr, inv(a), r*255.0f);
    g = mad(dg, inv(a), g*255.0f);
    b = mad(db, inv(a), b*255.0f);
    a = mad(da, inv(a), a*255.0f);
    // { r, g, b, a} are now in [0,255]  (but may be out of gamut)
 
    // to_unorm() clamps back to gamut.  Scaling by 1 since we're already 255-biased.
    dst = to_unorm(r, 1, 255)
        | to_unorm(g, 1, 255) <<  8
        | to_unorm(b, 1, 255) << 16
        | to_unorm(a, 1, 255) << 24;
    store(ptr, dst);
}

STAGE() [150/188]

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

Definition at line 3075 of file SkRasterPipeline_opts.h.

                                                                {
    static constexpr float min = -0.752941f;
    static constexpr float max = 1.25098f;
    static constexpr float range = max - min;
    auto ptr = ptr_at_xy<uint16_t>(ctx, 4*dx,4*dy);
 
    U16 R = pack(to_unorm((r - min) / range, 1023)) << 6,
        G = pack(to_unorm((g - min) / range, 1023)) << 6,
        B = pack(to_unorm((b - min) / range, 1023)) << 6,
        A = pack(to_unorm((a - min) / range, 1023)) << 6;
 
    store4(ptr, R,G,B,A);
}

STAGE() [151/188]

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

Definition at line 3088 of file SkRasterPipeline_opts.h.

                                                            {
    auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
 
    U32 px = to_unorm(r, 1023)
           | to_unorm(g, 1023) << 10
           | to_unorm(b, 1023) << 20
           | to_unorm(a,    3) << 30;
    store(ptr, px);
}

STAGE() [152/188]

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

Definition at line 3097 of file SkRasterPipeline_opts.h.

                                                               {
    auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
    static constexpr float min = -0.752941f;
    static constexpr float max = 1.25098f;
    static constexpr float range = max - min;
    U32 px = to_unorm((r - min) / range, 1023)
           | to_unorm((g - min) / range, 1023) << 10
           | to_unorm((b - min) / range, 1023) << 20
           | to_unorm(a,    3) << 30;
    store(ptr, px);
}

STAGE() [153/188]

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

Definition at line 3024 of file SkRasterPipeline_opts.h.

                                                         {
    auto ptr = ptr_at_xy<uint16_t>(ctx, 4*dx,4*dy);
 
    U16 R = pack(to_unorm(r, 1023)) << 6,
        G = pack(to_unorm(g, 1023)) << 6,
        B = pack(to_unorm(b, 1023)) << 6,
        A = pack(to_unorm(a, 1023)) << 6;
 
    store4(ptr, R,G,B,A);
}

STAGE() [154/188]

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

Definition at line 3000 of file SkRasterPipeline_opts.h.

                                                             {
    auto ptr = ptr_at_xy<uint16_t>(ctx, 4*dx,4*dy);
 
    U16 R = pack(to_unorm(r, 65535)),
        G = pack(to_unorm(g, 65535)),
        B = pack(to_unorm(b, 65535)),
        A = pack(to_unorm(a, 65535));
 
    store4(ptr, R,G,B,A);
}

STAGE() [155/188]

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

Definition at line 2880 of file SkRasterPipeline_opts.h.

                                                         {
    auto ptr = ptr_at_xy<uint16_t>(ctx, dx,dy);
    U16 px = pack( to_unorm(r, 15) << 12
                 | to_unorm(g, 15) <<  8
                 | to_unorm(b, 15) <<  4
                 | to_unorm(a, 15)      );
    store(ptr, px);
}

STAGE() [156/188]

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

Definition at line 2858 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<uint16_t>(ctx, dx,dy);
 
    U16 px = pack( to_unorm(r, 31) << 11
                 | to_unorm(g, 63) <<  5
                 | to_unorm(b, 31)      );
    store(ptr, px);
}

STAGE() [157/188]

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

Definition at line 2902 of file SkRasterPipeline_opts.h.

                                                         {
    auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
 
    U32 px = to_unorm(r, 255)
           | to_unorm(g, 255) <<  8
           | to_unorm(b, 255) << 16
           | to_unorm(a, 255) << 24;
    store(ptr, px);
}

STAGE() [158/188]

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

Definition at line 2953 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<uint16_t>(ctx, dx,dy);
 
    U16 px = pack(to_unorm(a, 65535));
    store(ptr, px);
}

STAGE() [159/188]

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

Definition at line 2827 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<uint8_t>(ctx, dx,dy);
 
    U8 packed = pack(pack(to_unorm(a, 255)));
    store(ptr, packed);
}

STAGE() [160/188]

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

Definition at line 3171 of file SkRasterPipeline_opts.h.

                                                         {
    auto ptr = ptr_at_xy<uint16_t>(ctx, dx,dy);
    store(ptr, to_half(a));
}

STAGE() [161/188]

SK_OPTS_NS::STAGE	(	store_dst	,
		float *	ptr
	)

Definition at line 2153 of file SkRasterPipeline_opts.h.

                             {
    sk_unaligned_store(ptr + 0*N, dr);
    sk_unaligned_store(ptr + 1*N, dg);
    sk_unaligned_store(ptr + 2*N, db);
    sk_unaligned_store(ptr + 3*N, da);
}

STAGE() [162/188]

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

Definition at line 3141 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<uint64_t>(ctx, dx,dy);
    store4((uint16_t*)ptr, to_half(r)
                         , to_half(g)
                         , to_half(b)
                         , to_half(a));
}

STAGE() [163/188]

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

Definition at line 3230 of file SkRasterPipeline_opts.h.

                                                        {
    auto ptr = ptr_at_xy<float>(ctx, 4*dx,4*dy);
    store4(ptr, r,g,b,a);
}

STAGE() [164/188]

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

Definition at line 2833 of file SkRasterPipeline_opts.h.

                                                       {
    auto ptr = ptr_at_xy<uint8_t>(ctx, dx,dy);
 
    U8 packed = pack(pack(to_unorm(r, 255)));
    store(ptr, packed);
}

STAGE() [165/188]

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

Definition at line 2979 of file SkRasterPipeline_opts.h.

                                                           {
    auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
 
    U32 px = to_unorm(r, 65535)
           | to_unorm(g, 65535) <<  16;
    store(ptr, px);
}

STAGE() [166/188]

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

Definition at line 2931 of file SkRasterPipeline_opts.h.

                                                         {
    auto ptr = ptr_at_xy<uint16_t>(ctx, dx, dy);
    U16 px = pack( to_unorm(r, 255) | to_unorm(g, 255) <<  8 );
    store(ptr, px);
}

STAGE() [167/188]

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

Definition at line 3208 of file SkRasterPipeline_opts.h.

                                                          {
    auto ptr = ptr_at_xy<uint32_t>(ctx, dx, dy);
    store2((uint16_t*)ptr, to_half(r)
                         , to_half(g));
}

STAGE() [168/188]

SK_OPTS_NS::STAGE	(	store_src	,
		float *	ptr
	)

Definition at line 2123 of file SkRasterPipeline_opts.h.

                             {
    sk_unaligned_store(ptr + 0*N, r);
    sk_unaligned_store(ptr + 1*N, g);
    sk_unaligned_store(ptr + 2*N, b);
    sk_unaligned_store(ptr + 3*N, a);
}

STAGE() [169/188]

SK_OPTS_NS::STAGE	(	store_src_a	,
		float *	ptr
	)

Definition at line 2140 of file SkRasterPipeline_opts.h.

                               {
    sk_unaligned_store(ptr, a);
}

STAGE() [170/188]

SK_OPTS_NS::STAGE	(	store_src_rg	,
		float *	ptr
	)

Definition at line 2130 of file SkRasterPipeline_opts.h.

                                {
    sk_unaligned_store(ptr + 0*N, r);
    sk_unaligned_store(ptr + 1*N, g);
}

STAGE() [171/188]

SK_OPTS_NS::STAGE	(	swap_rb	,
		NoCtx
	)

Definition at line 2399 of file SkRasterPipeline_opts.h.

                      {
    auto tmp = r;
    r = b;
    b = tmp;
}

STAGE() [172/188]

SK_OPTS_NS::STAGE	(	swap_rb_dst	,
		NoCtx
	)

Definition at line 2404 of file SkRasterPipeline_opts.h.

                          {
    auto tmp = dr;
    dr = db;
    db = tmp;
}

STAGE() [173/188]

SK_OPTS_NS::STAGE	(	swap_src_dst	,
		NoCtx
	)

Definition at line 2422 of file SkRasterPipeline_opts.h.

                           {
    std::swap(r, dr);
    std::swap(g, dg);
    std::swap(b, db);
    std::swap(a, da);
}

STAGE() [174/188]

SK_OPTS_NS::STAGE	(	swizzle	,
		void *	ctx
	)

Definition at line 5043 of file SkRasterPipeline_opts.h.

                          {
    auto ir = r, ig = g, ib = b, ia = a;
    F* o[] = {&r, &g, &b, &a};
    char swiz[4];
    memcpy(swiz, &ctx, sizeof(swiz));
 
    for (int i = 0; i < 4; ++i) {
        switch (swiz[i]) {
            case 'r': *o[i] = ir; break;
            case 'g': *o[i] = ig; break;
            case 'b': *o[i] = ib; break;
            case 'a': *o[i] = ia; break;
            case '0': *o[i] = F0; break;
            case '1': *o[i] = F1; break;
            default:              break;
        }
    }
}

STAGE() [175/188]

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

Definition at line 2393 of file SkRasterPipeline_opts.h.

                                           {
    r = F_(rgb[0]);
    g = F_(rgb[1]);
    b = F_(rgb[2]);
}

STAGE() [176/188]

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

Definition at line 2090 of file SkRasterPipeline_opts.h.

                                                                          {
    r = F_(c->r);
    g = F_(c->g);
    b = F_(c->b);
    a = F_(c->a);
}

STAGE() [177/188]

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

Definition at line 2084 of file SkRasterPipeline_opts.h.

                                                                {
    r = F_(c->r);
    g = F_(c->g);
    b = F_(c->b);
    a = F_(c->a);
}

STAGE() [178/188]

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

Definition at line 2097 of file SkRasterPipeline_opts.h.

                                                                    {
    dr = F_(c->r);
    dg = F_(c->g);
    db = F_(c->b);
    da = F_(c->a);
}

STAGE() [179/188]

SK_OPTS_NS::STAGE	(	unpremul	,
		NoCtx
	)

Definition at line 2439 of file SkRasterPipeline_opts.h.

                       {
    float inf = sk_bit_cast<float>(0x7f800000);
    auto scale = if_then_else(1.0f/a < inf, 1.0f/a, 0.0f);
    r *= scale;
    g *= scale;
    b *= scale;
}

STAGE() [180/188]

SK_OPTS_NS::STAGE	(	unpremul_polar	,
		NoCtx
	)

Definition at line 2446 of file SkRasterPipeline_opts.h.

                             {
    float inf = sk_bit_cast<float>(0x7f800000);
    auto scale = if_then_else(1.0f/a < inf, 1.0f/a, 0.0f);
    g *= scale;
    b *= scale;
}

STAGE() [181/188]

SK_OPTS_NS::STAGE	(	white_color	,
		NoCtx
	)

Definition at line 2110 of file SkRasterPipeline_opts.h.

                          {
    r = g = b = a = F1;
}

STAGE() [182/188]

SK_OPTS_NS::STAGE	(	xy_to_2pt_conical_focal_on_circle	,
		NoCtx
	)

Definition at line 3512 of file SkRasterPipeline_opts.h.

                                                {
    F x = r, y = g, &t = r;
    t = x + y*y / x; // (x^2 + y^2) / x
}

STAGE() [183/188]

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

Definition at line 3522 of file SkRasterPipeline_opts.h.

                                                                            {
    F x = r, y = g, &t = r;
    t = sqrt_(x*x - y*y) - x * ctx->fP0; // ctx->fP0 = 1/r1
}

STAGE() [184/188]

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

Definition at line 3527 of file SkRasterPipeline_opts.h.

                                                                            {
    F x = r, y = g, &t = r;
    t = -sqrt_(x*x - y*y) - x * ctx->fP0; // ctx->fP0 = 1/r1
}

STAGE() [185/188]

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

Definition at line 3507 of file SkRasterPipeline_opts.h.

                                                                          {
    F x = r, y = g, &t = r;
    t = x + sqrt_(ctx->fP0 - y*y); // ctx->fP0 = r0 * r0
}

STAGE() [186/188]

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

Definition at line 3517 of file SkRasterPipeline_opts.h.

                                                                                 {
    F x = r, y = g, &t = r;
    t = sqrt_(x*x + y*y) - x * ctx->fP0; // ctx->fP0 = 1/r1
}

STAGE() [187/188]

SK_OPTS_NS::STAGE	(	xy_to_radius	,
		NoCtx
	)

Definition at line 3497 of file SkRasterPipeline_opts.h.

                           {
    F X2 = r * r,
      Y2 = g * g;
    r = sqrt_(X2 + Y2);
}

STAGE() [188/188]

SK_OPTS_NS::STAGE	(	xy_to_unit_angle	,
		NoCtx
	)

Definition at line 3471 of file SkRasterPipeline_opts.h.

                               {
    F X = r,
      Y = g;
    F xabs = abs_(X),
      yabs = abs_(Y);
 
    F slope = min(xabs, yabs)/max(xabs, yabs);
    F s = slope * slope;
 
    // Use a 7th degree polynomial to approximate atan.
    // This was generated using sollya.gforge.inria.fr.
    // A float optimized polynomial was generated using the following command.
    // P1 = fpminimax((1/(2*Pi))*atan(x),[|1,3,5,7|],[|24...|],[2^(-40),1],relative);
    F phi = slope
             * (0.15912117063999176025390625f     + s
             * (-5.185396969318389892578125e-2f   + s
             * (2.476101927459239959716796875e-2f + s
             * (-7.0547382347285747528076171875e-3f))));
 
    phi = if_then_else(xabs < yabs, 1.0f/4.0f - phi, phi);
    phi = if_then_else(X < 0.0f   , 1.0f/2.0f - phi, phi);
    phi = if_then_else(Y < 0.0f   , 1.0f - phi     , phi);
    phi = if_then_else(phi != phi , 0.0f           , phi);  // Check for NaN.
    r = phi;
}

STAGE_BRANCH() [1/5]

SK_OPTS_NS::STAGE_BRANCH	(	branch_if_all_lanes_active	,
		SkRasterPipeline_BranchIfAllLanesActiveCtx *	ctx
	)

Definition at line 3979 of file SkRasterPipeline_opts.h.

                                                                                          {
    uint32_t iota[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
 
    I32 tailLanes = cond_to_mask(*ctx->tail <= sk_unaligned_load<U32>(iota));
    return all(execution_mask() | tailLanes) ? ctx->offset : 1;
}

STAGE_BRANCH() [2/5]

SK_OPTS_NS::STAGE_BRANCH	(	branch_if_any_lanes_active	,
		SkRasterPipeline_BranchCtx *	ctx
	)

Definition at line 3987 of file SkRasterPipeline_opts.h.

                                                                          {
    return any(execution_mask()) ? ctx->offset : 1;
}

STAGE_BRANCH() [3/5]

SK_OPTS_NS::STAGE_BRANCH	(	branch_if_no_active_lanes_eq	,
		SkRasterPipeline_BranchIfEqualCtx *	ctx
	)

Definition at line 3999 of file SkRasterPipeline_opts.h.

                                                                                   {
    // Compare each lane against the expected value...
    I32 match = cond_to_mask(*(const I32*)ctx->ptr == ctx->value);
    // ... but mask off lanes that aren't executing.
    match &= execution_mask();
    // If any lanes matched, don't take the branch.
    return any(match) ? 1 : ctx->offset;
}

STAGE_BRANCH() [4/5]

SK_OPTS_NS::STAGE_BRANCH	(	branch_if_no_lanes_active	,
		SkRasterPipeline_BranchCtx *	ctx
	)

Definition at line 3991 of file SkRasterPipeline_opts.h.

                                                                         {
    return any(execution_mask()) ? 1 : ctx->offset;
}

STAGE_BRANCH() [5/5]

SK_OPTS_NS::STAGE_BRANCH	(	jump	,
		SkRasterPipeline_BranchCtx *	ctx
	)

Definition at line 3995 of file SkRasterPipeline_opts.h.

                                                    {
    return ctx->offset;
}

STAGE_TAIL() [1/75]

SK_OPTS_NS::STAGE_TAIL	(	acos_float	,
		F *	dst
	)

Definition at line 4449 of file SkRasterPipeline_opts.h.

{ *dst = acos_(*dst); }

STAGE_TAIL() [2/75]

SK_OPTS_NS::STAGE_TAIL	(	asin_float	,
		F *	dst
	)

Definition at line 4448 of file SkRasterPipeline_opts.h.

{ *dst = asin_(*dst); }

STAGE_TAIL() [3/75]

SK_OPTS_NS::STAGE_TAIL	(	atan_float	,
		F *	dst
	)

Definition at line 4450 of file SkRasterPipeline_opts.h.

{ *dst = atan_(*dst); }

STAGE_TAIL() [4/75]

SK_OPTS_NS::STAGE_TAIL	(	case_op	,
		SkRasterPipeline_CaseOpCtx *	packed
	)

Definition at line 3947 of file SkRasterPipeline_opts.h.

                                                        {
    auto ctx = SkRPCtxUtils::Unpack(packed);
 
    // Check each lane to see if the case value matches the expectation.
    I32* actualValue = (I32*)(base + ctx.offset);
    I32 caseMatches = cond_to_mask(*actualValue == ctx.expectedValue);
 
    // In lanes where we found a match, enable the loop mask...
    g = sk_bit_cast<F>(sk_bit_cast<I32>(g) | caseMatches);
    update_execution_mask();
 
    // ... and clear the default-case mask.
    I32* defaultMask = actualValue + 1;
    *defaultMask &= ~caseMatches;
}

STAGE_TAIL() [5/75]

SK_OPTS_NS::STAGE_TAIL	(	continue_op	,
		I32 *	continueMask
	)

Definition at line 3938 of file SkRasterPipeline_opts.h.

                                           {
    // Set any currently-executing lanes in the continue-mask to true.
    *continueMask |= execution_mask();
 
    // Disable any currently-executing lanes from the loop mask. (Just like `mask_off_loop_mask`.)
    g = sk_bit_cast<F>(sk_bit_cast<I32>(g) & ~execution_mask());
    update_execution_mask();
}

STAGE_TAIL() [6/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_2_immutables_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4158 of file SkRasterPipeline_opts.h.

                                                                             {
    copy_n_immutable_unmasked_fn<2>(packed, base);
}

STAGE_TAIL() [7/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_2_slots_masked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4183 of file SkRasterPipeline_opts.h.

                                                                      {
    copy_n_slots_masked_fn<2>(packed, base, execution_mask());
}

STAGE_TAIL() [8/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_2_slots_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4128 of file SkRasterPipeline_opts.h.

                                                                        {
    copy_n_slots_unmasked_fn<2>(packed, base);
}

STAGE_TAIL() [9/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_2_uniforms	,
		SkRasterPipeline_UniformCtx *	ctx
	)

Definition at line 4070 of file SkRasterPipeline_opts.h.

                                                              {
    const int* src = ctx->src;
    I32* dst = (I32*)ctx->dst;
    dst[0] = I32_(src[0]);
    dst[1] = I32_(src[1]);
}

STAGE_TAIL() [10/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_3_immutables_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4161 of file SkRasterPipeline_opts.h.

                                                                             {
    copy_n_immutable_unmasked_fn<3>(packed, base);
}

STAGE_TAIL() [11/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_3_slots_masked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4186 of file SkRasterPipeline_opts.h.

                                                                      {
    copy_n_slots_masked_fn<3>(packed, base, execution_mask());
}

STAGE_TAIL() [12/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_3_slots_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4131 of file SkRasterPipeline_opts.h.

                                                                        {
    copy_n_slots_unmasked_fn<3>(packed, base);
}

STAGE_TAIL() [13/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_3_uniforms	,
		SkRasterPipeline_UniformCtx *	ctx
	)

Definition at line 4076 of file SkRasterPipeline_opts.h.

                                                              {
    const int* src = ctx->src;
    I32* dst = (I32*)ctx->dst;
    dst[0] = I32_(src[0]);
    dst[1] = I32_(src[1]);
    dst[2] = I32_(src[2]);
}

STAGE_TAIL() [14/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_4_immutables_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4164 of file SkRasterPipeline_opts.h.

                                                                             {
    copy_n_immutable_unmasked_fn<4>(packed, base);
}

STAGE_TAIL() [15/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_4_slots_masked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4189 of file SkRasterPipeline_opts.h.

                                                                      {
    copy_n_slots_masked_fn<4>(packed, base, execution_mask());
}

STAGE_TAIL() [16/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_4_slots_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4134 of file SkRasterPipeline_opts.h.

                                                                        {
    copy_n_slots_unmasked_fn<4>(packed, base);
}

STAGE_TAIL() [17/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_4_uniforms	,
		SkRasterPipeline_UniformCtx *	ctx
	)

Definition at line 4083 of file SkRasterPipeline_opts.h.

                                                              {
    const int* src = ctx->src;
    I32* dst = (I32*)ctx->dst;
    dst[0] = I32_(src[0]);
    dst[1] = I32_(src[1]);
    dst[2] = I32_(src[2]);
    dst[3] = I32_(src[3]);
}

STAGE_TAIL() [18/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_constant	,
		SkRasterPipeline_ConstantCtx *	packed
	)

Definition at line 4092 of file SkRasterPipeline_opts.h.

                                                                {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    I32* dst = (I32*)(base + ctx.dst);
    I32 value = I32_(ctx.value);
    dst[0] = value;
}

STAGE_TAIL() [19/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_from_indirect_uniform_unmasked	,
		SkRasterPipeline_CopyIndirectCtx *	ctx
	)

Definition at line 4295 of file SkRasterPipeline_opts.h.

                                                                                       {
    // Clamp the indirect offsets to stay within the limit.
    U32 offsets = *(const U32*)ctx->indirectOffset;
    offsets = min(offsets, U32_(ctx->indirectLimit));
 
    // Use gather to perform indirect lookups; write the results into `dst`.
    const int* src = ctx->src;
    I32*       dst = (I32*)ctx->dst;
    I32*       end = dst + ctx->slots;
    do {
        *dst = gather(src, offsets);
        dst += 1;
        src += 1;
    } while (dst != end);
}

STAGE_TAIL() [20/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_from_indirect_unmasked	,
		SkRasterPipeline_CopyIndirectCtx *	ctx
	)

Definition at line 4271 of file SkRasterPipeline_opts.h.

                                                                               {
    // Clamp the indirect offsets to stay within the limit.
    U32 offsets = *(const U32*)ctx->indirectOffset;
    offsets = min(offsets, U32_(ctx->indirectLimit));
 
    // Scale up the offsets to account for the N lanes per value.
    offsets *= N;
 
    // Adjust the offsets forward so that they fetch from the correct lane.
    static constexpr uint32_t iota[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
    offsets += sk_unaligned_load<U32>(iota);
 
    // Use gather to perform indirect lookups; write the results into `dst`.
    const int* src = ctx->src;
    I32*       dst = (I32*)ctx->dst;
    I32*       end = dst + ctx->slots;
    do {
        *dst = gather(src, offsets);
        dst += 1;
        src += N;
    } while (dst != end);
}

STAGE_TAIL() [21/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_immutable_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4155 of file SkRasterPipeline_opts.h.

                                                                          {
    copy_n_immutable_unmasked_fn<1>(packed, base);
}

STAGE_TAIL() [22/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_slot_masked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4180 of file SkRasterPipeline_opts.h.

                                                                   {
    copy_n_slots_masked_fn<1>(packed, base, execution_mask());
}

STAGE_TAIL() [23/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_slot_unmasked	,
		SkRasterPipeline_BinaryOpCtx *	packed
	)

Definition at line 4125 of file SkRasterPipeline_opts.h.

                                                                     {
    copy_n_slots_unmasked_fn<1>(packed, base);
}

STAGE_TAIL() [24/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_to_indirect_masked	,
		SkRasterPipeline_CopyIndirectCtx *	ctx
	)

Definition at line 4311 of file SkRasterPipeline_opts.h.

                                                                           {
    // Clamp the indirect offsets to stay within the limit.
    U32 offsets = *(const U32*)ctx->indirectOffset;
    offsets = min(offsets, U32_(ctx->indirectLimit));
 
    // Scale up the offsets to account for the N lanes per value.
    offsets *= N;
 
    // Adjust the offsets forward so that they store into the correct lane.
    static constexpr uint32_t iota[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
    offsets += sk_unaligned_load<U32>(iota);
 
    // Perform indirect, masked writes into `dst`.
    const I32* src = (const I32*)ctx->src;
    const I32* end = src + ctx->slots;
    int*       dst = ctx->dst;
    I32        mask = execution_mask();
    do {
        scatter_masked(*src, dst, offsets, mask);
        dst += N;
        src += 1;
    } while (src != end);
}

STAGE_TAIL() [25/75]

SK_OPTS_NS::STAGE_TAIL	(	copy_uniform	,
		SkRasterPipeline_UniformCtx *	ctx
	)

Definition at line 4065 of file SkRasterPipeline_opts.h.

                                                           {
    const int* src = ctx->src;
    I32* dst = (I32*)ctx->dst;
    dst[0] = I32_(src[0]);
}

STAGE_TAIL() [26/75]

SK_OPTS_NS::STAGE_TAIL	(	cos_float	,
		F *	dst
	)

Definition at line 4446 of file SkRasterPipeline_opts.h.

{ *dst = cos_(*dst); }

STAGE_TAIL() [27/75]

SK_OPTS_NS::STAGE_TAIL	(	dot_3_floats	,
		F *	dst
	)

Definition at line 4769 of file SkRasterPipeline_opts.h.

                                 {
    dst[0] = mad(dst[0],  dst[3],
             mad(dst[1],  dst[4],
                 dst[2] * dst[5]));
}

STAGE_TAIL() [28/75]

SK_OPTS_NS::STAGE_TAIL	(	dot_4_floats	,
		F *	dst
	)

Definition at line 4775 of file SkRasterPipeline_opts.h.

                                 {
    dst[0] = mad(dst[0],  dst[4],
             mad(dst[1],  dst[5],
             mad(dst[2],  dst[6],
                 dst[3] * dst[7])));
}

STAGE_TAIL() [29/75]

SK_OPTS_NS::STAGE_TAIL	(	exchange_src	,
		F *	rgba
	)

Definition at line 3875 of file SkRasterPipeline_opts.h.

                                  {
    // Swaps r,g,b,a registers with the values at `rgba`.
    F temp[4] = {r, g, b, a};
    r = rgba[0];
    rgba[0] = temp[0];
    g = rgba[1];
    rgba[1] = temp[1];
    b = rgba[2];
    rgba[2] = temp[2];
    a = rgba[3];
    rgba[3] = temp[3];
}

STAGE_TAIL() [30/75]

SK_OPTS_NS::STAGE_TAIL	(	exp2_float	,
		F *	dst
	)

Definition at line 4453 of file SkRasterPipeline_opts.h.

{ *dst = approx_pow2(*dst); }

STAGE_TAIL() [31/75]

SK_OPTS_NS::STAGE_TAIL	(	exp_float	,
		F *	dst
	)

Definition at line 4452 of file SkRasterPipeline_opts.h.

{ *dst = approx_exp(*dst); }

STAGE_TAIL() [32/75]

SK_OPTS_NS::STAGE_TAIL	(	init_lane_masks	,
		SkRasterPipeline_InitLaneMasksCtx *	ctx
	)

Definition at line 3852 of file SkRasterPipeline_opts.h.

                                                                    {
    uint32_t iota[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
 
    I32 mask = cond_to_mask(sk_unaligned_load<U32>(iota) < *ctx->tail);
    r = g = b = a = sk_bit_cast<F>(mask);
}

STAGE_TAIL() [33/75]

SK_OPTS_NS::STAGE_TAIL	(	inverse_mat2	,
		F *	dst
	)

Definition at line 4457 of file SkRasterPipeline_opts.h.

                                 {
    F a00 = dst[0], a01 = dst[1],
      a10 = dst[2], a11 = dst[3];
    F det = nmad(a01, a10, a00 * a11),
      invdet = rcp_precise(det);
    dst[0] =  invdet * a11;
    dst[1] = -invdet * a01;
    dst[2] = -invdet * a10;
    dst[3] =  invdet * a00;
}

STAGE_TAIL() [34/75]

SK_OPTS_NS::STAGE_TAIL	(	inverse_mat3	,
		F *	dst
	)

Definition at line 4468 of file SkRasterPipeline_opts.h.

                                 {
    F a00 = dst[0], a01 = dst[1], a02 = dst[2],
      a10 = dst[3], a11 = dst[4], a12 = dst[5],
      a20 = dst[6], a21 = dst[7], a22 = dst[8];
    F b01 = nmad(a12, a21, a22 * a11),
      b11 = nmad(a22, a10, a12 * a20),
      b21 = nmad(a11, a20, a21 * a10);
    F det = mad(a00, b01, mad(a01, b11, a02 * b21)),
      invdet = rcp_precise(det);
    dst[0] = invdet * b01;
    dst[1] = invdet * nmad(a22, a01, a02 * a21);
    dst[2] = invdet * nmad(a02, a11, a12 * a01);
    dst[3] = invdet * b11;
    dst[4] = invdet * nmad(a02, a20, a22 * a00);
    dst[5] = invdet * nmad(a12, a00, a02 * a10);
    dst[6] = invdet * b21;
    dst[7] = invdet * nmad(a21, a00, a01 * a20);
    dst[8] = invdet * nmad(a01, a10, a11 * a00);
}

STAGE_TAIL() [35/75]

SK_OPTS_NS::STAGE_TAIL	(	inverse_mat4	,
		F *	dst
	)

Definition at line 4488 of file SkRasterPipeline_opts.h.

                                 {
    F a00 = dst[0],  a01 = dst[1],  a02 = dst[2],  a03 = dst[3],
      a10 = dst[4],  a11 = dst[5],  a12 = dst[6],  a13 = dst[7],
      a20 = dst[8],  a21 = dst[9],  a22 = dst[10], a23 = dst[11],
      a30 = dst[12], a31 = dst[13], a32 = dst[14], a33 = dst[15];
    F b00 = nmad(a01, a10, a00 * a11),
      b01 = nmad(a02, a10, a00 * a12),
      b02 = nmad(a03, a10, a00 * a13),
      b03 = nmad(a02, a11, a01 * a12),
      b04 = nmad(a03, a11, a01 * a13),
      b05 = nmad(a03, a12, a02 * a13),
      b06 = nmad(a21, a30, a20 * a31),
      b07 = nmad(a22, a30, a20 * a32),
      b08 = nmad(a23, a30, a20 * a33),
      b09 = nmad(a22, a31, a21 * a32),
      b10 = nmad(a23, a31, a21 * a33),
      b11 = nmad(a23, a32, a22 * a33),
      det = mad(b00, b11, b05 * b06) + mad(b02, b09, b03 * b08) - mad(b01, b10, b04 * b07),
      invdet = rcp_precise(det);
    b00 *= invdet;
    b01 *= invdet;
    b02 *= invdet;
    b03 *= invdet;
    b04 *= invdet;
    b05 *= invdet;
    b06 *= invdet;
    b07 *= invdet;
    b08 *= invdet;
    b09 *= invdet;
    b10 *= invdet;
    b11 *= invdet;
    dst[0]  =  mad(a13, b09, nmad(a12, b10, a11*b11));
    dst[1]  = nmad(a03, b09, nmad(a01, b11, a02*b10));
    dst[2]  =  mad(a33, b03, nmad(a32, b04, a31*b05));
    dst[3]  = nmad(a23, b03, nmad(a21, b05, a22*b04));
    dst[4]  = nmad(a13, b07, nmad(a10, b11, a12*b08));
    dst[5]  =  mad(a03, b07, nmad(a02, b08, a00*b11));
    dst[6]  = nmad(a33, b01, nmad(a30, b05, a32*b02));
    dst[7]  =  mad(a23, b01, nmad(a22, b02, a20*b05));
    dst[8]  =  mad(a13, b06, nmad(a11, b08, a10*b10));
    dst[9]  = nmad(a03, b06, nmad(a00, b10, a01*b08));
    dst[10] =  mad(a33, b00, nmad(a31, b02, a30*b04));
    dst[11] = nmad(a23, b00, nmad(a20, b04, a21*b02));
    dst[12] = nmad(a12, b06, nmad(a10, b09, a11*b07));
    dst[13] =  mad(a02, b06, nmad(a01, b07, a00*b09));
    dst[14] = nmad(a32, b00, nmad(a30, b03, a31*b01));
    dst[15] =  mad(a22, b00, nmad(a21, b01, a20*b03));
}

STAGE_TAIL() [36/75]

SK_OPTS_NS::STAGE_TAIL	(	load_condition_mask	,
		F *	ctx
	)

Definition at line 3888 of file SkRasterPipeline_opts.h.

                                        {
    r = sk_unaligned_load<F>(ctx);
    update_execution_mask();
}

STAGE_TAIL() [37/75]

SK_OPTS_NS::STAGE_TAIL	(	load_loop_mask	,
		F *	ctx
	)

Definition at line 3909 of file SkRasterPipeline_opts.h.

                                   {
    g = sk_unaligned_load<F>(ctx);
    update_execution_mask();
}

STAGE_TAIL() [38/75]

SK_OPTS_NS::STAGE_TAIL	(	load_return_mask	,
		F *	ctx
	)

Definition at line 3963 of file SkRasterPipeline_opts.h.

                                     {
    b = sk_unaligned_load<F>(ctx);
    update_execution_mask();
}

STAGE_TAIL() [39/75]

SK_OPTS_NS::STAGE_TAIL	(	log2_float	,
		F *	dst
	)

Definition at line 4455 of file SkRasterPipeline_opts.h.

{ *dst = approx_log2(*dst); }

STAGE_TAIL() [40/75]

SK_OPTS_NS::STAGE_TAIL	(	log_float	,
		F *	dst
	)

Definition at line 4454 of file SkRasterPipeline_opts.h.

{ *dst = approx_log(*dst); }

STAGE_TAIL() [41/75]

SK_OPTS_NS::STAGE_TAIL	(	mask_off_loop_mask	,
		NoCtx
	)

Definition at line 3918 of file SkRasterPipeline_opts.h.

                                      {
    // We encountered a break statement. If a lane was active, it should be masked off now, and stay
    // masked-off until the termination of the loop.
    g = sk_bit_cast<F>(sk_bit_cast<I32>(g) & ~execution_mask());
    update_execution_mask();
}

STAGE_TAIL() [42/75]

SK_OPTS_NS::STAGE_TAIL	(	mask_off_return_mask	,
		NoCtx
	)

Definition at line 3972 of file SkRasterPipeline_opts.h.

                                        {
    // We encountered a return statement. If a lane was active, it should be masked off now, and
    // stay masked-off until the end of the function.
    b = sk_bit_cast<F>(sk_bit_cast<I32>(b) & ~execution_mask());
    update_execution_mask();
}

STAGE_TAIL() [43/75]

SK_OPTS_NS::STAGE_TAIL	(	matrix_multiply_2	,
		SkRasterPipeline_MatrixMultiplyCtx *	packed
	)

Definition at line 4831 of file SkRasterPipeline_opts.h.

                                                                          {
    matrix_multiply<2>(packed, base);
}

STAGE_TAIL() [44/75]

SK_OPTS_NS::STAGE_TAIL	(	matrix_multiply_3	,
		SkRasterPipeline_MatrixMultiplyCtx *	packed
	)

Definition at line 4835 of file SkRasterPipeline_opts.h.

                                                                          {
    matrix_multiply<3>(packed, base);
}

STAGE_TAIL() [45/75]

SK_OPTS_NS::STAGE_TAIL	(	matrix_multiply_4	,
		SkRasterPipeline_MatrixMultiplyCtx *	packed
	)

Definition at line 4839 of file SkRasterPipeline_opts.h.

                                                                          {
    matrix_multiply<4>(packed, base);
}

STAGE_TAIL() [46/75]

SK_OPTS_NS::STAGE_TAIL	(	merge_condition_mask	,
		I32 *	ptr
	)

Definition at line 3897 of file SkRasterPipeline_opts.h.

                                           {
    // Set the condition-mask to the intersection of two adjacent masks at the pointer.
    r = sk_bit_cast<F>(ptr[0] & ptr[1]);
    update_execution_mask();
}

STAGE_TAIL() [47/75]

SK_OPTS_NS::STAGE_TAIL	(	merge_inv_condition_mask	,
		I32 *	ptr
	)

Definition at line 3903 of file SkRasterPipeline_opts.h.

                                               {
    // Set the condition-mask to the intersection of the first mask and the inverse of the second.
    r = sk_bit_cast<F>(ptr[0] & ~ptr[1]);
    update_execution_mask();
}

STAGE_TAIL() [48/75]

SK_OPTS_NS::STAGE_TAIL	(	merge_loop_mask	,
		I32 *	ptr
	)

Definition at line 3931 of file SkRasterPipeline_opts.h.

                                      {
    // Set the loop-mask to the intersection of the current loop-mask with the mask at the pointer.
    // (Note: this behavior subtly differs from merge_condition_mask!)
    g = sk_bit_cast<F>(sk_bit_cast<I32>(g) & ptr[0]);
    update_execution_mask();
}

STAGE_TAIL() [49/75]

SK_OPTS_NS::STAGE_TAIL	(	reenable_loop_mask	,
		I32 *	ptr
	)

Definition at line 3925 of file SkRasterPipeline_opts.h.

                                         {
    // Set the loop-mask to the union of the current loop-mask with the mask at the pointer.
    g = sk_bit_cast<F>(sk_bit_cast<I32>(g) | ptr[0]);
    update_execution_mask();
}

STAGE_TAIL() [50/75]

SK_OPTS_NS::STAGE_TAIL	(	refract_4_floats	,
		F *	dst
	)

Definition at line 4845 of file SkRasterPipeline_opts.h.

                                     {
    // Algorithm adapted from https://registry.khronos.org/OpenGL-Refpages/gl4/html/refract.xhtml
    F *incident = dst + 0;
    F *normal = dst + 4;
    F eta = dst[8];
 
    F dotNI = mad(normal[0],  incident[0],
              mad(normal[1],  incident[1],
              mad(normal[2],  incident[2],
                  normal[3] * incident[3])));
 
    F k = 1.0 - eta * eta * (1.0 - dotNI * dotNI);
    F sqrt_k = sqrt_(k);
 
    for (int idx = 0; idx < 4; ++idx) {
        dst[idx] = if_then_else(k >= 0,
                                eta * incident[idx] - (eta * dotNI + sqrt_k) * normal[idx],
                                0.0);
    }
}

STAGE_TAIL() [51/75]

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

Definition at line 3837 of file SkRasterPipeline_opts.h.

                                         {
    base = p;
}

STAGE_TAIL() [52/75]

SK_OPTS_NS::STAGE_TAIL	(	shuffle	,
		SkRasterPipeline_ShuffleCtx *	ctx
	)

Definition at line 4243 of file SkRasterPipeline_opts.h.

                                                      {
    shuffle_fn<16>((std::byte*)ctx->ptr, ctx->offsets, ctx->count);
}

STAGE_TAIL() [53/75]

SK_OPTS_NS::STAGE_TAIL	(	splat_2_constants	,
		SkRasterPipeline_ConstantCtx *	packed
	)

Definition at line 4098 of file SkRasterPipeline_opts.h.

                                                                    {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    I32* dst = (I32*)(base + ctx.dst);
    I32 value = I32_(ctx.value);
    dst[0] = dst[1] = value;
}

STAGE_TAIL() [54/75]

SK_OPTS_NS::STAGE_TAIL	(	splat_3_constants	,
		SkRasterPipeline_ConstantCtx *	packed
	)

Definition at line 4104 of file SkRasterPipeline_opts.h.

                                                                    {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    I32* dst = (I32*)(base + ctx.dst);
    I32 value = I32_(ctx.value);
    dst[0] = dst[1] = dst[2] = value;
}

STAGE_TAIL() [55/75]

SK_OPTS_NS::STAGE_TAIL	(	splat_4_constants	,
		SkRasterPipeline_ConstantCtx *	packed
	)

Definition at line 4110 of file SkRasterPipeline_opts.h.

                                                                    {
    auto ctx = SkRPCtxUtils::Unpack(packed);
    I32* dst = (I32*)(base + ctx.dst);
    I32 value = I32_(ctx.value);
    dst[0] = dst[1] = dst[2] = dst[3] = value;
}

STAGE_TAIL() [56/75]

SK_OPTS_NS::STAGE_TAIL	(	sqrt_float	,
		F *	dst
	)

Definition at line 4451 of file SkRasterPipeline_opts.h.

{ *dst = sqrt_(*dst); }

STAGE_TAIL() [57/75]

SK_OPTS_NS::STAGE_TAIL	(	store_condition_mask	,
		F *	ctx
	)

Definition at line 3893 of file SkRasterPipeline_opts.h.

                                         {
    sk_unaligned_store(ctx, r);
}

STAGE_TAIL() [58/75]

SK_OPTS_NS::STAGE_TAIL	(	store_device_xy01	,
		F *	dst
	)

Definition at line 3860 of file SkRasterPipeline_opts.h.

                                      {
    // This is very similar to `seed_shader + store_src`, but b/a are backwards.
    // (sk_FragCoord actually puts w=1 in the w slot.)
    static constexpr float iota[] = {
        0.5f, 1.5f, 2.5f, 3.5f, 4.5f, 5.5f, 6.5f, 7.5f,
        8.5f, 9.5f,10.5f,11.5f,12.5f,13.5f,14.5f,15.5f,
    };
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
 
    dst[0] = cast(U32_(dx)) + sk_unaligned_load<F>(iota);
    dst[1] = cast(U32_(dy)) + 0.5f;
    dst[2] = F0;
    dst[3] = F1;
}

STAGE_TAIL() [59/75]

SK_OPTS_NS::STAGE_TAIL	(	store_loop_mask	,
		F *	ctx
	)

Definition at line 3914 of file SkRasterPipeline_opts.h.

                                    {
    sk_unaligned_store(ctx, g);
}

STAGE_TAIL() [60/75]

SK_OPTS_NS::STAGE_TAIL	(	store_return_mask	,
		F *	ctx
	)

Definition at line 3968 of file SkRasterPipeline_opts.h.

                                      {
    sk_unaligned_store(ctx, b);
}

STAGE_TAIL() [61/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_1	,
		SkRasterPipeline_SwizzleCtx *	packed
	)

Definition at line 4231 of file SkRasterPipeline_opts.h.

                                                           {
    small_swizzle_fn<1>(packed, base);
}

STAGE_TAIL() [62/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_2	,
		SkRasterPipeline_SwizzleCtx *	packed
	)

Definition at line 4234 of file SkRasterPipeline_opts.h.

                                                           {
    small_swizzle_fn<2>(packed, base);
}

STAGE_TAIL() [63/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_3	,
		SkRasterPipeline_SwizzleCtx *	packed
	)

Definition at line 4237 of file SkRasterPipeline_opts.h.

                                                           {
    small_swizzle_fn<3>(packed, base);
}

STAGE_TAIL() [64/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_4	,
		SkRasterPipeline_SwizzleCtx *	packed
	)

Definition at line 4240 of file SkRasterPipeline_opts.h.

                                                           {
    small_swizzle_fn<4>(packed, base);
}

STAGE_TAIL() [65/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_copy_2_slots_masked	,
		SkRasterPipeline_SwizzleCopyCtx *	ctx
	)

Definition at line 4261 of file SkRasterPipeline_opts.h.

                                                                              {
    swizzle_copy_masked_fn<2>((I32*)ctx->dst, (const I32*)ctx->src, ctx->offsets, execution_mask());
}

STAGE_TAIL() [66/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_copy_3_slots_masked	,
		SkRasterPipeline_SwizzleCopyCtx *	ctx
	)

Definition at line 4264 of file SkRasterPipeline_opts.h.

                                                                              {
    swizzle_copy_masked_fn<3>((I32*)ctx->dst, (const I32*)ctx->src, ctx->offsets, execution_mask());
}

STAGE_TAIL() [67/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_copy_4_slots_masked	,
		SkRasterPipeline_SwizzleCopyCtx *	ctx
	)

Definition at line 4267 of file SkRasterPipeline_opts.h.

                                                                              {
    swizzle_copy_masked_fn<4>((I32*)ctx->dst, (const I32*)ctx->src, ctx->offsets, execution_mask());
}

STAGE_TAIL() [68/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_copy_slot_masked	,
		SkRasterPipeline_SwizzleCopyCtx *	ctx
	)

Definition at line 4258 of file SkRasterPipeline_opts.h.

                                                                           {
    swizzle_copy_masked_fn<1>((I32*)ctx->dst, (const I32*)ctx->src, ctx->offsets, execution_mask());
}

STAGE_TAIL() [69/75]

SK_OPTS_NS::STAGE_TAIL	(	swizzle_copy_to_indirect_masked	,
		SkRasterPipeline_SwizzleCopyIndirectCtx *	ctx
	)

Definition at line 4336 of file SkRasterPipeline_opts.h.

                                                                                          {
    // Clamp the indirect offsets to stay within the limit.
    U32 offsets = *(const U32*)ctx->indirectOffset;
    offsets = min(offsets, U32_(ctx->indirectLimit));
 
    // Scale up the offsets to account for the N lanes per value.
    offsets *= N;
 
    // Adjust the offsets forward so that they store into the correct lane.
    static constexpr uint32_t iota[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
    static_assert(std::size(iota) >= SkRasterPipeline_kMaxStride_highp);
    offsets += sk_unaligned_load<U32>(iota);
 
    // Perform indirect, masked, swizzled writes into `dst`.
    const I32*      src   = (const I32*)ctx->src;
    const I32*      end   = src + ctx->slots;
    std::byte*      dstB    = (std::byte*)ctx->dst;
    const uint16_t* swizzle = ctx->offsets;
    I32             mask    = execution_mask();
    do {
        int* dst = (int*)(dstB + *swizzle);
        scatter_masked(*src, dst, offsets, mask);
        swizzle += 1;
        src     += 1;
    } while (src != end);
}

STAGE_TAIL() [70/75]

SK_OPTS_NS::STAGE_TAIL	(	tan_float	,
		F *	dst
	)

Definition at line 4447 of file SkRasterPipeline_opts.h.

{ *dst = tan_(*dst); }

STAGE_TAIL() [71/75]

SK_OPTS_NS::STAGE_TAIL	(	trace_enter	,
		SkRasterPipeline_TraceFuncCtx *	ctx
	)

Definition at line 4015 of file SkRasterPipeline_opts.h.

                                                            {
    const I32* traceMask = (const I32*)ctx->traceMask;
    if (any(execution_mask() & *traceMask)) {
        ctx->traceHook->enter(ctx->funcIdx);
    }
}

STAGE_TAIL() [72/75]

SK_OPTS_NS::STAGE_TAIL	(	trace_exit	,
		SkRasterPipeline_TraceFuncCtx *	ctx
	)

Definition at line 4022 of file SkRasterPipeline_opts.h.

                                                           {
    const I32* traceMask = (const I32*)ctx->traceMask;
    if (any(execution_mask() & *traceMask)) {
        ctx->traceHook->exit(ctx->funcIdx);
    }
}

STAGE_TAIL() [73/75]

SK_OPTS_NS::STAGE_TAIL	(	trace_line	,
		SkRasterPipeline_TraceLineCtx *	ctx
	)

Definition at line 4008 of file SkRasterPipeline_opts.h.

                                                           {
    const I32* traceMask = (const I32*)ctx->traceMask;
    if (any(execution_mask() & *traceMask)) {
        ctx->traceHook->line(ctx->lineNumber);
    }
}

STAGE_TAIL() [74/75]

SK_OPTS_NS::STAGE_TAIL	(	trace_scope	,
		SkRasterPipeline_TraceScopeCtx *	ctx
	)

Definition at line 4029 of file SkRasterPipeline_opts.h.

                                                             {
    // Note that trace_scope intentionally does not incorporate the execution mask. Otherwise, the
    // scopes would become unbalanced if the execution mask changed in the middle of a block. The
    // caller is responsible for providing a combined trace- and execution-mask.
    const I32* traceMask = (const I32*)ctx->traceMask;
    if (any(*traceMask)) {
        ctx->traceHook->scope(ctx->delta);
    }
}

STAGE_TAIL() [75/75]

SK_OPTS_NS::STAGE_TAIL	(	trace_var	,
		SkRasterPipeline_TraceVarCtx *	ctx
	)

Definition at line 4039 of file SkRasterPipeline_opts.h.

                                                         {
    const I32* traceMask = (const I32*)ctx->traceMask;
    I32 mask = execution_mask() & *traceMask;
    if (any(mask)) {
        for (size_t lane = 0; lane < N; ++lane) {
            if (select_lane(mask, lane)) {
                const I32* data = (const I32*)ctx->data;
                int slotIdx = ctx->slotIdx, numSlots = ctx->numSlots;
                if (ctx->indirectOffset) {
                    // If this was an indirect store, apply the indirect-offset to the data pointer.
                    uint32_t indirectOffset = select_lane(*(const U32*)ctx->indirectOffset, lane);
                    indirectOffset = std::min<uint32_t>(indirectOffset, ctx->indirectLimit);
                    data += indirectOffset;
                    slotIdx += indirectOffset;
                }
                while (numSlots--) {
                    ctx->traceHook->var(slotIdx, select_lane(*data, lane));
                    ++slotIdx;
                    ++data;
                }
                break;
            }
        }
    }
}

start_pipeline()

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

Definition at line 1530 of file SkRasterPipeline_opts.h.

                                                 {
    uint8_t unreferencedTail;
    if (!tailPointer) {
        tailPointer = &unreferencedTail;
    }
    auto start = (Stage)program->fn;
    const size_t x0 = dx;
    std::byte* const base = nullptr;
    for (; dy < ylimit; dy++) {
    #if JUMPER_NARROW_STAGES
        Params params = { x0,dy,base, F0,F0,F0,F0 };
        while (params.dx + N <= xlimit) {
            start(&params,program, F0,F0,F0,F0);
            params.dx += N;
        }
        if (size_t tail = xlimit - params.dx) {
            *tailPointer = tail;
            patch_memory_contexts(memoryCtxPatches, params.dx, dy, tail);
            start(&params,program, F0,F0,F0,F0);
            restore_memory_contexts(memoryCtxPatches, params.dx, dy, tail);
            *tailPointer = 0xFF;
        }
    #else
        dx = x0;
        while (dx + N <= xlimit) {
            start(program,dx,dy,base, F0,F0,F0,F0, F0,F0,F0,F0);
            dx += N;
        }
        if (size_t tail = xlimit - dx) {
            *tailPointer = tail;
            patch_memory_contexts(memoryCtxPatches, dx, dy, tail);
            start(program,dx,dy,base, F0,F0,F0,F0, F0,F0,F0,F0);
            restore_memory_contexts(memoryCtxPatches, dx, dy, tail);
            *tailPointer = 0xFF;
        }
    #endif
    }
}

store()

template<typename V , typename T >

SI void SK_OPTS_NS::store	(	T *	dst,
		V	v
	)

Definition at line 1746 of file SkRasterPipeline_opts.h.

                           {
    sk_unaligned_store(dst, v);
}

store2()

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

Definition at line 182 of file SkRasterPipeline_opts.h.

                                                {
        ptr[0] = r;
        ptr[1] = g;
    }

store4() [1/2]

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

Definition at line 205 of file SkRasterPipeline_opts.h.

                                                   {
        ptr[0] = r;
        ptr[1] = g;
        ptr[2] = b;
        ptr[3] = a;
    }

store4() [2/2]

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

Definition at line 192 of file SkRasterPipeline_opts.h.

                                                              {
        ptr[0] = r;
        ptr[1] = g;
        ptr[2] = b;
        ptr[3] = a;
    }

strip_sign()

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

Definition at line 2719 of file SkRasterPipeline_opts.h.

                                {
    U32 bits = sk_bit_cast<U32>(x);
    *sign = bits & 0x80000000;
    return sk_bit_cast<F>(bits ^ *sign);
}

sub_fn()

template<typename T >

SI void SK_OPTS_NS::sub_fn	(	T *	dst,
		T *	src
	)

Definition at line 4574 of file SkRasterPipeline_opts.h.

                               {
    *dst -= *src;
}

swizzle_copy_masked_fn()

template<int NumSlots>

SI void SK_OPTS_NS::swizzle_copy_masked_fn	(	I32 *	dst,
		const I32 *	src,
		uint16_t *	offsets,
		I32	mask
	)

Definition at line 4248 of file SkRasterPipeline_opts.h.

                                                                                      {
    std::byte* dstB = (std::byte*)dst;
    SK_UNROLL for (int count = 0; count < NumSlots; ++count) {
        I32* dstS = (I32*)(dstB + *offsets);
        *dstS = if_then_else(mask, *src, *dstS);
        offsets += 1;
        src     += 1;
    }
}

tan_()

SI F SK_OPTS_NS::tan_

(

F

x

)

Definition at line 1885 of file SkRasterPipeline_opts.h.

               {
    constexpr float Pi = SK_FloatPI;
    // periodic between -pi/2 ... pi/2
    // shift to 0...Pi, scale 1/Pi to get into 0...1, then fract, scale-up, shift-back
    x = mad(fract(mad(x, 1/Pi, 0.5f)), Pi, -Pi/2);
 
    I32 neg = (x < 0.0f);
    x = if_then_else(neg, -x, x);
 
    // minimize total error by shifting if x > pi/8
    I32 use_quotient = (x > (Pi/8));
    x = if_then_else(use_quotient, x - (Pi/4), x);
 
    // 9th order poly = 4th order(x^2) * x
    const float c4 = 62 / 2835.0f;
    const float c3 = 17 / 315.0f;
    const float c2 = 2 / 15.0f;
    const float c1 = 1 / 3.0f;
    const float c0 = 1.0f;
    F x2 = x * x;
    x *= mad(x2, mad(x2, mad(x2, mad(x2, c4, c3), c2), c1), c0);
    x = if_then_else(use_quotient, (1+x)/(1-x), x);
    x = if_then_else(neg, -x, x);
    return x;
}

to_half()

SI U16 SK_OPTS_NS::to_half

(

F

f

)

Definition at line 1422 of file SkRasterPipeline_opts.h.

                    {
#if defined(JUMPER_IS_NEON) && defined(SK_CPU_ARM64)
    return (U16)vcvt_f16_f32(f);
 
#elif defined(JUMPER_IS_SKX)
    return (U16)_mm512_cvtps_ph(f, _MM_FROUND_CUR_DIRECTION);
 
#elif defined(JUMPER_IS_HSW)
    return (U16)_mm256_cvtps_ph(f, _MM_FROUND_CUR_DIRECTION);
 
#else
    // Remember, a float is 1-8-23 (sign-exponent-mantissa) with 127 exponent bias.
    U32 sem = sk_bit_cast<U32>(f),
        s   = sem & 0x80000000,
         em = sem ^ s;
 
    // Convert to 1-5-10 half with 15 bias, flushing denorm halfs (including zero) to zero.
    auto denorm = (I32)em < 0x38800000;  // I32 comparison is often quicker, and always safe here.
    return pack((U32)if_then_else(denorm, I32_(0)
                                        , (I32)((s>>16) + (em>>13) - ((127-15)<<10))));
#endif
}

to_unorm()

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

Definition at line 2005 of file SkRasterPipeline_opts.h.

                                                     {
    // Any time we use round() we probably want to use to_unorm().
    return round(min(max(0.0f, v), bias), F_(scale));
}

trunc_()

SI U32 SK_OPTS_NS::trunc_

(

F

v

)

Definition at line 1339 of file SkRasterPipeline_opts.h.

{ return (U32)v; }

two()

SI F SK_OPTS_NS::two

(

F

x

)

Definition at line 2172 of file SkRasterPipeline_opts.h.

{ return x + x; }

U32_()

SI constexpr U32 SK_OPTS_NS::U32_ ( uint32_t  x )

constexpr

Definition at line 1301 of file SkRasterPipeline_opts.h.

{ return x; }

Variable Documentation

dst

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

Definition at line 4445 of file SkRasterPipeline_opts.h.

F0

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

staticconstexpr

Definition at line 1309 of file SkRasterPipeline_opts.h.

F1

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

static

Definition at line 1310 of file SkRasterPipeline_opts.h.

N

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

staticconstexpr

Definition at line 1491 of file SkRasterPipeline_opts.h.

S32_alpha_D32_filter_DXDY

constexpr void(* SK_OPTS_NS::S32_alpha_D32_filter_DXDY) (const SkBitmapProcState &, const uint32_t *, int, SkPMColor *) ( const SkBitmapProcState &  , const uint32_t *  , int  , SkPMColor *    ) = nullptr

staticconstexpr

Definition at line 574 of file SkBitmapProcState_opts.h.