SkRgnClipBlitter Class Reference

#include <SkBlitter.h>

Inheritance diagram for SkRgnClipBlitter:

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

Additional Inherited Members
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)
Protected Attributes inherited from SkBlitter
SkAutoMalloc	fBlitMemory

Detailed Description

Wraps another (real) blitter, and ensures that the real blitter is only called with coordinates that have been clipped by the specified clipRgn. This means the caller need not perform the clipping ahead of time.

Definition at line 214 of file SkBlitter.h.

Member Function Documentation

allocBlitMemory()

void * SkRgnClipBlitter::allocBlitMemory ( size_t  sz )

inlineoverridevirtual

This function allocates memory for the blitter that the blitter then owns. The memory can be used by the calling function at will, but it will be released when the blitter's destructor is called. This function returns nullptr if no persistent memory is needed by the blitter.

Reimplemented from SkBlitter.

Definition at line 234 of file SkBlitter.h.

                                              {
        return fBlitter->allocBlitMemory(sz);
    }

blitAntiH()

void SkRgnClipBlitter::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 501 of file SkBlitter.cpp.

                                                             {
    SkAlpha* aa = const_cast<SkAlpha*>(const_aa);
    int16_t* runs = const_cast<int16_t*>(const_runs);
 
    int width = compute_anti_width(runs);
    SkRegion::Spanerator span(*fRgn, y, x, x + width);
    int left, right;
    SkDEBUGCODE(const SkIRect& bounds = fRgn->getBounds();)
 
    int prevRite = x;
    while (span.next(&left, &right)) {
        SkASSERT(x <= left);
        SkASSERT(left < right);
        SkASSERT(left >= bounds.fLeft && right <= bounds.fRight);
 
        SkAlphaRuns::Break((int16_t*)runs, (uint8_t*)aa, left - x, right - left);
 
        // now zero before left
        if (left > prevRite) {
            int index = prevRite - x;
            ((uint8_t*)aa)[index] = 0;   // skip runs after right
            ((int16_t*)runs)[index] = SkToS16(left - prevRite);
        }
 
        prevRite = right;
    }
 
    if (prevRite > x) {
        ((int16_t*)runs)[prevRite - x] = 0;
 
        if (x < 0) {
            int skip = runs[0];
            SkASSERT(skip >= -x);
            aa += skip;
            runs += skip;
            x += skip;
        }
        fBlitter->blitAntiH(x, y, aa, runs);
    }
}

blitAntiRect()

void SkRgnClipBlitter::blitAntiRect ( int  x, int  y, int  width, int  height, SkAlpha  leftAlpha, SkAlpha  rightAlpha  )

overridevirtual

Blit a rectangle with one alpha-blended column on the left, width (zero or more) opaque pixels, and one alpha-blended column on the right. The result will always be at least two pixels wide.

Default implementation doesn't check for easy optimizations such as alpha == 255; also uses blitV(), which some subclasses may not support.

Reimplemented from SkBlitter.

Definition at line 573 of file SkBlitter.cpp.

                                                                           {
    // The *true* width of the rectangle to blit is width + 2
    SkIRect    bounds;
    bounds.setXYWH(x, y, width + 2, height);
 
    SkRegion::Cliperator    iter(*fRgn, bounds);
 
    while (!iter.done()) {
        const SkIRect& r = iter.rect();
        SkASSERT(bounds.contains(r));
        SkASSERT(r.fLeft >= x);
        SkASSERT(r.fRight <= x + width + 2);
 
        SkAlpha effectiveLeftAlpha = (r.fLeft == x) ? leftAlpha : 255;
        SkAlpha effectiveRightAlpha = (r.fRight == x + width + 2) ?
                                      rightAlpha : 255;
 
        if (255 == effectiveLeftAlpha && 255 == effectiveRightAlpha) {
            fBlitter->blitRect(r.fLeft, r.fTop, r.width(), r.height());
        } else if (1 == r.width()) {
            if (r.fLeft == x) {
                fBlitter->blitV(r.fLeft, r.fTop, r.height(),
                                effectiveLeftAlpha);
            } else {
                SkASSERT(r.fLeft == x + width + 1);
                fBlitter->blitV(r.fLeft, r.fTop, r.height(),
                                effectiveRightAlpha);
            }
        } else {
            fBlitter->blitAntiRect(r.fLeft, r.fTop, r.width() - 2, r.height(),
                                   effectiveLeftAlpha, effectiveRightAlpha);
        }
        iter.next();
    }
}

blitH()

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

overridevirtual

Blit a horizontal run of one or more pixels.

Implements SkBlitter.

Definition at line 491 of file SkBlitter.cpp.

                                                    {
    SkRegion::Spanerator span(*fRgn, y, x, x + width);
    int left, right;
 
    while (span.next(&left, &right)) {
        SkASSERT(left < right);
        fBlitter->blitH(left, y, right - left);
    }
}

blitMask()

void SkRgnClipBlitter::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 611 of file SkBlitter.cpp.

                                                                       {
    SkASSERT(mask.fBounds.contains(clip));
 
    SkRegion::Cliperator iter(*fRgn, clip);
    const SkIRect&       r = iter.rect();
    SkBlitter*           blitter = fBlitter;
 
    while (!iter.done()) {
        blitter->blitMask(mask, r);
        iter.next();
    }
}

blitRect()

void SkRgnClipBlitter::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 558 of file SkBlitter.cpp.

                                                                   {
    SkIRect    bounds;
    bounds.setXYWH(x, y, width, height);
 
    SkRegion::Cliperator    iter(*fRgn, bounds);
 
    while (!iter.done()) {
        const SkIRect& r = iter.rect();
        SkASSERT(bounds.contains(r));
 
        fBlitter->blitRect(r.fLeft, r.fTop, r.width(), r.height());
        iter.next();
    }
}

blitV()

void SkRgnClipBlitter::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 543 of file SkBlitter.cpp.

                                                                    {
    SkIRect    bounds;
    bounds.setXYWH(x, y, 1, height);
 
    SkRegion::Cliperator    iter(*fRgn, bounds);
 
    while (!iter.done()) {
        const SkIRect& r = iter.rect();
        SkASSERT(bounds.contains(r));
 
        fBlitter->blitV(x, r.fTop, r.height(), alpha);
        iter.next();
    }
}

init()

void SkRgnClipBlitter::init ( SkBlitter *  blitter, const SkRegion *  clipRgn  )

inline

Definition at line 216 of file SkBlitter.h.

                                                           {
        SkASSERT(clipRgn && !clipRgn->isEmpty());
        fBlitter = blitter;
        fRgn = clipRgn;
    }

requestRowsPreserved()

int SkRgnClipBlitter::requestRowsPreserved ( ) const

inlineoverridevirtual

Special methods for blitters that can blit more than one row at a time. This function returns the number of rows that this blitter could optimally process at a time. It is still required to support blitting one scanline at a time.

Reimplemented from SkBlitter.

Definition at line 230 of file SkBlitter.h.

                                              {
        return fBlitter->requestRowsPreserved();
    }

---

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

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