SkRgnBuilder Class Reference

Inheritance diagram for SkRgnBuilder:

Public Member Functions
	SkRgnBuilder ()
	~SkRgnBuilder () override
bool	init (int maxHeight, int maxTransitions, bool pathIsInverse)
void	done ()
int	computeRunCount () const
void	copyToRect (SkIRect *) const
void	copyToRgn (SkRegion::RunType runs[]) const
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 antialias[], const int16_t runs[]) override
Public Member Functions inherited from SkBlitter
virtual	~SkBlitter ()
virtual void	blitV (int x, int y, int height, SkAlpha alpha)
	Blit a vertical run of pixels with a constant alpha value.
virtual void	blitRect (int x, int y, int width, int height)
	Blit a solid rectangle one or more pixels wide.
virtual void	blitAntiRect (int x, int y, int width, int height, SkAlpha leftAlpha, SkAlpha rightAlpha)
void	blitFatAntiRect (const SkRect &rect)
virtual void	blitMask (const SkMask &, const SkIRect &clip)
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
virtual int	requestRowsPreserved () const
virtual void *	allocBlitMemory (size_t sz)
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

Definition at line 44 of file SkRegion_path.cpp.

Constructor & Destructor Documentation

SkRgnBuilder()

SkRgnBuilder::SkRgnBuilder

(

)

Definition at line 131 of file SkRegion_path.cpp.

    : fStorage(nullptr) {
}

~SkRgnBuilder()

SkRgnBuilder::~SkRgnBuilder ( )

override

Definition at line 135 of file SkRegion_path.cpp.

                            {
    sk_free(fStorage);
}

Member Function Documentation

blitAntiH()

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

inlineoverridevirtual

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 66 of file SkRegion_path.cpp.

                                                                                           {
        SkDEBUGFAIL("blitAntiH not implemented");
    }

blitH()

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

overridevirtual

Blit a horizontal run of one or more pixels.

Implements SkBlitter.

Definition at line 177 of file SkRegion_path.cpp.

                                                {
    if (fCurrScanline == nullptr) {  // first time
        fTop = (SkRegion::RunType)(y);
        fCurrScanline = (Scanline*)fStorage;
        fCurrScanline->fLastY = (SkRegion::RunType)(y);
        fCurrXPtr = fCurrScanline->firstX();
    } else {
        SkASSERT(y >= fCurrScanline->fLastY);
 
        if (y > fCurrScanline->fLastY) {
            // if we get here, we're done with fCurrScanline
            fCurrScanline->fXCount = (SkRegion::RunType)((int)(fCurrXPtr - fCurrScanline->firstX()));
 
            int prevLastY = fCurrScanline->fLastY;
            if (!this->collapsWithPrev()) {
                fPrevScanline = fCurrScanline;
                fCurrScanline = fCurrScanline->nextScanline();
 
            }
            if (y - 1 > prevLastY) {  // insert empty run
                fCurrScanline->fLastY = (SkRegion::RunType)(y - 1);
                fCurrScanline->fXCount = 0;
                fCurrScanline = fCurrScanline->nextScanline();
            }
            // setup for the new curr line
            fCurrScanline->fLastY = (SkRegion::RunType)(y);
            fCurrXPtr = fCurrScanline->firstX();
        }
    }
    //  check if we should extend the current run, or add a new one
    if (fCurrXPtr > fCurrScanline->firstX() && fCurrXPtr[-1] == x) {
        fCurrXPtr[-1] = (SkRegion::RunType)(x + width);
    } else {
        fCurrXPtr[0] = (SkRegion::RunType)(x);
        fCurrXPtr[1] = (SkRegion::RunType)(x + width);
        fCurrXPtr += 2;
    }
    SkASSERT(fCurrXPtr - fStorage < fStorageCount);
}

computeRunCount()

int SkRgnBuilder::computeRunCount

(

)

const

Definition at line 217 of file SkRegion_path.cpp.

                                        {
    if (fCurrScanline == nullptr) {
        return 0;
    }
 
    const SkRegion::RunType*  line = fStorage;
    const SkRegion::RunType*  stop = (const SkRegion::RunType*)fCurrScanline;
 
    return 2 + (int)(stop - line);
}

copyToRect()

void SkRgnBuilder::copyToRect

(

SkIRect *

r

)

const

Definition at line 228 of file SkRegion_path.cpp.

                                              {
    SkASSERT(fCurrScanline != nullptr);
    // A rect's scanline is [bottom intervals left right sentinel] == 5
    SkASSERT((const SkRegion::RunType*)fCurrScanline - fStorage == 5);
 
    Scanline* line = (Scanline*)fStorage;
    SkASSERT(line->fXCount == 2);
 
    r->setLTRB(line->firstX()[0], fTop, line->firstX()[1], line->fLastY + 1);
}

copyToRgn()

void SkRgnBuilder::copyToRgn

(

SkRegion::RunType

runs[]

)

const

Definition at line 239 of file SkRegion_path.cpp.

                                                         {
    SkASSERT(fCurrScanline != nullptr);
    SkASSERT((const SkRegion::RunType*)fCurrScanline - fStorage > 4);
 
    Scanline* line = (Scanline*)fStorage;
    const Scanline* stop = fCurrScanline;
 
    *runs++ = fTop;
    do {
        *runs++ = (SkRegion::RunType)(line->fLastY + 1);
        int count = line->fXCount;
        *runs++ = count >> 1;   // intervalCount
        if (count) {
            memcpy(runs, line->firstX(), count * sizeof(SkRegion::RunType));
            runs += count;
        }
        *runs++ = SkRegion_kRunTypeSentinel;
        line = line->nextScanline();
    } while (line < stop);
    SkASSERT(line == stop);
    *runs = SkRegion_kRunTypeSentinel;
}

done()

void SkRgnBuilder::done ( )

inline

Definition at line 52 of file SkRegion_path.cpp.

                {
        if (fCurrScanline != nullptr) {
            fCurrScanline->fXCount = (SkRegion::RunType)((int)(fCurrXPtr - fCurrScanline->firstX()));
            if (!this->collapsWithPrev()) { // flush the last line
                fCurrScanline = fCurrScanline->nextScanline();
            }
        }
    }

init()

bool SkRgnBuilder::init	(	int	maxHeight,
		int	maxTransitions,
		bool	pathIsInverse
	)

Definition at line 139 of file SkRegion_path.cpp.

                                                                             {
    if ((maxHeight | maxTransitions) < 0) {
        return false;
    }
 
    SkSafeMath  safe;
 
    if (pathIsInverse) {
        // allow for additional X transitions to "invert" each scanline
        // [ L' ... normal transitions ... R' ]
        //
        maxTransitions = safe.addInt(maxTransitions, 2);
    }
 
    // compute the count with +1 and +3 slop for the working buffer
    size_t count = safe.mul(safe.addInt(maxHeight, 1), safe.addInt(3, maxTransitions));
 
    if (pathIsInverse) {
        // allow for two "empty" rows for the top and bottom
        //      [ Y, 1, L, R, S] == 5 (*2 for top and bottom)
        count = safe.add(count, 10);
    }
 
    if (!safe || !SkTFitsIn<int32_t>(count)) {
        return false;
    }
    fStorageCount = SkToS32(count);
 
    fStorage = (SkRegion::RunType*)sk_malloc_canfail(fStorageCount, sizeof(SkRegion::RunType));
    if (nullptr == fStorage) {
        return false;
    }
 
    fCurrScanline = nullptr;    // signal empty collection
    fPrevScanline = nullptr;    // signal first scanline
    return true;
}

---

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

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