SkRegion::RunHead Struct Reference

#include <SkRegionPriv.h>

Public Member Functions
int	getYSpanCount () const
int	getIntervalCount () const
SkRegion::RunType *	writable_runs ()
const SkRegion::RunType *	readonly_runs () const
RunHead *	ensureWritable ()
SkRegion::RunType *	findScanline (int y) const
void	computeRunBounds (SkIRect *bounds)

Static Public Member Functions
static RunHead *	Alloc (int count)
static RunHead *	Alloc (int count, int yspancount, int intervalCount)
static SkRegion::RunType *	SkipEntireScanline (const SkRegion::RunType runs[])

Public Attributes
std::atomic< int32_t >	fRefCnt
int32_t	fRunCount

Detailed Description

Definition at line 59 of file SkRegionPriv.h.

Member Function Documentation

Alloc() [1/2]

static RunHead * SkRegion::RunHead::Alloc ( int  count )

inlinestatic

Definition at line 85 of file SkRegionPriv.h.

                                     {
        if (count < SkRegion::kRectRegionRuns) {
            return nullptr;
        }
 
        const int64_t size = sk_64_mul(count, sizeof(RunType)) + sizeof(RunHead);
        if (count < 0 || !SkTFitsIn<int32_t>(size)) { SK_ABORT("Invalid Size"); }
 
        RunHead* head = (RunHead*)sk_malloc_throw(size);
        head->fRefCnt = 1;
        head->fRunCount = count;
        // these must be filled in later, otherwise we will be invalid
        head->fYSpanCount = 0;
        head->fIntervalCount = 0;
        return head;
    }

Alloc() [2/2]

static RunHead * SkRegion::RunHead::Alloc ( int  count, int  yspancount, int  intervalCount  )

inlinestatic

Definition at line 102 of file SkRegionPriv.h.

                                                                        {
        if (yspancount <= 0 || intervalCount <= 1) {
            return nullptr;
        }
 
        RunHead* head = Alloc(count);
        if (!head) {
            return nullptr;
        }
        head->fYSpanCount = yspancount;
        head->fIntervalCount = intervalCount;
        return head;
    }

computeRunBounds()

void SkRegion::RunHead::computeRunBounds ( SkIRect *  bounds )

inline

Definition at line 195 of file SkRegionPriv.h.

                                           {
        RunType* runs = this->writable_runs();
        bounds->fTop = *runs++;
 
        int bot;
        int ySpanCount = 0;
        int intervalCount = 0;
        int left = SK_MaxS32;
        int rite = SK_MinS32;
 
        do {
            bot = *runs++;
            SkASSERT(bot < SkRegion_kRunTypeSentinel);
            ySpanCount += 1;
 
            const int intervals = *runs++;
            SkASSERT(intervals >= 0);
            SkASSERT(intervals < SkRegion_kRunTypeSentinel);
 
            if (intervals > 0) {
#ifdef SK_DEBUG
                {
                    int n = compute_intervalcount(runs);
                    SkASSERT(n == intervals);
                }
#endif
                RunType L = runs[0];
                SkASSERT(L < SkRegion_kRunTypeSentinel);
                if (left > L) {
                    left = L;
                }
 
                runs += intervals * 2;
                RunType R = runs[-1];
                SkASSERT(R < SkRegion_kRunTypeSentinel);
                if (rite < R) {
                    rite = R;
                }
 
                intervalCount += intervals;
            }
            SkASSERT(SkRegion_kRunTypeSentinel == *runs);
            runs += 1;  // skip x-sentinel
 
            // test Y-sentinel
        } while (SkRegion_kRunTypeSentinel > *runs);
 
#ifdef SK_DEBUG
        // +1 to skip the last Y-sentinel
        int runCount = SkToInt(runs - this->writable_runs() + 1);
        SkASSERT(runCount == fRunCount);
#endif
 
        fYSpanCount = ySpanCount;
        fIntervalCount = intervalCount;
 
        bounds->fLeft = left;
        bounds->fRight = rite;
        bounds->fBottom = bot;
    }

ensureWritable()

RunHead * SkRegion::RunHead::ensureWritable ( )

inline

Definition at line 125 of file SkRegionPriv.h.

                              {
        RunHead* writable = this;
        if (fRefCnt > 1) {
            // We need to alloc & copy the current region before decrease
            // the refcount because it could be freed in the meantime.
            writable = Alloc(fRunCount, fYSpanCount, fIntervalCount);
            memcpy(writable->writable_runs(), this->readonly_runs(),
                   fRunCount * sizeof(RunType));
 
            // fRefCount might have changed since we last checked.
            // If we own the last reference at this point, we need to
            // free the memory.
            if (--fRefCnt == 0) {
                sk_free(this);
            }
        }
        return writable;
    }

findScanline()

SkRegion::RunType * SkRegion::RunHead::findScanline ( int  y ) const

inline

Return the scanline that contains the Y value. This requires that the Y value is already known to be contained within the bounds of the region, and so this routine never returns nullptr.

It returns the beginning of the scanline, starting with its Bottom value.

Definition at line 174 of file SkRegionPriv.h.

                                               {
        const RunType* runs = this->readonly_runs();
 
        // if the top-check fails, we didn't do a quick check on the bounds
        SkASSERT(y >= runs[0]);
 
        runs += 1;  // skip top-Y
        for (;;) {
            int bottom = runs[0];
            // If we hit this, we've walked off the region, and our bounds check
            // failed.
            SkASSERT(bottom < SkRegion_kRunTypeSentinel);
            if (y < bottom) {
                break;
            }
            runs = SkipEntireScanline(runs);
        }
        return const_cast<SkRegion::RunType*>(runs);
    }

getIntervalCount()

int SkRegion::RunHead::getIntervalCount ( ) const

inline

Number of intervals in the entire region. This equals the number of rects that would be returned by the Iterator. In the logical case of a rect, this would return 1, and an empty region would return 0.

Definition at line 81 of file SkRegionPriv.h.

                                 {
        return fIntervalCount;
    }

getYSpanCount()

int SkRegion::RunHead::getYSpanCount ( ) const

inline

Number of spans with different Y values. This does not count the initial Top value, nor does it count the final Y-Sentinel value. In the logical case of a rectangle, this would return 1, and an empty region would return 0.

Definition at line 72 of file SkRegionPriv.h.

                              {
        return fYSpanCount;
    }

readonly_runs()

const SkRegion::RunType * SkRegion::RunHead::readonly_runs ( ) const

inline

Definition at line 121 of file SkRegionPriv.h.

                                                 {
        return (const SkRegion::RunType*)(this + 1);
    }

SkipEntireScanline()

static SkRegion::RunType * SkRegion::RunHead::SkipEntireScanline ( const SkRegion::RunType  runs[] )

inlinestatic

Given a scanline (including its Bottom value at runs[0]), return the next scanline. Asserts that there is one (i.e. runs[0] < Sentinel)

Definition at line 148 of file SkRegionPriv.h.

                                                                             {
        // we are not the Y Sentinel
        SkASSERT(runs[0] < SkRegion_kRunTypeSentinel);
 
        const int intervals = runs[1];
        SkASSERT(runs[2 + intervals * 2] == SkRegion_kRunTypeSentinel);
#ifdef SK_DEBUG
        {
            int n = compute_intervalcount(&runs[2]);
            SkASSERT(n == intervals);
        }
#endif
 
        // skip the entire line [B N [L R] S]
        runs += 1 + 1 + intervals * 2 + 1;
        return const_cast<SkRegion::RunType*>(runs);
    }

writable_runs()

SkRegion::RunType * SkRegion::RunHead::writable_runs ( )

inline

Definition at line 116 of file SkRegionPriv.h.

                                     {
        SkASSERT(fRefCnt == 1);
        return (SkRegion::RunType*)(this + 1);
    }

Member Data Documentation

fRefCnt

std::atomic<int32_t> SkRegion::RunHead::fRefCnt

Definition at line 63 of file SkRegionPriv.h.

fRunCount

int32_t SkRegion::RunHead::fRunCount

Definition at line 64 of file SkRegionPriv.h.

---

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

• third_party/skia/src/core/SkRegionPriv.h