SkAAClip Class Reference

#include <SkAAClip.h>

Classes
class	Builder
struct	RunHead

Public Member Functions
	SkAAClip ()
	SkAAClip (const SkAAClip &)
	~SkAAClip ()
SkAAClip &	operator= (const SkAAClip &)
bool	isEmpty () const
const SkIRect &	getBounds () const
bool	isRect () const
bool	setEmpty ()
bool	setRect (const SkIRect &)
bool	setPath (const SkPath &, const SkIRect &bounds, bool doAA=true)
bool	setRegion (const SkRegion &)
bool	op (const SkIRect &, SkClipOp)
bool	op (const SkRect &, SkClipOp, bool doAA)
bool	op (const SkAAClip &, SkClipOp)
bool	translate (int dx, int dy, SkAAClip *dst) const
void	copyToMask (SkMaskBuilder *) const
bool	quickContains (const SkIRect &r) const
void	validate () const
void	debug (bool compress_y=false) const

Friends
class	SkAAClipBlitter

Detailed Description

Definition at line 25 of file SkAAClip.h.

Constructor & Destructor Documentation

SkAAClip() [1/2]

SkAAClip::SkAAClip

(

)

Definition at line 1234 of file SkAAClip.cpp.

                   {
    fBounds.setEmpty();
    fRunHead = nullptr;
}

SkAAClip() [2/2]

SkAAClip::SkAAClip

(

const SkAAClip &

src

)

Definition at line 1239 of file SkAAClip.cpp.

                                      {
    SkDEBUGCODE(fBounds.setEmpty();)    // need this for validate
    fRunHead = nullptr;
    *this = src;
}

~SkAAClip()

SkAAClip::~SkAAClip

(

)

Definition at line 1245 of file SkAAClip.cpp.

                    {
    this->freeRuns();
}

Member Function Documentation

copyToMask()

void SkAAClip::copyToMask

(

SkMaskBuilder *

mask

)

const

Allocates a mask the size of the aaclip, and expands its data into the mask, using kA8_Format. Used for tests and visualization purposes.

Definition at line 851 of file SkAAClip.cpp.

                                                   {
    auto expandRowToMask = [](uint8_t* dst, const uint8_t* row, int width) {
        while (width > 0) {
            int n = row[0];
            SkASSERT(width >= n);
            memset(dst, row[1], n);
            dst += n;
            row += 2;
            width -= n;
        }
        SkASSERT(0 == width);
    };
 
    mask->format() = SkMask::kA8_Format;
    if (this->isEmpty()) {
        mask->bounds().setEmpty();
        mask->image() = nullptr;
        mask->rowBytes() = 0;
        return;
    }
 
    mask->bounds() = fBounds;
    mask->rowBytes() = fBounds.width();
    size_t size = mask->computeImageSize();
    mask->image() = SkMaskBuilder::AllocImage(size);
 
    Iter iter = RunHead::Iterate(*this);
    uint8_t* dst = mask->image();
    const int width = fBounds.width();
 
    int y = fBounds.fTop;
    while (!iter.done()) {
        do {
            expandRowToMask(dst, iter.data(), width);
            dst += mask->fRowBytes;
        } while (++y < iter.bottom());
        iter.next();
    }
}

debug()

void SkAAClip::debug ( bool  compress_y = false ) const

inline

Definition at line 66 of file SkAAClip.h.

{}

getBounds()

const SkIRect & SkAAClip::getBounds ( ) const

inline

Definition at line 34 of file SkAAClip.h.

{ return fBounds; }

isEmpty()

bool SkAAClip::isEmpty ( ) const

inline

Definition at line 33 of file SkAAClip.h.

{ return nullptr == fRunHead; }

isRect()

bool SkAAClip::isRect

(

)

const

Definition at line 1285 of file SkAAClip.cpp.

                            {
    if (this->isEmpty()) {
        return false;
    }
 
    const RunHead* head = fRunHead;
    if (head->fRowCount != 1) {
        return false;
    }
    const YOffset* yoff = head->yoffsets();
    if (yoff->fY != fBounds.fBottom - 1) {
        return false;
    }
 
    const uint8_t* row = head->data() + yoff->fOffset;
    int width = fBounds.width();
    do {
        if (row[1] != 0xFF) {
            return false;
        }
        int n = row[0];
        SkASSERT(n <= width);
        width -= n;
        row += 2;
    } while (width > 0);
    return true;
}

op() [1/3]

bool SkAAClip::op	(	const SkAAClip &	other,
		SkClipOp	op
	)

Definition at line 1426 of file SkAAClip.cpp.

                                                    {
    AUTO_AACLIP_VALIDATE(*this);
 
    if (this->isEmpty()) {
        // Once the clip is empty, it cannot become un-empty.
        return false;
    }
 
    SkIRect bounds = fBounds;
    switch(op) {
        case SkClipOp::kDifference:
            if (other.isEmpty() || !SkIRect::Intersects(fBounds, other.fBounds)) {
                // this remains unmodified and isn't empty
                return true;
            }
            break;
 
        case SkClipOp::kIntersect:
            if (other.isEmpty() || !bounds.intersect(other.fBounds)) {
                // the intersected clip becomes empty
                return this->setEmpty();
            }
            break;
    }
 
 
    SkASSERT(SkIRect::Intersects(bounds, fBounds));
    SkASSERT(SkIRect::Intersects(bounds, other.fBounds));
 
    Builder builder(bounds);
    return builder.applyClipOp(this, other, op);
}

op() [2/3]

bool SkAAClip::op	(	const SkIRect &	rect,
		SkClipOp	op
	)

Definition at line 1459 of file SkAAClip.cpp.

                                                  {
    // It can be expensive to build a local aaclip before applying the op, so
    // we first see if we can restrict the bounds of new rect to our current
    // bounds, or note that the new rect subsumes our current clip.
    SkIRect pixelBounds = fBounds;
    if (!pixelBounds.intersect(rect)) {
        // No change or clip becomes empty depending on 'op'
        switch(op) {
            case SkClipOp::kDifference: return !this->isEmpty();
            case SkClipOp::kIntersect:  return this->setEmpty();
        }
        SkUNREACHABLE;
    } else if (pixelBounds == fBounds) {
        // Wholly inside 'rect', so clip becomes empty or remains unchanged
        switch(op) {
            case SkClipOp::kDifference: return this->setEmpty();
            case SkClipOp::kIntersect:  return !this->isEmpty();
        }
        SkUNREACHABLE;
    } else if (op == SkClipOp::kIntersect && this->quickContains(pixelBounds)) {
        // We become just the remaining rectangle
        return this->setRect(pixelBounds);
    } else {
        SkAAClip clip;
        clip.setRect(rect);
        return this->op(clip, op);
    }
}

op() [3/3]

bool SkAAClip::op	(	const SkRect &	rect,
		SkClipOp	op,
		bool	doAA
	)

Definition at line 1488 of file SkAAClip.cpp.

                                                            {
    if (!doAA) {
        return this->op(rect.round(), op);
    } else {
        // Tighten bounds for "path" aaclip of the rect
        SkIRect pixelBounds = fBounds;
        if (!pixelBounds.intersect(rect.roundOut())) {
            // No change or clip becomes empty depending on 'op'
            switch(op) {
                case SkClipOp::kDifference: return !this->isEmpty();
                case SkClipOp::kIntersect:  return this->setEmpty();
            }
            SkUNREACHABLE;
        } else if (rect.contains(SkRect::Make(fBounds))) {
            // Wholly inside 'rect', so clip becomes empty or remains unchanged
            switch(op) {
                case SkClipOp::kDifference: return this->setEmpty();
                case SkClipOp::kIntersect:  return !this->isEmpty();
            }
            SkUNREACHABLE;
        } else if (op == SkClipOp::kIntersect && this->quickContains(pixelBounds)) {
            // We become just the rect intersected with pixel bounds (preserving fractional coords
            // for AA edges).
            return this->setPath(SkPath::Rect(rect), pixelBounds, /*doAA=*/true);
        } else {
            SkAAClip rectClip;
            rectClip.setPath(SkPath::Rect(rect),
                             op == SkClipOp::kDifference ? fBounds : pixelBounds,
                             /*doAA=*/true);
            return this->op(rectClip, op);
        }
    }
}

operator=()

SkAAClip & SkAAClip::operator=

(

const SkAAClip &

src

)

Definition at line 1249 of file SkAAClip.cpp.

                                                 {
    AUTO_AACLIP_VALIDATE(*this);
    src.validate();
 
    if (this != &src) {
        this->freeRuns();
        fBounds = src.fBounds;
        fRunHead = src.fRunHead;
        if (fRunHead) {
            fRunHead->fRefCnt++;
        }
    }
    return *this;
}

quickContains()

bool SkAAClip::quickContains ( const SkIRect &  r ) const

inline

Definition at line 57 of file SkAAClip.h.

                                               {
        return this->quickContains(r.fLeft, r.fTop, r.fRight, r.fBottom);
    }

setEmpty()

bool SkAAClip::setEmpty

(

)

Definition at line 1264 of file SkAAClip.cpp.

                        {
    this->freeRuns();
    fBounds.setEmpty();
    fRunHead = nullptr;
    return false;
}

setPath()

bool SkAAClip::setPath	(	const SkPath &	path,
		const SkIRect &	bounds,
		bool	doAA = true
	)

Definition at line 1401 of file SkAAClip.cpp.

                                                                         {
    AUTO_AACLIP_VALIDATE(*this);
 
    if (clip.isEmpty()) {
        return this->setEmpty();
    }
 
    SkIRect ibounds;
    // Since we assert that the BuilderBlitter will never blit outside the intersection
    // of clip and ibounds, we create the builder with the snug bounds.
    if (path.isInverseFillType()) {
        ibounds = clip;
    } else {
        path.getBounds().roundOut(&ibounds);
        if (ibounds.isEmpty() || !ibounds.intersect(clip)) {
            return this->setEmpty();
        }
    }
 
    Builder builder(ibounds);
    return builder.blitPath(this, path, doAA);
}

setRect()

bool SkAAClip::setRect

(

const SkIRect &

bounds

)

Definition at line 1271 of file SkAAClip.cpp.

                                            {
    if (bounds.isEmpty()) {
        return this->setEmpty();
    }
 
    AUTO_AACLIP_VALIDATE(*this);
 
    this->freeRuns();
    fBounds = bounds;
    fRunHead = RunHead::AllocRect(bounds);
    SkASSERT(!this->isEmpty());
    return true;
}

setRegion()

bool SkAAClip::setRegion

(

const SkRegion &

rgn

)

Definition at line 1313 of file SkAAClip.cpp.

                                            {
    if (rgn.isEmpty()) {
        return this->setEmpty();
    }
    if (rgn.isRect()) {
        return this->setRect(rgn.getBounds());
    }
 
 
    const SkIRect& bounds = rgn.getBounds();
    const int offsetX = bounds.fLeft;
    const int offsetY = bounds.fTop;
 
    SkTDArray<YOffset> yArray;
    SkTDArray<uint8_t> xArray;
 
    yArray.reserve(std::min(bounds.height(), 1024));
    xArray.reserve(std::min(bounds.width(), 512) * 128);
 
    auto appendXRun = [&xArray](uint8_t value, int count) {
        SkASSERT(count >= 0);
        while (count > 0) {
            int n = count;
            if (n > 255) {
                n = 255;
            }
            uint8_t* data = xArray.append(2);
            data[0] = n;
            data[1] = value;
            count -= n;
        }
    };
 
    SkRegion::Iterator iter(rgn);
    int prevRight = 0;
    int prevBot = 0;
    YOffset* currY = nullptr;
 
    for (; !iter.done(); iter.next()) {
        const SkIRect& r = iter.rect();
        SkASSERT(bounds.contains(r));
 
        int bot = r.fBottom - offsetY;
        SkASSERT(bot >= prevBot);
        if (bot > prevBot) {
            if (currY) {
                // flush current row
                appendXRun(0, bounds.width() - prevRight);
            }
            // did we introduce an empty-gap from the prev row?
            int top = r.fTop - offsetY;
            if (top > prevBot) {
                currY = yArray.append();
                currY->fY = top - 1;
                currY->fOffset = xArray.size();
                appendXRun(0, bounds.width());
            }
            // create a new record for this Y value
            currY = yArray.append();
            currY->fY = bot - 1;
            currY->fOffset = xArray.size();
            prevRight = 0;
            prevBot = bot;
        }
 
        int x = r.fLeft - offsetX;
        appendXRun(0, x - prevRight);
 
        int w = r.fRight - r.fLeft;
        appendXRun(0xFF, w);
        prevRight = x + w;
        SkASSERT(prevRight <= bounds.width());
    }
    // flush last row
    appendXRun(0, bounds.width() - prevRight);
 
    // now pack everything into a RunHead
    RunHead* head = RunHead::Alloc(yArray.size(), xArray.size_bytes());
    memcpy(head->yoffsets(), yArray.begin(), yArray.size_bytes());
    memcpy(head->data(), xArray.begin(), xArray.size_bytes());
 
    this->setEmpty();
    fBounds = bounds;
    fRunHead = head;
    this->validate();
    return true;
}

translate()

bool SkAAClip::translate	(	int	dx,
		int	dy,
		SkAAClip *	dst
	)		const

Definition at line 1524 of file SkAAClip.cpp.

                                                            {
    if (nullptr == dst) {
        return !this->isEmpty();
    }
 
    if (this->isEmpty()) {
        return dst->setEmpty();
    }
 
    if (this != dst) {
        fRunHead->fRefCnt++;
        dst->freeRuns();
        dst->fRunHead = fRunHead;
        dst->fBounds = fBounds;
    }
    dst->fBounds.offset(dx, dy);
    return true;
}

validate()

void SkAAClip::validate ( ) const

inline

Definition at line 65 of file SkAAClip.h.

{}

Friends And Related Function Documentation

SkAAClipBlitter

friend class SkAAClipBlitter

friend

Definition at line 72 of file SkAAClip.h.

---

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

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