SkRasterPipelineBlitter Class Reference

Inheritance diagram for SkRasterPipelineBlitter:

Public Member Functions
	SkRasterPipelineBlitter (SkPixmap dst, SkArenaAlloc *alloc)
void	blitH (int x, int y, int w) override
	Blit a horizontal run of one or more pixels.
void	blitAntiH (int x, int y, const SkAlpha[], const int16_t[]) override
void	blitAntiH2 (int x, int y, U8CPU a0, U8CPU a1) override
void	blitAntiV2 (int x, int y, U8CPU a0, U8CPU a1) override
void	blitMask (const SkMask &, const SkIRect &clip) override
void	blitRect (int x, int y, int width, int height) override
	Blit a solid rectangle one or more pixels wide.
void	blitV (int x, int y, int height, SkAlpha alpha) override
	Blit a vertical run of pixels with a constant alpha value.
Public Member Functions inherited from SkBlitter
virtual	~SkBlitter ()
virtual void	blitAntiRect (int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha)
void	blitFatAntiRect (const SkRect &rect)
virtual bool	isNullBlitter () const
virtual int	requestRowsPreserved () const
virtual void *	allocBlitMemory (size_t sz)
void	blitRectRegion (const SkIRect &rect, const SkRegion &clip)
void	blitRegion (const SkRegion &clip)

Static Public Member Functions
static SkBlitter *	Create (const SkPixmap &dst, const SkPaint &paint, const SkColor4f &dstPaintColor, SkArenaAlloc *alloc, const SkRasterPipeline &shaderPipeline, bool is_opaque, bool is_constant, const SkShader *clipShader)
Static Public Member Functions inherited from SkBlitter
static bool	UseLegacyBlitter (const SkPixmap &, const SkPaint &, const SkMatrix &)
static SkBlitter *	Choose (const SkPixmap &dst, const SkMatrix &ctm, const SkPaint &paint, SkArenaAlloc *, bool drawCoverage, sk_sp< SkShader > clipShader, const SkSurfaceProps &props)
static SkBlitter *	ChooseSprite (const SkPixmap &dst, const SkPaint &, const SkPixmap &src, int left, int top, SkArenaAlloc *, sk_sp< SkShader > clipShader)

Additional Inherited Members
Protected Attributes inherited from SkBlitter
SkAutoMalloc	fBlitMemory

Detailed Description

Definition at line 47 of file SkRasterPipelineBlitter.cpp.

Constructor & Destructor Documentation

SkRasterPipelineBlitter()

SkRasterPipelineBlitter::SkRasterPipelineBlitter ( SkPixmap  dst, SkArenaAlloc *  alloc  )

inline

Definition at line 59 of file SkRasterPipelineBlitter.cpp.

        : fDst(std::move(dst))
        , fAlloc(alloc)
        , fColorPipeline(alloc)
        , fBlendPipeline(alloc)
    {}

Member Function Documentation

blitAntiH()

void SkRasterPipelineBlitter::blitAntiH ( int  x, int  y, const SkAlpha  antialias[], const int16_t  runs[]  )

overridevirtual

Blit a horizontal run of antialiased pixels; runs[] is a sparse zero-terminated run-length encoding of spans of constant alpha values. The runs[] and antialias[] work together to represent long runs of pixels with the same alphas. The runs[] contains the number of pixels with the same alpha, and antialias[] contain the coverage value for that number of pixels. The runs[] (and antialias[]) are encoded in a clever way. The runs array is zero terminated, and has enough entries for each pixel plus one, in most cases some of the entries will not contain valid data. An entry in the runs array contains the number of pixels (np) that have the same alpha value. The next np value is found np entries away. For example, if runs[0] = 7, then the next valid entry will by at runs[7]. The runs array and antialias[] are coupled by index. So, if the np entry is at runs[45] = 12 then the alpha value can be found at antialias[45] = 0x88. This would mean to use an alpha value of 0x88 for the next 12 pixels starting at pixel 45.

Implements SkBlitter.

Definition at line 433 of file SkRasterPipelineBlitter.cpp.

                                                                                              {
    if (!fBlitAntiH) {
        SkRasterPipeline p(fAlloc);
        p.extend(fColorPipeline);
        p.appendClampIfNormalized(fDst.info());
        if (fBlendMode.has_value() &&
            SkBlendMode_ShouldPreScaleCoverage(*fBlendMode, /*rgb_coverage=*/false)) {
            p.append(SkRasterPipelineOp::scale_1_float, &fCurrentCoverage);
            this->appendClipScale(&p);
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
        } else {
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
            p.append(SkRasterPipelineOp::lerp_1_float, &fCurrentCoverage);
            this->appendClipLerp(&p);
        }
 
        this->appendStore(&p);
        fBlitAntiH = p.compile();
    }
 
    for (int16_t run = *runs; run > 0; run = *runs) {
        switch (*aa) {
            case 0x00:                                break;
            case 0xff:this->blitRectWithTrace(x,y,run, 1, false); break;
            default:
                fCurrentCoverage = *aa * (1/255.0f);
                fBlitAntiH(x,y,run,1);
        }
        x    += run;
        runs += run;
        aa   += run;
    }
}

blitAntiH2()

void SkRasterPipelineBlitter::blitAntiH2 ( int  x, int  y, U8CPU  a0, U8CPU  a1  )

overridevirtual

Reimplemented from SkBlitter.

Definition at line 469 of file SkRasterPipelineBlitter.cpp.

                                                                         {
    SkIRect clip = {x,y, x+2,y+1};
    uint8_t coverage[] = { (uint8_t)a0, (uint8_t)a1 };
    SkMask mask(coverage, clip, 2, SkMask::kA8_Format);
    this->blitMask(mask, clip);
}

blitAntiV2()

void SkRasterPipelineBlitter::blitAntiV2 ( int  x, int  y, U8CPU  a0, U8CPU  a1  )

overridevirtual

Reimplemented from SkBlitter.

Definition at line 476 of file SkRasterPipelineBlitter.cpp.

                                                                         {
    SkIRect clip = {x,y, x+1,y+2};
    uint8_t coverage[] = { (uint8_t)a0, (uint8_t)a1 };
    SkMask mask(coverage, clip, 1, SkMask::kA8_Format);
    this->blitMask(mask, clip);
}

blitH()

void SkRasterPipelineBlitter::blitH ( int  x, int  y, int  width  )

overridevirtual

Blit a horizontal run of one or more pixels.

Implements SkBlitter.

Definition at line 387 of file SkRasterPipelineBlitter.cpp.

                                                       {
    this->blitRect(x,y,w,1);
}

blitMask()

void SkRasterPipelineBlitter::blitMask ( const SkMask &  mask, const SkIRect &  clip  )

overridevirtual

Blit a pattern of pixels defined by a rectangle-clipped mask; typically used for text.

Reimplemented from SkBlitter.

Definition at line 491 of file SkRasterPipelineBlitter.cpp.

                                                                              {
    if (mask.fFormat == SkMask::kBW_Format) {
        // TODO: native BW masks?
        return INHERITED::blitMask(mask, clip);
    }
 
    // ARGB and SDF masks shouldn't make it here.
    SkASSERT(mask.fFormat == SkMask::kA8_Format
          || mask.fFormat == SkMask::kLCD16_Format
          || mask.fFormat == SkMask::k3D_Format);
 
    auto extract_mask_plane = [&mask](int plane, SkRasterPipeline_MemoryCtx* ctx) {
        // LCD is 16-bit per pixel; A8 and 3D are 8-bit per pixel.
        size_t bpp = mask.fFormat == SkMask::kLCD16_Format ? 2 : 1;
 
        // Select the right mask plane.  Usually plane == 0 and this is just mask.fImage.
        auto ptr = (uintptr_t)mask.fImage
                 + plane * mask.computeImageSize();
 
        // Update ctx to point "into" this current mask, but lined up with fDstPtr at (0,0).
        // This sort of trickery upsets UBSAN (pointer-overflow) so our ptr must be a uintptr_t.
        // mask.fRowBytes is a uint32_t, which would break our addressing math on 64-bit builds.
        size_t rowBytes = mask.fRowBytes;
        ctx->stride = rowBytes / bpp;
        ctx->pixels = (void*)(ptr - mask.fBounds.left() * bpp
                                  - mask.fBounds.top()  * rowBytes);
    };
 
    extract_mask_plane(0, &fMaskPtr);
    if (mask.fFormat == SkMask::k3D_Format) {
        extract_mask_plane(1, &fEmbossCtx.mul);
        extract_mask_plane(2, &fEmbossCtx.add);
    }
 
    // Lazily build whichever pipeline we need, specialized for each mask format.
    if (mask.fFormat == SkMask::kA8_Format && !fBlitMaskA8) {
        SkRasterPipeline p(fAlloc);
        p.extend(fColorPipeline);
        p.appendClampIfNormalized(fDst.info());
        if (fBlendMode.has_value() &&
            SkBlendMode_ShouldPreScaleCoverage(*fBlendMode, /*rgb_coverage=*/false)) {
            p.append(SkRasterPipelineOp::scale_u8, &fMaskPtr);
            this->appendClipScale(&p);
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
        } else {
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
            p.append(SkRasterPipelineOp::lerp_u8, &fMaskPtr);
            this->appendClipLerp(&p);
        }
        this->appendStore(&p);
        fBlitMaskA8 = p.compile();
    }
    if (mask.fFormat == SkMask::kLCD16_Format && !fBlitMaskLCD16) {
        SkRasterPipeline p(fAlloc);
        p.extend(fColorPipeline);
        p.appendClampIfNormalized(fDst.info());
        if (fBlendMode.has_value() &&
            SkBlendMode_ShouldPreScaleCoverage(*fBlendMode, /*rgb_coverage=*/true)) {
            // Somewhat unusually, scale_565 needs dst loaded first.
            this->appendLoadDst(&p);
            p.append(SkRasterPipelineOp::scale_565, &fMaskPtr);
            this->appendClipScale(&p);
            p.extend(fBlendPipeline);
        } else {
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
            p.append(SkRasterPipelineOp::lerp_565, &fMaskPtr);
            this->appendClipLerp(&p);
        }
        this->appendStore(&p);
        fBlitMaskLCD16 = p.compile();
    }
    if (mask.fFormat == SkMask::k3D_Format && !fBlitMask3D) {
        SkRasterPipeline p(fAlloc);
        p.extend(fColorPipeline);
        // This bit is where we differ from kA8_Format:
        p.append(SkRasterPipelineOp::emboss, &fEmbossCtx);
        // Now onward just as kA8.
        p.appendClampIfNormalized(fDst.info());
        if (fBlendMode.has_value() &&
            SkBlendMode_ShouldPreScaleCoverage(*fBlendMode, /*rgb_coverage=*/false)) {
            p.append(SkRasterPipelineOp::scale_u8, &fMaskPtr);
            this->appendClipScale(&p);
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
        } else {
            this->appendLoadDst(&p);
            p.extend(fBlendPipeline);
            p.append(SkRasterPipelineOp::lerp_u8, &fMaskPtr);
            this->appendClipLerp(&p);
        }
        this->appendStore(&p);
        fBlitMask3D = p.compile();
    }
 
    std::function<void(size_t,size_t,size_t,size_t)>* blitter = nullptr;
    switch (mask.fFormat) {
        case SkMask::kA8_Format:    blitter = &fBlitMaskA8;    break;
        case SkMask::kLCD16_Format: blitter = &fBlitMaskLCD16; break;
        case SkMask::k3D_Format:    blitter = &fBlitMask3D;    break;
        default:
            SkASSERT(false);
            return;
    }
 
    SkASSERT(blitter);
    (*blitter)(clip.left(),clip.top(), clip.width(),clip.height());
}

blitRect()

void SkRasterPipelineBlitter::blitRect ( int  x, int  y, int  width, int  height  )

overridevirtual

Blit a solid rectangle one or more pixels wide.

Reimplemented from SkBlitter.

Definition at line 391 of file SkRasterPipelineBlitter.cpp.

                                                                 {
    this->blitRectWithTrace(x, y, w, h, true);
}

blitV()

void SkRasterPipelineBlitter::blitV ( int  x, int  y, int  height, SkAlpha  alpha  )

overridevirtual

Blit a vertical run of pixels with a constant alpha value.

Reimplemented from SkBlitter.

Definition at line 483 of file SkRasterPipelineBlitter.cpp.

                                                                           {
    SkIRect clip = {x,y, x+1,y+height};
    SkMask mask(&alpha, clip,
                0,     // so we reuse the 1 "row" for all of height
                SkMask::kA8_Format);
    this->blitMask(mask, clip);
}

Create()

SkBlitter * SkRasterPipelineBlitter::Create ( const SkPixmap &  dst, const SkPaint &  paint, const SkColor4f &  dstPaintColor, SkArenaAlloc *  alloc, const SkRasterPipeline &  shaderPipeline, bool  is_opaque, bool  is_constant, const SkShader *  clipShader  )

static

Definition at line 175 of file SkRasterPipelineBlitter.cpp.

                                                                       {
    auto blitter = alloc->make<SkRasterPipelineBlitter>(dst, alloc);
 
    // Our job in this factory is to fill out the blitter's color and blend pipelines.
    // The color pipeline is the common front of the full blit pipeline. The blend pipeline is just
    // the portion that does the actual blending math (and assumes that src and dst are already
    // loaded).
    //
    // The full blit pipelines are each constructed lazily on first use, and include the color
    // pipeline, reading the dst, the blend pipeline, coverage, dithering, and writing the dst.
 
    // Start with the color pipeline
    auto colorPipeline = &blitter->fColorPipeline;
 
    if (clipShader) {
        auto clipP = colorPipeline;
        SkColorType clipCT = kRGBA_8888_SkColorType;
        SkColorSpace* clipCS = nullptr;
        SkSurfaceProps props{}; // default OK; clipShader doesn't render text
        SkStageRec rec = {clipP, alloc, clipCT, clipCS, SkColors::kBlack, props};
        if (as_SB(clipShader)->appendRootStages(rec, SkMatrix::I())) {
            struct Storage {
                // large enough for highp (float) or lowp(U16)
                float   fA[SkRasterPipeline_kMaxStride];
            };
            auto storage = alloc->make<Storage>();
            clipP->append(SkRasterPipelineOp::store_src_a, storage->fA);
            blitter->fClipShaderBuffer = storage->fA;
            is_constant = false;
        } else {
            return nullptr;
        }
    }
 
    // Let's get the shader in first.
    colorPipeline->extend(shaderPipeline);
 
    // If there's a color filter it comes next.
    if (auto colorFilter = paint.getColorFilter()) {
        SkSurfaceProps props{}; // default OK; colorFilter doesn't render text
        SkStageRec rec = {
                colorPipeline, alloc, dst.colorType(), dst.colorSpace(), dstPaintColor, props};
        if (!as_CFB(colorFilter)->appendStages(rec, is_opaque)) {
            return nullptr;
        }
        is_opaque = is_opaque && as_CFB(colorFilter)->isAlphaUnchanged();
    }
 
    // Not all formats make sense to dither (think, F16).  We set their dither rate
    // to zero.  We only dither non-constant shaders, so is_constant won't change here.
    if (paint.isDither() && !is_constant) {
        switch (dst.info().colorType()) {
            case kARGB_4444_SkColorType:
                blitter->fDitherRate = 1 / 15.0f;
                break;
            case kRGB_565_SkColorType:
                blitter->fDitherRate = 1 / 63.0f;
                break;
            case kGray_8_SkColorType:
            case kRGB_888x_SkColorType:
            case kRGBA_8888_SkColorType:
            case kBGRA_8888_SkColorType:
            case kSRGBA_8888_SkColorType:
            case kR8_unorm_SkColorType:
                blitter->fDitherRate = 1 / 255.0f;
                break;
            case kRGB_101010x_SkColorType:
            case kRGBA_1010102_SkColorType:
            case kBGR_101010x_SkColorType:
            case kBGRA_1010102_SkColorType:
            case kBGRA_10101010_XR_SkColorType:
            case kRGBA_10x6_SkColorType:
                blitter->fDitherRate = 1 / 1023.0f;
                break;
 
            case kUnknown_SkColorType:
            case kAlpha_8_SkColorType:
            case kBGR_101010x_XR_SkColorType:
            case kRGBA_F16_SkColorType:
            case kRGBA_F16Norm_SkColorType:
            case kRGBA_F32_SkColorType:
            case kR8G8_unorm_SkColorType:
            case kA16_float_SkColorType:
            case kA16_unorm_SkColorType:
            case kR16G16_float_SkColorType:
            case kR16G16_unorm_SkColorType:
            case kR16G16B16A16_unorm_SkColorType:
                blitter->fDitherRate = 0.0f;
                break;
        }
        if (blitter->fDitherRate > 0.0f) {
            colorPipeline->append(SkRasterPipelineOp::dither, &blitter->fDitherRate);
        }
    }
 
    // Optimization: A pipeline that's still constant here can collapse back into a constant color.
    if (is_constant) {
        SkColor4f constantColor;
        SkRasterPipeline_MemoryCtx constantColorPtr = { &constantColor, 0 };
        // We could remove this clamp entirely, but if the destination is 8888, doing the clamp
        // here allows the color pipeline to still run in lowp (we'll use uniform_color, rather than
        // unbounded_uniform_color).
        colorPipeline->appendClampIfNormalized(dst.info());
        colorPipeline->append(SkRasterPipelineOp::store_f32, &constantColorPtr);
        colorPipeline->run(0,0,1,1);
        colorPipeline->reset();
        colorPipeline->appendConstantColor(alloc, constantColor);
 
        is_opaque = constantColor.fA == 1.0f;
    }
 
    // Now we'll build the blend pipeline
    auto blendPipeline = &blitter->fBlendPipeline;
 
    sk_sp<SkBlender> blender = paint.refBlender();
    if (!blender) {
        blender = SkBlender::Mode(SkBlendMode::kSrcOver);
    }
 
    // We can strength-reduce SrcOver into Src when opaque.
    if (is_opaque && as_BB(blender)->asBlendMode() == SkBlendMode::kSrcOver) {
        blender = SkBlender::Mode(SkBlendMode::kSrc);
    }
 
    // When we're drawing a constant color in Src mode, we can sometimes just memset.
    // (The previous two optimizations help find more opportunities for this one.)
    if (is_constant && as_BB(blender)->asBlendMode() == SkBlendMode::kSrc &&
        dst.info().bytesPerPixel() <= static_cast<int>(sizeof(blitter->fMemsetColor))) {
        // Run our color pipeline all the way through to produce what we'd memset when we can.
        // Not all blits can memset, so we need to keep colorPipeline too.
        SkRasterPipeline_<256> p;
        p.extend(*colorPipeline);
        blitter->fDstPtr = SkRasterPipeline_MemoryCtx{&blitter->fMemsetColor, 0};
        blitter->appendStore(&p);
        p.run(0,0,1,1);
 
        switch (blitter->fDst.shiftPerPixel()) {
            case 0: blitter->fMemset2D = [](SkPixmap* dst, int x,int y, int w,int h, uint64_t c) {
                void* p = dst->writable_addr(x,y);
                while (h --> 0) {
                    memset(p, c, w);
                    p = SkTAddOffset<void>(p, dst->rowBytes());
                }
            }; break;
 
            case 1: blitter->fMemset2D = [](SkPixmap* dst, int x,int y, int w,int h, uint64_t c) {
                SkOpts::rect_memset16(dst->writable_addr16(x,y), c, w, dst->rowBytes(), h);
            }; break;
 
            case 2: blitter->fMemset2D = [](SkPixmap* dst, int x,int y, int w,int h, uint64_t c) {
                SkOpts::rect_memset32(dst->writable_addr32(x,y), c, w, dst->rowBytes(), h);
            }; break;
 
            case 3: blitter->fMemset2D = [](SkPixmap* dst, int x,int y, int w,int h, uint64_t c) {
                SkOpts::rect_memset64(dst->writable_addr64(x,y), c, w, dst->rowBytes(), h);
            }; break;
 
            // TODO(F32)?
        }
    }
 
    {
        SkSurfaceProps props{};  // default OK; blender doesn't render text
        SkStageRec rec = {
                blendPipeline, alloc, dst.colorType(), dst.colorSpace(), dstPaintColor, props};
        if (!as_BB(blender)->appendStages(rec)) {
            return nullptr;
        }
        blitter->fBlendMode = as_BB(blender)->asBlendMode();
    }
 
    blitter->fDstPtr = SkRasterPipeline_MemoryCtx{
        blitter->fDst.writable_addr(),
        blitter->fDst.rowBytesAsPixels(),
    };
 
    return blitter;
}

---

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

• third_party/skia/src/core/SkRasterPipelineBlitter.cpp