/* * Copyright 2016 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #ifndef SkRasterPipeline_DEFINED #define SkRasterPipeline_DEFINED #include "SkArenaAlloc.h" #include "SkColor.h" #include "SkImageInfo.h" #include "SkNx.h" #include "SkTArray.h" // TODO: unused #include "SkTypes.h" #include <functional> #include <vector> // TODO: unused /** * SkRasterPipeline provides a cheap way to chain together a pixel processing pipeline. * * It's particularly designed for situations where the potential pipeline is extremely * combinatoric: {N dst formats} x {M source formats} x {K mask formats} x {C transfer modes} ... * No one wants to write specialized routines for all those combinations, and if we did, we'd * end up bloating our code size dramatically. SkRasterPipeline stages can be chained together * at runtime, so we can scale this problem linearly rather than combinatorically. * * Each stage is represented by a function conforming to a common interface and by an * arbitrary context pointer. The stage funciton arguments and calling convention are * designed to maximize the amount of data we can pass along the pipeline cheaply, and * vary depending on CPU feature detection. */ #define SK_RASTER_PIPELINE_STAGES(M) \ M(callback) \ M(move_src_dst) M(move_dst_src) \ M(clamp_0) M(clamp_1) M(clamp_a) M(clamp_a_dst) M(clamp_gamut) \ M(unpremul) M(premul) M(premul_dst) \ M(force_opaque) M(force_opaque_dst) \ M(set_rgb) M(unbounded_set_rgb) M(swap_rb) M(swap_rb_dst) \ M(from_srgb) M(to_srgb) \ M(black_color) M(white_color) M(uniform_color) M(unbounded_uniform_color) \ M(seed_shader) M(dither) \ M(load_a8) M(load_a8_dst) M(store_a8) M(gather_a8) \ M(load_565) M(load_565_dst) M(store_565) M(gather_565) \ M(load_4444) M(load_4444_dst) M(store_4444) M(gather_4444) \ M(load_f16) M(load_f16_dst) M(store_f16) M(gather_f16) \ M(load_f32) M(load_f32_dst) M(store_f32) M(gather_f32) \ M(load_8888) M(load_8888_dst) M(store_8888) M(gather_8888) \ M(load_1010102) M(load_1010102_dst) M(store_1010102) M(gather_1010102) \ M(alpha_to_gray) M(alpha_to_gray_dst) M(luminance_to_alpha) \ M(bilerp_clamp_8888) \ M(store_u16_be) \ M(load_src) M(store_src) M(load_dst) M(store_dst) \ M(scale_u8) M(scale_565) M(scale_1_float) \ M( lerp_u8) M( lerp_565) M( lerp_1_float) \ M(dstatop) M(dstin) M(dstout) M(dstover) \ M(srcatop) M(srcin) M(srcout) M(srcover) \ M(clear) M(modulate) M(multiply) M(plus_) M(screen) M(xor_) \ M(colorburn) M(colordodge) M(darken) M(difference) \ M(exclusion) M(hardlight) M(lighten) M(overlay) M(softlight) \ M(hue) M(saturation) M(color) M(luminosity) \ M(srcover_rgba_8888) \ M(matrix_translate) M(matrix_scale_translate) \ M(matrix_2x3) M(matrix_3x3) M(matrix_3x4) M(matrix_4x5) M(matrix_4x3) \ M(matrix_perspective) \ M(parametric) M(gamma) \ M(mirror_x) M(repeat_x) \ M(mirror_y) M(repeat_y) \ M(decal_x) M(decal_y) M(decal_x_and_y) \ M(check_decal_mask) \ M(negate_x) \ M(bilinear_nx) M(bilinear_px) M(bilinear_ny) M(bilinear_py) \ M(bicubic_n3x) M(bicubic_n1x) M(bicubic_p1x) M(bicubic_p3x) \ M(bicubic_n3y) M(bicubic_n1y) M(bicubic_p1y) M(bicubic_p3y) \ M(save_xy) M(accumulate) \ M(clamp_x_1) M(mirror_x_1) M(repeat_x_1) \ M(evenly_spaced_gradient) \ M(gradient) \ M(evenly_spaced_2_stop_gradient) \ M(xy_to_unit_angle) \ M(xy_to_radius) \ M(xy_to_2pt_conical_strip) \ M(xy_to_2pt_conical_focal_on_circle) \ M(xy_to_2pt_conical_well_behaved) \ M(xy_to_2pt_conical_smaller) \ M(xy_to_2pt_conical_greater) \ M(alter_2pt_conical_compensate_focal) \ M(alter_2pt_conical_unswap) \ M(mask_2pt_conical_nan) \ M(mask_2pt_conical_degenerates) M(apply_vector_mask) \ M(byte_tables) \ M(rgb_to_hsl) M(hsl_to_rgb) \ M(gauss_a_to_rgba) \ M(emboss) // The largest number of pixels we handle at a time. static const int SkRasterPipeline_kMaxStride = 16; // Structs representing the arguments to some common stages. struct SkRasterPipeline_MemoryCtx { void* pixels; int stride; }; struct SkRasterPipeline_GatherCtx { const void* pixels; int stride; float width; float height; }; // State shared by save_xy, accumulate, and bilinear_* / bicubic_*. struct SkRasterPipeline_SamplerCtx { float x[SkRasterPipeline_kMaxStride]; float y[SkRasterPipeline_kMaxStride]; float fx[SkRasterPipeline_kMaxStride]; float fy[SkRasterPipeline_kMaxStride]; float scalex[SkRasterPipeline_kMaxStride]; float scaley[SkRasterPipeline_kMaxStride]; }; struct SkRasterPipeline_TileCtx { float scale; float invScale; // cache of 1/scale }; struct SkRasterPipeline_DecalTileCtx { uint32_t mask[SkRasterPipeline_kMaxStride]; float limit_x; float limit_y; }; struct SkRasterPipeline_CallbackCtx { void (*fn)(SkRasterPipeline_CallbackCtx* self, int active_pixels/*<= SkRasterPipeline_kMaxStride*/); // When called, fn() will have our active pixels available in rgba. // When fn() returns, the pipeline will read back those active pixels from read_from. float rgba[4*SkRasterPipeline_kMaxStride]; float* read_from = rgba; }; struct SkRasterPipeline_GradientCtx { size_t stopCount; float* fs[4]; float* bs[4]; float* ts; bool interpolatedInPremul; }; struct SkRasterPipeline_EvenlySpaced2StopGradientCtx { float f[4]; float b[4]; bool interpolatedInPremul; }; struct SkRasterPipeline_2PtConicalCtx { uint32_t fMask[SkRasterPipeline_kMaxStride]; float fP0, fP1; }; struct SkRasterPipeline_UniformColorCtx { float r,g,b,a; uint16_t rgba[4]; // [0,255] in a 16-bit lane. }; struct SkRasterPipeline_EmbossCtx { SkRasterPipeline_MemoryCtx mul, add; }; class SkRasterPipeline { public: explicit SkRasterPipeline(SkArenaAlloc*); SkRasterPipeline(const SkRasterPipeline&) = delete; SkRasterPipeline(SkRasterPipeline&&) = default; SkRasterPipeline& operator=(const SkRasterPipeline&) = delete; SkRasterPipeline& operator=(SkRasterPipeline&&) = default; void reset(); enum StockStage { #define M(stage) stage, SK_RASTER_PIPELINE_STAGES(M) #undef M }; void append(StockStage, void* = nullptr); void append(StockStage stage, const void* ctx) { this->append(stage, const_cast<void*>(ctx)); } // For raw functions (i.e. from a JIT). Don't use this unless you know exactly what fn needs to // be. :) void append(void* fn, void* ctx); // Append all stages to this pipeline. void extend(const SkRasterPipeline&); // Runs the pipeline in 2d from (x,y) inclusive to (x+w,y+h) exclusive. void run(size_t x, size_t y, size_t w, size_t h) const; // Allocates a thunk which amortizes run() setup cost in alloc. std::function<void(size_t, size_t, size_t, size_t)> compile() const; void dump() const; // Appends a stage for the specified matrix. // Tries to optimize the stage by analyzing the type of matrix. void append_matrix(SkArenaAlloc*, const SkMatrix&); // Appends a stage for a constant uniform color. // Tries to optimize the stage based on the color. void append_constant_color(SkArenaAlloc*, const float rgba[4]); void append_constant_color(SkArenaAlloc* alloc, const SkColor4f& color) { this->append_constant_color(alloc, color.vec()); } // Like append_constant_color() but only affecting r,g,b, ignoring the alpha channel. void append_set_rgb(SkArenaAlloc*, const float rgb[3]); void append_set_rgb(SkArenaAlloc* alloc, const SkColor4f& color) { this->append_set_rgb(alloc, color.vec()); } void append_load (SkColorType, const SkRasterPipeline_MemoryCtx*); void append_load_dst(SkColorType, const SkRasterPipeline_MemoryCtx*); void append_store (SkColorType, const SkRasterPipeline_MemoryCtx*); void append_gamut_clamp_if_normalized(const SkImageInfo&); bool empty() const { return fStages == nullptr; } private: struct StageList { StageList* prev; uint64_t stage; void* ctx; bool rawFunction; }; using StartPipelineFn = void(*)(size_t,size_t,size_t,size_t, void** program); StartPipelineFn build_pipeline(void**) const; void unchecked_append(StockStage, void*); // Used by old single-program void** style execution. SkArenaAlloc* fAlloc; StageList* fStages; int fNumStages; int fSlotsNeeded; }; template <size_t bytes> class SkRasterPipeline_ : public SkRasterPipeline { public: SkRasterPipeline_() : SkRasterPipeline(&fBuiltinAlloc) {} private: SkSTArenaAlloc<bytes> fBuiltinAlloc; }; #endif//SkRasterPipeline_DEFINED