SkRasterPipeline Class Reference

#include <SkRasterPipeline.h>

Inheritance diagram for SkRasterPipeline:

Classes
struct	StageList

Public Member Functions
	SkRasterPipeline (SkArenaAlloc *)
	SkRasterPipeline (const SkRasterPipeline &)=delete
	SkRasterPipeline (SkRasterPipeline &&)=default
SkRasterPipeline &	operator= (const SkRasterPipeline &)=delete
SkRasterPipeline &	operator= (SkRasterPipeline &&)=default
void	reset ()
void	append (SkRasterPipelineOp, void *=nullptr)
void	append (SkRasterPipelineOp op, const void *ctx)
void	append (SkRasterPipelineOp, uintptr_t ctx)
void	extend (const SkRasterPipeline &)
void	run (size_t x, size_t y, size_t w, size_t h) const
std::function< void(size_t, size_t, size_t, size_t)>	compile () const
const StageList *	getStageList () const
int	getNumStages () const
void	dump () const
void	appendMatrix (SkArenaAlloc *, const SkMatrix &)
void	appendConstantColor (SkArenaAlloc *, const float rgba[4])
void	appendConstantColor (SkArenaAlloc *alloc, const SkColor4f &color)
void	appendSetRGB (SkArenaAlloc *, const float rgb[3])
void	appendSetRGB (SkArenaAlloc *alloc, const SkColor4f &color)
void	appendLoad (SkColorType, const SkRasterPipeline_MemoryCtx *)
void	appendLoadDst (SkColorType, const SkRasterPipeline_MemoryCtx *)
void	appendStore (SkColorType, const SkRasterPipeline_MemoryCtx *)
void	appendClampIfNormalized (const SkImageInfo &)
void	appendTransferFunction (const skcms_TransferFunction &)
void	appendStackRewind ()
bool	empty () const

Static Public Member Functions
static const char *	GetOpName (SkRasterPipelineOp op)

Detailed Description

Definition at line 68 of file SkRasterPipeline.h.

Constructor & Destructor Documentation

SkRasterPipeline() [1/3]

SkRasterPipeline::SkRasterPipeline ( SkArenaAlloc *  alloc )

explicit

Definition at line 31 of file SkRasterPipeline.cpp.

                                                      : fAlloc(alloc) {
    this->reset();
}

SkRasterPipeline() [2/3]

SkRasterPipeline::SkRasterPipeline ( const SkRasterPipeline &  )

delete

SkRasterPipeline() [3/3]

SkRasterPipeline::SkRasterPipeline ( SkRasterPipeline &&  )

default

Member Function Documentation

append() [1/3]

void SkRasterPipeline::append ( SkRasterPipelineOp  op, const void *  ctx  )

inline

Definition at line 81 of file SkRasterPipeline.h.

{ this->append(op,const_cast<void*>(ctx)); }

append() [2/3]

void SkRasterPipeline::append	(	SkRasterPipelineOp	op,
		uintptr_t	ctx
	)

Definition at line 161 of file SkRasterPipeline.cpp.

                                                                  {
    void* ptrCtx;
    memcpy(&ptrCtx, &ctx, sizeof(ctx));
    this->append(op, ptrCtx);
}

append() [3/3]

void SkRasterPipeline::append	(	SkRasterPipelineOp	op,
		void *	ctx = nullptr
	)

Definition at line 44 of file SkRasterPipeline.cpp.

                                                              {
    SkASSERT(op != Op::uniform_color);            // Please use appendConstantColor().
    SkASSERT(op != Op::unbounded_uniform_color);  // Please use appendConstantColor().
    SkASSERT(op != Op::set_rgb);                  // Please use appendSetRGB().
    SkASSERT(op != Op::unbounded_set_rgb);        // Please use appendSetRGB().
    SkASSERT(op != Op::parametric);               // Please use appendTransferFunction().
    SkASSERT(op != Op::gamma_);                   // Please use appendTransferFunction().
    SkASSERT(op != Op::PQish);                    // Please use appendTransferFunction().
    SkASSERT(op != Op::HLGish);                   // Please use appendTransferFunction().
    SkASSERT(op != Op::HLGinvish);                // Please use appendTransferFunction().
    SkASSERT(op != Op::stack_checkpoint);         // Please use appendStackRewind().
    SkASSERT(op != Op::stack_rewind);             // Please use appendStackRewind().
    this->uncheckedAppend(op, ctx);
}

appendClampIfNormalized()

void SkRasterPipeline::appendClampIfNormalized

(

const SkImageInfo &

info

)

Definition at line 534 of file SkRasterPipeline.cpp.

                                                                      {
    if (SkColorTypeIsNormalized(info.colorType())) {
        this->uncheckedAppend(Op::clamp_01, nullptr);
    }
}

appendConstantColor() [1/2]

void SkRasterPipeline::appendConstantColor	(	SkArenaAlloc *	alloc,
		const float	rgba[4]
	)

Definition at line 257 of file SkRasterPipeline.cpp.

                                                                                   {
    // r,g,b might be outside [0,1], but alpha should probably always be in [0,1].
    SkASSERT(0 <= rgba[3] && rgba[3] <= 1);
 
    if (rgba[0] == 0 && rgba[1] == 0 && rgba[2] == 0 && rgba[3] == 1) {
        this->append(Op::black_color);
    } else if (rgba[0] == 1 && rgba[1] == 1 && rgba[2] == 1 && rgba[3] == 1) {
        this->append(Op::white_color);
    } else {
        auto ctx = alloc->make<SkRasterPipeline_UniformColorCtx>();
        skvx::float4 color = skvx::float4::Load(rgba);
        color.store(&ctx->r);
 
        // uniform_color requires colors in range and can go lowp,
        // while unbounded_uniform_color supports out-of-range colors too but not lowp.
        if (0 <= rgba[0] && rgba[0] <= rgba[3] &&
            0 <= rgba[1] && rgba[1] <= rgba[3] &&
            0 <= rgba[2] && rgba[2] <= rgba[3]) {
            // To make loads more direct, we store 8-bit values in 16-bit slots.
            color = color * 255.0f + 0.5f;
            ctx->rgba[0] = (uint16_t)color[0];
            ctx->rgba[1] = (uint16_t)color[1];
            ctx->rgba[2] = (uint16_t)color[2];
            ctx->rgba[3] = (uint16_t)color[3];
            this->uncheckedAppend(Op::uniform_color, ctx);
        } else {
            this->uncheckedAppend(Op::unbounded_uniform_color, ctx);
        }
    }
}

appendConstantColor() [2/2]

void SkRasterPipeline::appendConstantColor ( SkArenaAlloc *  alloc, const SkColor4f &  color  )

inline

Definition at line 115 of file SkRasterPipeline.h.

                                                                          {
        this->appendConstantColor(alloc, color.vec());
    }

appendLoad()

void SkRasterPipeline::appendLoad	(	SkColorType	ct,
		const SkRasterPipeline_MemoryCtx *	ctx
	)

Definition at line 319 of file SkRasterPipeline.cpp.

                                                                                       {
    switch (ct) {
        case kUnknown_SkColorType: SkASSERT(false); break;
 
        case kAlpha_8_SkColorType:           this->append(Op::load_a8,      ctx); break;
        case kA16_unorm_SkColorType:         this->append(Op::load_a16,     ctx); break;
        case kA16_float_SkColorType:         this->append(Op::load_af16,    ctx); break;
        case kRGB_565_SkColorType:           this->append(Op::load_565,     ctx); break;
        case kARGB_4444_SkColorType:         this->append(Op::load_4444,    ctx); break;
        case kR8G8_unorm_SkColorType:        this->append(Op::load_rg88,    ctx); break;
        case kR16G16_unorm_SkColorType:      this->append(Op::load_rg1616,  ctx); break;
        case kR16G16_float_SkColorType:      this->append(Op::load_rgf16,   ctx); break;
        case kRGBA_8888_SkColorType:         this->append(Op::load_8888,    ctx); break;
        case kRGBA_1010102_SkColorType:      this->append(Op::load_1010102, ctx); break;
        case kR16G16B16A16_unorm_SkColorType:this->append(Op::load_16161616,ctx); break;
        case kRGBA_F16Norm_SkColorType:
        case kRGBA_F16_SkColorType:          this->append(Op::load_f16,     ctx); break;
        case kRGBA_F32_SkColorType:          this->append(Op::load_f32,     ctx); break;
        case kRGBA_10x6_SkColorType:         this->append(Op::load_10x6,    ctx); break;
 
        case kGray_8_SkColorType:            this->append(Op::load_a8, ctx);
                                             this->append(Op::alpha_to_gray);
                                             break;
 
        case kR8_unorm_SkColorType:          this->append(Op::load_a8, ctx);
                                             this->append(Op::alpha_to_red);
                                             break;
 
        case kRGB_888x_SkColorType:          this->append(Op::load_8888, ctx);
                                             this->append(Op::force_opaque);
                                             break;
 
        case kBGRA_1010102_SkColorType:      this->append(Op::load_1010102, ctx);
                                             this->append(Op::swap_rb);
                                             break;
 
        case kRGB_101010x_SkColorType:       this->append(Op::load_1010102, ctx);
                                             this->append(Op::force_opaque);
                                             break;
 
        case kBGR_101010x_SkColorType:       this->append(Op::load_1010102, ctx);
                                             this->append(Op::force_opaque);
                                             this->append(Op::swap_rb);
                                             break;
 
        case kBGRA_10101010_XR_SkColorType:  this->append(Op::load_10101010_xr, ctx);
                                             this->append(Op::swap_rb);
                                             break;
 
        case kBGR_101010x_XR_SkColorType:    this->append(Op::load_1010102_xr, ctx);
                                             this->append(Op::force_opaque);
                                             this->append(Op::swap_rb);
                                             break;
 
        case kBGRA_8888_SkColorType:         this->append(Op::load_8888, ctx);
                                             this->append(Op::swap_rb);
                                             break;
 
        case kSRGBA_8888_SkColorType:
            this->append(Op::load_8888, ctx);
            this->appendTransferFunction(*skcms_sRGB_TransferFunction());
            break;
    }
}

appendLoadDst()

void SkRasterPipeline::appendLoadDst	(	SkColorType	ct,
		const SkRasterPipeline_MemoryCtx *	ctx
	)

Definition at line 384 of file SkRasterPipeline.cpp.

                                                                                          {
    switch (ct) {
        case kUnknown_SkColorType: SkASSERT(false); break;
 
        case kAlpha_8_SkColorType:            this->append(Op::load_a8_dst,      ctx); break;
        case kA16_unorm_SkColorType:          this->append(Op::load_a16_dst,     ctx); break;
        case kA16_float_SkColorType:          this->append(Op::load_af16_dst,    ctx); break;
        case kRGB_565_SkColorType:            this->append(Op::load_565_dst,     ctx); break;
        case kARGB_4444_SkColorType:          this->append(Op::load_4444_dst,    ctx); break;
        case kR8G8_unorm_SkColorType:         this->append(Op::load_rg88_dst,    ctx); break;
        case kR16G16_unorm_SkColorType:       this->append(Op::load_rg1616_dst,  ctx); break;
        case kR16G16_float_SkColorType:       this->append(Op::load_rgf16_dst,   ctx); break;
        case kRGBA_8888_SkColorType:          this->append(Op::load_8888_dst,    ctx); break;
        case kRGBA_1010102_SkColorType:       this->append(Op::load_1010102_dst, ctx); break;
        case kR16G16B16A16_unorm_SkColorType: this->append(Op::load_16161616_dst,ctx); break;
        case kRGBA_F16Norm_SkColorType:
        case kRGBA_F16_SkColorType:           this->append(Op::load_f16_dst,     ctx); break;
        case kRGBA_F32_SkColorType:           this->append(Op::load_f32_dst,     ctx); break;
        case kRGBA_10x6_SkColorType:          this->append(Op::load_10x6_dst,    ctx); break;
 
        case kGray_8_SkColorType:             this->append(Op::load_a8_dst, ctx);
                                              this->append(Op::alpha_to_gray_dst);
                                              break;
 
        case kR8_unorm_SkColorType:           this->append(Op::load_a8_dst, ctx);
                                              this->append(Op::alpha_to_red_dst);
                                              break;
 
        case kRGB_888x_SkColorType:           this->append(Op::load_8888_dst, ctx);
                                              this->append(Op::force_opaque_dst);
                                              break;
 
        case kBGRA_1010102_SkColorType:       this->append(Op::load_1010102_dst, ctx);
                                              this->append(Op::swap_rb_dst);
                                              break;
 
        case kRGB_101010x_SkColorType:        this->append(Op::load_1010102_dst, ctx);
                                              this->append(Op::force_opaque_dst);
                                              break;
 
        case kBGR_101010x_SkColorType:        this->append(Op::load_1010102_dst, ctx);
                                              this->append(Op::force_opaque_dst);
                                              this->append(Op::swap_rb_dst);
                                              break;
 
        case kBGR_101010x_XR_SkColorType:     this->append(Op::load_1010102_xr_dst, ctx);
                                              this->append(Op::force_opaque_dst);
                                              this->append(Op::swap_rb_dst);
                                              break;
 
        case kBGRA_10101010_XR_SkColorType:   this->append(Op::load_10101010_xr_dst, ctx);
                                              this->append(Op::swap_rb_dst);
                                              break;
 
        case kBGRA_8888_SkColorType:          this->append(Op::load_8888_dst, ctx);
                                              this->append(Op::swap_rb_dst);
                                              break;
 
        case kSRGBA_8888_SkColorType:
            // TODO: We could remove the double-swap if we had _dst versions of all the TF stages
            this->append(Op::load_8888_dst, ctx);
            this->append(Op::swap_src_dst);
            this->appendTransferFunction(*skcms_sRGB_TransferFunction());
            this->append(Op::swap_src_dst);
            break;
    }
}

appendMatrix()

void SkRasterPipeline::appendMatrix	(	SkArenaAlloc *	alloc,
		const SkMatrix &	matrix
	)

Definition at line 288 of file SkRasterPipeline.cpp.

                                                                               {
    SkMatrix::TypeMask mt = matrix.getType();
 
    if (mt == SkMatrix::kIdentity_Mask) {
        return;
    }
    if (mt == SkMatrix::kTranslate_Mask) {
        float* trans = alloc->makeArrayDefault<float>(2);
        trans[0] = matrix.getTranslateX();
        trans[1] = matrix.getTranslateY();
        this->append(Op::matrix_translate, trans);
    } else if ((mt | (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) ==
                     (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
        float* scaleTrans = alloc->makeArrayDefault<float>(4);
        scaleTrans[0] = matrix.getScaleX();
        scaleTrans[1] = matrix.getScaleY();
        scaleTrans[2] = matrix.getTranslateX();
        scaleTrans[3] = matrix.getTranslateY();
        this->append(Op::matrix_scale_translate, scaleTrans);
    } else {
        float* storage = alloc->makeArrayDefault<float>(9);
        matrix.get9(storage);
        if (!matrix.hasPerspective()) {
            // note: asAffine and the 2x3 stage really only need 6 entries
            this->append(Op::matrix_2x3, storage);
        } else {
            this->append(Op::matrix_perspective, storage);
        }
    }
}

appendSetRGB() [1/2]

void SkRasterPipeline::appendSetRGB	(	SkArenaAlloc *	alloc,
		const float	rgb[3]
	)

Definition at line 240 of file SkRasterPipeline.cpp.

                                                                           {
    auto arg = alloc->makeArrayDefault<float>(3);
    arg[0] = rgb[0];
    arg[1] = rgb[1];
    arg[2] = rgb[2];
 
    auto op = Op::unbounded_set_rgb;
    if (0 <= rgb[0] && rgb[0] <= 1 &&
        0 <= rgb[1] && rgb[1] <= 1 &&
        0 <= rgb[2] && rgb[2] <= 1)
    {
        op = Op::set_rgb;
    }
 
    this->uncheckedAppend(op, arg);
}

appendSetRGB() [2/2]

void SkRasterPipeline::appendSetRGB ( SkArenaAlloc *  alloc, const SkColor4f &  color  )

inline

Definition at line 122 of file SkRasterPipeline.h.

                                                                   {
        this->appendSetRGB(alloc, color.vec());
    }

appendStackRewind()

void SkRasterPipeline::appendStackRewind

(

)

Definition at line 540 of file SkRasterPipeline.cpp.

                                         {
    if (!fRewindCtx) {
        fRewindCtx = fAlloc->make<SkRasterPipeline_RewindCtx>();
    }
    this->uncheckedAppend(Op::stack_rewind, fRewindCtx);
}

appendStore()

void SkRasterPipeline::appendStore	(	SkColorType	ct,
		const SkRasterPipeline_MemoryCtx *	ctx
	)

Definition at line 452 of file SkRasterPipeline.cpp.

                                                                                        {
    switch (ct) {
        case kUnknown_SkColorType: SkASSERT(false); break;
 
        case kAlpha_8_SkColorType:            this->append(Op::store_a8,      ctx); break;
        case kR8_unorm_SkColorType:           this->append(Op::store_r8,      ctx); break;
        case kA16_unorm_SkColorType:          this->append(Op::store_a16,     ctx); break;
        case kA16_float_SkColorType:          this->append(Op::store_af16,    ctx); break;
        case kRGB_565_SkColorType:            this->append(Op::store_565,     ctx); break;
        case kARGB_4444_SkColorType:          this->append(Op::store_4444,    ctx); break;
        case kR8G8_unorm_SkColorType:         this->append(Op::store_rg88,    ctx); break;
        case kR16G16_unorm_SkColorType:       this->append(Op::store_rg1616,  ctx); break;
        case kR16G16_float_SkColorType:       this->append(Op::store_rgf16,   ctx); break;
        case kRGBA_8888_SkColorType:          this->append(Op::store_8888,    ctx); break;
        case kRGBA_1010102_SkColorType:       this->append(Op::store_1010102, ctx); break;
        case kR16G16B16A16_unorm_SkColorType: this->append(Op::store_16161616,ctx); break;
        case kRGBA_F16Norm_SkColorType:
        case kRGBA_F16_SkColorType:           this->append(Op::store_f16,     ctx); break;
        case kRGBA_F32_SkColorType:           this->append(Op::store_f32,     ctx); break;
        case kRGBA_10x6_SkColorType:          this->append(Op::store_10x6,    ctx); break;
 
        case kRGB_888x_SkColorType:           this->append(Op::force_opaque);
                                              this->append(Op::store_8888, ctx);
                                              break;
 
        case kBGRA_1010102_SkColorType:       this->append(Op::swap_rb);
                                              this->append(Op::store_1010102, ctx);
                                              break;
 
        case kRGB_101010x_SkColorType:        this->append(Op::force_opaque);
                                              this->append(Op::store_1010102, ctx);
                                              break;
 
        case kBGR_101010x_SkColorType:        this->append(Op::force_opaque);
                                              this->append(Op::swap_rb);
                                              this->append(Op::store_1010102, ctx);
                                              break;
 
        case kBGR_101010x_XR_SkColorType:     this->append(Op::force_opaque);
                                              this->append(Op::swap_rb);
                                              this->append(Op::store_1010102_xr, ctx);
                                              break;
 
        case kBGRA_10101010_XR_SkColorType:   this->append(Op::swap_rb);
                                              this->append(Op::store_10101010_xr, ctx);
                                              break;
 
        case kGray_8_SkColorType:             this->append(Op::bt709_luminance_or_luma_to_alpha);
                                              this->append(Op::store_a8, ctx);
                                              break;
 
        case kBGRA_8888_SkColorType:          this->append(Op::swap_rb);
                                              this->append(Op::store_8888, ctx);
                                              break;
 
        case kSRGBA_8888_SkColorType:
            this->appendTransferFunction(*skcms_sRGB_Inverse_TransferFunction());
            this->append(Op::store_8888, ctx);
            break;
    }
}

appendTransferFunction()

void SkRasterPipeline::appendTransferFunction

(

const skcms_TransferFunction &

tf

)

Definition at line 514 of file SkRasterPipeline.cpp.

                                                                              {
    void* ctx = const_cast<void*>(static_cast<const void*>(&tf));
    switch (skcms_TransferFunction_getType(&tf)) {
        case skcms_TFType_Invalid: SkASSERT(false); break;
 
        case skcms_TFType_sRGBish:
            if (tf.a == 1 && tf.b == 0 && tf.c == 0 && tf.d == 0 && tf.e == 0 && tf.f == 0) {
                this->uncheckedAppend(Op::gamma_, ctx);
            } else {
                this->uncheckedAppend(Op::parametric, ctx);
            }
            break;
        case skcms_TFType_PQish:     this->uncheckedAppend(Op::PQish,     ctx); break;
        case skcms_TFType_HLGish:    this->uncheckedAppend(Op::HLGish,    ctx); break;
        case skcms_TFType_HLGinvish: this->uncheckedAppend(Op::HLGinvish, ctx); break;
    }
}

compile()

std::function< void(size_t, size_t, size_t, size_t)> SkRasterPipeline::compile

(

)

const

Definition at line 634 of file SkRasterPipeline.cpp.

                                                                                  {
    if (this->empty()) {
        return [](size_t, size_t, size_t, size_t) {};
    }
 
    int stagesNeeded = this->stagesNeeded();
 
    SkRasterPipelineStage* program = fAlloc->makeArray<SkRasterPipelineStage>(stagesNeeded);
 
    int numMemoryCtxs = fMemoryCtxInfos.size();
    SkRasterPipeline_MemoryCtxPatch* patches =
            fAlloc->makeArray<SkRasterPipeline_MemoryCtxPatch>(numMemoryCtxs);
    for (int i = 0; i < numMemoryCtxs; ++i) {
        patches[i].info = fMemoryCtxInfos[i];
        patches[i].backup = nullptr;
        memset(patches[i].scratch, 0, sizeof(patches[i].scratch));
    }
    uint8_t* tailPointer = fTailPointer;
 
    auto start_pipeline = this->buildPipeline(program + stagesNeeded);
    return [=](size_t x, size_t y, size_t w, size_t h) {
        start_pipeline(x, y, x + w, y + h, program,
                       SkSpan{patches, numMemoryCtxs},
                       tailPointer);
    };
}

dump()

void SkRasterPipeline::dump

(

)

const

Definition at line 227 of file SkRasterPipeline.cpp.

                                  {
    SkDebugf("SkRasterPipeline, %d stages\n", fNumStages);
    std::vector<const char*> stages;
    for (auto st = fStages; st; st = st->prev) {
        stages.push_back(GetOpName(st->stage));
    }
    std::reverse(stages.begin(), stages.end());
    for (const char* name : stages) {
        SkDebugf("\t%s\n", name);
    }
    SkDebugf("\n");
}

empty()

bool SkRasterPipeline::empty ( ) const

inline

Definition at line 136 of file SkRasterPipeline.h.

{ return fStages == nullptr; }

extend()

void SkRasterPipeline::extend

(

const SkRasterPipeline &

src

)

Definition at line 167 of file SkRasterPipeline.cpp.

                                                         {
    if (src.empty()) {
        return;
    }
    // Create a rewind context if `src` has one already, but we don't. If we _do_ already have one,
    // we need to keep it, since we already have rewind ops that reference it. Either way, we need
    // to rewrite all the rewind ops to point to _our_ rewind context; we only get that checkpoint.
    if (src.fRewindCtx && !fRewindCtx) {
        fRewindCtx = fAlloc->make<SkRasterPipeline_RewindCtx>();
    }
    auto stages = fAlloc->makeArrayDefault<StageList>(src.fNumStages);
 
    int n = src.fNumStages;
    const StageList* st = src.fStages;
    while (n --> 1) {
        stages[n]      = *st;
        stages[n].prev = &stages[n-1];
 
        // We make sure that all ops use _our_ stack context and tail pointer.
        switch (stages[n].stage) {
            case Op::stack_rewind: {
                stages[n].ctx = fRewindCtx;
                break;
            }
            case Op::init_lane_masks: {
                auto* ctx = (SkRasterPipeline_InitLaneMasksCtx*)stages[n].ctx;
                ctx->tail = this->tailPointer();
                break;
            }
            case Op::branch_if_all_lanes_active: {
                auto* ctx = (SkRasterPipeline_BranchIfAllLanesActiveCtx*)stages[n].ctx;
                ctx->tail = this->tailPointer();
                break;
            }
            default:
                break;
        }
 
        st = st->prev;
    }
    stages[0]      = *st;
    stages[0].prev = fStages;
 
    fStages = &stages[src.fNumStages - 1];
    fNumStages += src.fNumStages;
    for (const SkRasterPipeline_MemoryCtxInfo& info : src.fMemoryCtxInfos) {
        this->addMemoryContext(info.context, info.bytesPerPixel, info.load, info.store);
    }
}

getNumStages()

int SkRasterPipeline::getNumStages ( ) const

inline

Definition at line 102 of file SkRasterPipeline.h.

{ return fNumStages; }

GetOpName()

const char * SkRasterPipeline::GetOpName ( SkRasterPipelineOp  op )

static

Definition at line 217 of file SkRasterPipeline.cpp.

                                                             {
    const char* name = "";
    switch (op) {
    #define M(x) case Op::x: name = #x; break;
        SK_RASTER_PIPELINE_OPS_ALL(M)
    #undef M
    }
    return name;
}

getStageList()

const StageList * SkRasterPipeline::getStageList ( ) const

inline

Definition at line 101 of file SkRasterPipeline.h.

{ return fStages; }

operator=() [1/2]

SkRasterPipeline & SkRasterPipeline::operator= ( const SkRasterPipeline &  )

delete

operator=() [2/2]

SkRasterPipeline & SkRasterPipeline::operator= ( SkRasterPipeline &&  )

default

reset()

void SkRasterPipeline::reset

(

)

Definition at line 35 of file SkRasterPipeline.cpp.

                             {
    // We intentionally leave the alloc alone here; we don't own it.
    fRewindCtx   = nullptr;
    fStages      = nullptr;
    fTailPointer = nullptr;
    fNumStages   = 0;
    fMemoryCtxInfos.clear();
}

run()

void SkRasterPipeline::run	(	size_t	x,
		size_t	y,
		size_t	w,
		size_t	h
	)		const

Definition at line 610 of file SkRasterPipeline.cpp.

                                                                       {
    if (this->empty()) {
        return;
    }
 
    int stagesNeeded = this->stagesNeeded();
 
    // Best to not use fAlloc here... we can't bound how often run() will be called.
    AutoSTMalloc<32, SkRasterPipelineStage> program(stagesNeeded);
 
    int numMemoryCtxs = fMemoryCtxInfos.size();
    AutoSTMalloc<2, SkRasterPipeline_MemoryCtxPatch> patches(numMemoryCtxs);
    for (int i = 0; i < numMemoryCtxs; ++i) {
        patches[i].info = fMemoryCtxInfos[i];
        patches[i].backup = nullptr;
        memset(patches[i].scratch, 0, sizeof(patches[i].scratch));
    }
 
    auto start_pipeline = this->buildPipeline(program.get() + stagesNeeded);
    start_pipeline(x, y, x + w, y + h, program.get(),
                   SkSpan{patches.data(), numMemoryCtxs},
                   fTailPointer);
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkRasterPipeline.h
• third_party/skia/src/core/SkRasterPipeline.cpp