SkBlurMaskFilterImpl Class Reference

#include <SkBlurMaskFilterImpl.h>

Inheritance diagram for SkBlurMaskFilterImpl:

Public Member Functions
	SkBlurMaskFilterImpl (SkScalar sigma, SkBlurStyle, bool respectCTM)
SkMask::Format	getFormat () const override
bool	filterMask (SkMaskBuilder *dst, const SkMask &src, const SkMatrix &, SkIPoint *margin) const override
SkMaskFilterBase::Type	type () const override
void	computeFastBounds (const SkRect &, SkRect *) const override
bool	asABlur (BlurRec *) const override
sk_sp< SkImageFilter >	asImageFilter (const SkMatrix &ctm) const override
SkScalar	computeXformedSigma (const SkMatrix &ctm) const
SkBlurStyle	blurStyle () const
SkScalar	sigma () const
bool	ignoreXform () const
Public Member Functions inherited from SkMaskFilterBase
SkFlattenable::Type	getFlattenableType () const override
Public Member Functions inherited from SkMaskFilter
SkRect	approximateFilteredBounds (const SkRect &src) const
Public Member Functions inherited from SkFlattenable
	SkFlattenable ()
virtual Factory	getFactory () const =0
virtual const char *	getTypeName () const =0
sk_sp< SkData >	serialize (const SkSerialProcs *=nullptr) const
size_t	serialize (void *memory, size_t memory_size, const SkSerialProcs *=nullptr) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Private Member Functions
FilterReturn	filterRectsToNine (const SkRect[], int count, const SkMatrix &, const SkIRect &clipBounds, SkTLazy< NinePatch > *) const override
FilterReturn	filterRRectToNine (const SkRRect &, const SkMatrix &, const SkIRect &clipBounds, SkTLazy< NinePatch > *) const override
void	flatten (SkWriteBuffer &) const override

Friends
class	SkBlurMaskFilter
void	sk_register_blur_maskfilter_createproc ()

Additional Inherited Members
Public Types inherited from SkMaskFilterBase
enum class	Type {   kBlur , kEmboss , kSDF , kShader ,   kTable }
Public Types inherited from SkFlattenable
enum	Type {   kSkColorFilter_Type , kSkBlender_Type , kSkDrawable_Type , kSkDrawLooper_Type ,   kSkImageFilter_Type , kSkMaskFilter_Type , kSkPathEffect_Type , kSkShader_Type }
typedef sk_sp< SkFlattenable >(*	Factory) (SkReadBuffer &)
Static Public Member Functions inherited from SkMaskFilterBase
static SkFlattenable::Type	GetFlattenableType ()
Static Public Member Functions inherited from SkMaskFilter
static sk_sp< SkMaskFilter >	MakeBlur (SkBlurStyle style, SkScalar sigma, bool respectCTM=true)
static sk_sp< SkMaskFilter >	Deserialize (const void *data, size_t size, const SkDeserialProcs *procs=nullptr)
Static Public Member Functions inherited from SkFlattenable
static Factory	NameToFactory (const char name[])
static const char *	FactoryToName (Factory)
static void	Register (const char name[], Factory)
static sk_sp< SkFlattenable >	Deserialize (Type, const void *data, size_t length, const SkDeserialProcs *procs=nullptr)
Protected Types inherited from SkMaskFilterBase
enum	FilterReturn { kFalse_FilterReturn , kTrue_FilterReturn , kUnimplemented_FilterReturn }
Protected Member Functions inherited from SkMaskFilterBase
	SkMaskFilterBase ()

Detailed Description

Definition at line 28 of file SkBlurMaskFilterImpl.h.

Constructor & Destructor Documentation

SkBlurMaskFilterImpl()

SkBlurMaskFilterImpl::SkBlurMaskFilterImpl	(	SkScalar	sigma,
		SkBlurStyle	style,
		bool	respectCTM
	)

Definition at line 50 of file SkBlurMaskFilterImpl.cpp.

    : fSigma(sigma)
    , fBlurStyle(style)
    , fRespectCTM(respectCTM) {
    SkASSERT(fSigma > 0);
    SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle);
}

Member Function Documentation

asABlur()

bool SkBlurMaskFilterImpl::asABlur ( BlurRec *  ) const

overridevirtual

If this filter can be represented by a BlurRec, return true and (if not null) fill in the provided BlurRec parameter. If this effect cannot be represented as a BlurRec, return false and ignore the BlurRec parameter.

Reimplemented from SkMaskFilterBase.

Definition at line 62 of file SkBlurMaskFilterImpl.cpp.

                                                     {
    if (this->ignoreXform()) {
        return false;
    }
 
    if (rec) {
        rec->fSigma = fSigma;
        rec->fStyle = fBlurStyle;
    }
    return true;
}

asImageFilter()

sk_sp< SkImageFilter > SkBlurMaskFilterImpl::asImageFilter ( const SkMatrix &  ctm ) const

overridevirtual

Return an SkImageFilter representation of this mask filter that SkCanvas can apply to an alpha-only image to produce an equivalent effect to running the mask filter directly.

Reimplemented from SkMaskFilterBase.

Definition at line 74 of file SkBlurMaskFilterImpl.cpp.

                                                                                  {
    float sigma = fSigma;
    if (this->ignoreXform()) {
        // This is analogous to computeXformedSigma(), but it might be more correct to wrap the
        // blur image filter in a local matrix with ctm^-1, or to control the skif::Mapping when
        // the mask filter layer is restored. This is inaccurate when 'ctm' has skew or perspective
        const float ctmScaleFactor = fSigma / ctm.mapRadius(fSigma);
        sigma *= ctmScaleFactor;
    }
 
    // The null input image filter will be bound to the original coverage mask.
    sk_sp<SkImageFilter> filter = SkImageFilters::Blur(sigma, sigma, nullptr);
    // Combine the original coverage mask (src) and the blurred coverage mask (dst)
    switch(fBlurStyle) {
        case kInner_SkBlurStyle: //  dst = dst * src
                                 //      = 0 * src + src * dst
            return SkImageFilters::Blend(SkBlendMode::kDstIn, std::move(filter), nullptr);
        case kSolid_SkBlurStyle: //  dst = src + dst - src * dst
                                 //      = 1 * src + (1 - src) * dst
            return SkImageFilters::Blend(SkBlendMode::kSrcOver, std::move(filter), nullptr);
        case kOuter_SkBlurStyle: //  dst = dst * (1 - src)
                                 //      = 0 * src + (1 - src) * dst
            return SkImageFilters::Blend(SkBlendMode::kDstOut, std::move(filter), nullptr);
        case kNormal_SkBlurStyle:
            return filter;
    }
    SkUNREACHABLE;
}

blurStyle()

SkBlurStyle SkBlurMaskFilterImpl::blurStyle ( ) const

inline

Definition at line 44 of file SkBlurMaskFilterImpl.h.

{return fBlurStyle;}

computeFastBounds()

void SkBlurMaskFilterImpl::computeFastBounds ( const SkRect &  src, SkRect *  dest  ) const

overridevirtual

The fast bounds function is used to enable the paint to be culled early in the drawing pipeline. This function accepts the current bounds of the paint as its src param and the filter adjust those bounds using its current mask and returns the result using the dest param. Callers are allowed to provide the same struct for both src and dest so each implementation must accommodate that behavior.

The default impl calls filterMask with the src mask having no image, but subclasses may override this if they can compute the rect faster.

Reimplemented from SkMaskFilterBase.

Definition at line 506 of file SkBlurMaskFilterImpl.cpp.

                                                                {
    // TODO: if we're doing kInner blur, should we return a different outset?
    //       i.e. pad == 0 ?
 
    SkScalar pad = 3.0f * fSigma;
 
    dst->setLTRB(src.fLeft  - pad, src.fTop    - pad,
                 src.fRight + pad, src.fBottom + pad);
}

computeXformedSigma()

SkScalar SkBlurMaskFilterImpl::computeXformedSigma

(

const SkMatrix &

ctm

)

const

Definition at line 103 of file SkBlurMaskFilterImpl.cpp.

                                                                            {
    constexpr SkScalar kMaxBlurSigma = SkIntToScalar(128);
    SkScalar xformedSigma = this->ignoreXform() ? fSigma : ctm.mapRadius(fSigma);
    return std::min(xformedSigma, kMaxBlurSigma);
}

filterMask()

bool SkBlurMaskFilterImpl::filterMask ( SkMaskBuilder *  dst, const SkMask &  src, const SkMatrix &  , SkIPoint *  margin  ) const

overridevirtual

Create a new mask by filter the src mask. If src.fImage == null, then do not allocate or create the dst image but do fill out the other fields in dstMask. If you do allocate a dst image, use SkMask::AllocImage() If this returns false, dst mask is ignored.

Parameters

dst	the result of the filter. If src.fImage == null, dst should not allocate its image
src	the original image to be filtered.
matrix	the CTM
margin	if not null, return the buffer dx/dy need when calculating the effect. Used when drawing a clipped object to know how much larger to allocate the src before applying the filter. If returning false, ignore this parameter.

Returns

true if the dst mask was correctly created.

Implements SkMaskFilterBase.

Definition at line 109 of file SkBlurMaskFilterImpl.cpp.

                                                              {
    SkScalar sigma = this->computeXformedSigma(matrix);
    return SkBlurMask::BoxBlur(dst, src, sigma, fBlurStyle, margin);
}

filterRectsToNine()

SkMaskFilterBase::FilterReturn SkBlurMaskFilterImpl::filterRectsToNine ( const SkRect  [], int  count, const SkMatrix &  , const SkIRect &  clipBounds, SkTLazy< NinePatch > *    ) const

overrideprivatevirtual

Override if your subclass can filter a rect, and return the answer as a ninepatch mask to be stretched over the returned outerRect. On success return kTrue_FilterReturn. On failure (e.g. out of memory) return kFalse_FilterReturn. If the normal filterMask() entry-point should be called (the default) return kUnimplemented_FilterReturn.

By convention, the caller will take the center rol/col from the returned mask as the slice it can replicate horizontally and vertically as we stretch the mask to fit inside outerRect. It is an error for outerRect to be smaller than the mask's bounds. This would imply that the width and height of the mask should be odd. This is not required, just that the caller will call mask.fBounds.centerX() and centerY() to find the strips that will be replicated.

Reimplemented from SkMaskFilterBase.

Definition at line 381 of file SkBlurMaskFilterImpl.cpp.

                                                                         {
    if (count < 1 || count > 2) {
        return kUnimplemented_FilterReturn;
    }
 
    // TODO: report correct metrics for innerstyle, where we do not grow the
    // total bounds, but we do need an inset the size of our blur-radius
    if (kInner_SkBlurStyle == fBlurStyle || kOuter_SkBlurStyle == fBlurStyle) {
        return kUnimplemented_FilterReturn;
    }
 
    // TODO: take clipBounds into account to limit our coordinates up front
    // for now, just skip too-large src rects (to take the old code path).
    if (rect_exceeds(rects[0], SkIntToScalar(32767))) {
        return kUnimplemented_FilterReturn;
    }
 
    SkIPoint margin;
    SkMaskBuilder srcM(nullptr, rects[0].roundOut(), 0, SkMask::kA8_Format), dstM;
 
    bool filterResult = false;
    if (count == 1 && c_analyticBlurNinepatch) {
        // special case for fast rect blur
        // don't actually do the blur the first time, just compute the correct size
        filterResult = this->filterRectMask(&dstM, rects[0], matrix, &margin,
                                            SkMaskBuilder::kJustComputeBounds_CreateMode);
    } else {
        filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
    }
 
    if (!filterResult) {
        return kFalse_FilterReturn;
    }
 
    /*
     *  smallR is the smallest version of 'rect' that will still guarantee that
     *  we get the same blur results on all edges, plus 1 center row/col that is
     *  representative of the extendible/stretchable edges of the ninepatch.
     *  Since our actual edge may be fractional we inset 1 more to be sure we
     *  don't miss any interior blur.
     *  x is an added pixel of blur, and { and } are the (fractional) edge
     *  pixels from the original rect.
     *
     *   x x { x x .... x x } x x
     *
     *  Thus, in this case, we inset by a total of 5 (on each side) beginning
     *  with our outer-rect (dstM.fBounds)
     */
    SkRect smallR[2];
    SkIPoint center;
 
    // +2 is from +1 for each edge (to account for possible fractional edges
    int smallW = dstM.fBounds.width() - srcM.fBounds.width() + 2;
    int smallH = dstM.fBounds.height() - srcM.fBounds.height() + 2;
    SkIRect innerIR;
 
    if (1 == count) {
        innerIR = srcM.fBounds;
        center.set(smallW, smallH);
    } else {
        SkASSERT(2 == count);
        rects[1].roundIn(&innerIR);
        center.set(smallW + (innerIR.left() - srcM.fBounds.left()),
                   smallH + (innerIR.top() - srcM.fBounds.top()));
    }
 
    // +1 so we get a clean, stretchable, center row/col
    smallW += 1;
    smallH += 1;
 
    // we want the inset amounts to be integral, so we don't change any
    // fractional phase on the fRight or fBottom of our smallR.
    const SkScalar dx = SkIntToScalar(innerIR.width() - smallW);
    const SkScalar dy = SkIntToScalar(innerIR.height() - smallH);
    if (dx < 0 || dy < 0) {
        // we're too small, relative to our blur, to break into nine-patch,
        // so we ask to have our normal filterMask() be called.
        return kUnimplemented_FilterReturn;
    }
 
    smallR[0].setLTRB(rects[0].left(),       rects[0].top(),
                      rects[0].right() - dx, rects[0].bottom() - dy);
    if (smallR[0].width() < 2 || smallR[0].height() < 2) {
        return kUnimplemented_FilterReturn;
    }
    if (2 == count) {
        smallR[1].setLTRB(rects[1].left(), rects[1].top(),
                          rects[1].right() - dx, rects[1].bottom() - dy);
        SkASSERT(!smallR[1].isEmpty());
    }
 
    const SkScalar sigma = this->computeXformedSigma(matrix);
    SkTLazy<SkMask> cachedMask;
    SkCachedData* cache = find_cached_rects(&cachedMask, sigma, fBlurStyle, smallR, count);
    if (!cache) {
        SkMaskBuilder filterM;
        if (count > 1 || !c_analyticBlurNinepatch) {
            if (!draw_rects_into_mask(smallR, count, &srcM)) {
                return kFalse_FilterReturn;
            }
 
            SkAutoMaskFreeImage amf(srcM.image());
 
            if (!this->filterMask(&filterM, srcM, matrix, &margin)) {
                return kFalse_FilterReturn;
            }
        } else {
            if (!this->filterRectMask(&filterM, smallR[0], matrix, &margin,
                                      SkMaskBuilder::kComputeBoundsAndRenderImage_CreateMode)) {
                return kFalse_FilterReturn;
            }
        }
        cache = add_cached_rects(&filterM, sigma, fBlurStyle, smallR, count);
        cachedMask.init(filterM);
    }
    SkIRect bounds = cachedMask->fBounds;
    bounds.offsetTo(0, 0);
    patch->init(SkMask{cachedMask->fImage, bounds, cachedMask->fRowBytes, cachedMask->fFormat},
                dstM.fBounds, center, cache); // transfer ownership to patch
    return kTrue_FilterReturn;
}

filterRRectToNine()

SkMaskFilterBase::FilterReturn SkBlurMaskFilterImpl::filterRRectToNine ( const SkRRect &  , const SkMatrix &  , const SkIRect &  clipBounds, SkTLazy< NinePatch > *    ) const

overrideprivatevirtual

Similar to filterRectsToNine, except it performs the work on a round rect.

Reimplemented from SkMaskFilterBase.

Definition at line 245 of file SkBlurMaskFilterImpl.cpp.

                                                                         {
    SkASSERT(patch != nullptr);
    switch (rrect.getType()) {
        case SkRRect::kEmpty_Type:
            // Nothing to draw.
            return kFalse_FilterReturn;
 
        case SkRRect::kRect_Type:
            // We should have caught this earlier.
            SkASSERT(false);
            [[fallthrough]];
        case SkRRect::kOval_Type:
            // The nine patch special case does not handle ovals, and we
            // already have code for rectangles.
            return kUnimplemented_FilterReturn;
 
        // These three can take advantage of this fast path.
        case SkRRect::kSimple_Type:
        case SkRRect::kNinePatch_Type:
        case SkRRect::kComplex_Type:
            break;
    }
 
    // TODO: report correct metrics for innerstyle, where we do not grow the
    // total bounds, but we do need an inset the size of our blur-radius
    if (kInner_SkBlurStyle == fBlurStyle) {
        return kUnimplemented_FilterReturn;
    }
 
    // TODO: take clipBounds into account to limit our coordinates up front
    // for now, just skip too-large src rects (to take the old code path).
    if (rect_exceeds(rrect.rect(), SkIntToScalar(32767))) {
        return kUnimplemented_FilterReturn;
    }
 
    SkIPoint margin;
    SkMaskBuilder srcM(nullptr, rrect.rect().roundOut(), 0, SkMask::kA8_Format), dstM;
 
    bool filterResult = false;
    if (c_analyticBlurRRect) {
        // special case for fast round rect blur
        // don't actually do the blur the first time, just compute the correct size
        filterResult = this->filterRRectMask(&dstM, rrect, matrix, &margin,
                                             SkMaskBuilder::kJustComputeBounds_CreateMode);
    }
 
    if (!filterResult) {
        filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
    }
 
    if (!filterResult) {
        return kFalse_FilterReturn;
    }
 
    // Now figure out the appropriate width and height of the smaller round rectangle
    // to stretch. It will take into account the larger radius per side as well as double
    // the margin, to account for inner and outer blur.
    const SkVector& UL = rrect.radii(SkRRect::kUpperLeft_Corner);
    const SkVector& UR = rrect.radii(SkRRect::kUpperRight_Corner);
    const SkVector& LR = rrect.radii(SkRRect::kLowerRight_Corner);
    const SkVector& LL = rrect.radii(SkRRect::kLowerLeft_Corner);
 
    const SkScalar leftUnstretched = std::max(UL.fX, LL.fX) + SkIntToScalar(2 * margin.fX);
    const SkScalar rightUnstretched = std::max(UR.fX, LR.fX) + SkIntToScalar(2 * margin.fX);
 
    // Extra space in the middle to ensure an unchanging piece for stretching. Use 3 to cover
    // any fractional space on either side plus 1 for the part to stretch.
    const SkScalar stretchSize = SkIntToScalar(3);
 
    const SkScalar totalSmallWidth = leftUnstretched + rightUnstretched + stretchSize;
    if (totalSmallWidth >= rrect.rect().width()) {
        // There is no valid piece to stretch.
        return kUnimplemented_FilterReturn;
    }
 
    const SkScalar topUnstretched = std::max(UL.fY, UR.fY) + SkIntToScalar(2 * margin.fY);
    const SkScalar bottomUnstretched = std::max(LL.fY, LR.fY) + SkIntToScalar(2 * margin.fY);
 
    const SkScalar totalSmallHeight = topUnstretched + bottomUnstretched + stretchSize;
    if (totalSmallHeight >= rrect.rect().height()) {
        // There is no valid piece to stretch.
        return kUnimplemented_FilterReturn;
    }
 
    SkRect smallR = SkRect::MakeWH(totalSmallWidth, totalSmallHeight);
 
    SkRRect smallRR;
    SkVector radii[4];
    radii[SkRRect::kUpperLeft_Corner] = UL;
    radii[SkRRect::kUpperRight_Corner] = UR;
    radii[SkRRect::kLowerRight_Corner] = LR;
    radii[SkRRect::kLowerLeft_Corner] = LL;
    smallRR.setRectRadii(smallR, radii);
 
    const SkScalar sigma = this->computeXformedSigma(matrix);
    SkTLazy<SkMask> cachedMask;
    SkCachedData* cache = find_cached_rrect(&cachedMask, sigma, fBlurStyle, smallRR);
    if (!cache) {
        SkMaskBuilder filterM;
        bool analyticBlurWorked = false;
        if (c_analyticBlurRRect) {
            analyticBlurWorked =
                this->filterRRectMask(&filterM, smallRR, matrix, &margin,
                                      SkMaskBuilder::kComputeBoundsAndRenderImage_CreateMode);
        }
 
        if (!analyticBlurWorked) {
            if (!draw_rrect_into_mask(smallRR, &srcM)) {
                return kFalse_FilterReturn;
            }
            SkAutoMaskFreeImage amf(srcM.image());
 
            if (!this->filterMask(&filterM, srcM, matrix, &margin)) {
                return kFalse_FilterReturn;
            }
        }
        cache = add_cached_rrect(&filterM, sigma, fBlurStyle, smallRR);
        cachedMask.init(filterM);
    }
 
    SkIRect bounds = cachedMask->fBounds;
    bounds.offsetTo(0, 0);
    patch->init(SkMask{cachedMask->fImage, bounds, cachedMask->fRowBytes, cachedMask->fFormat},
                dstM.fBounds,
                SkIPoint{SkScalarCeilToInt(leftUnstretched) + 1,
                         SkScalarCeilToInt(topUnstretched) + 1},
                cache); // transfer ownership to patch
    return kTrue_FilterReturn;
}

flatten()

void SkBlurMaskFilterImpl::flatten ( SkWriteBuffer &  ) const

overrideprivatevirtual

Override this if your subclass needs to record data that it will need to recreate itself from its CreateProc (returned by getFactory()).

DEPRECATED public : will move to protected ... use serialize() instead

Reimplemented from SkFlattenable.

Definition at line 527 of file SkBlurMaskFilterImpl.cpp.

                                                              {
    buffer.writeScalar(fSigma);
    buffer.writeUInt(fBlurStyle);
    buffer.writeUInt(!fRespectCTM); // historically we recorded ignoreCTM
}

getFormat()

SkMask::Format SkBlurMaskFilterImpl::getFormat ( ) const

overridevirtual

Returns the format of the resulting mask that this subclass will return when its filterMask() method is called.

Implements SkMaskFilterBase.

Definition at line 58 of file SkBlurMaskFilterImpl.cpp.

                                                   {
    return SkMask::kA8_Format;
}

ignoreXform()

bool SkBlurMaskFilterImpl::ignoreXform ( ) const

inline

Definition at line 46 of file SkBlurMaskFilterImpl.h.

{ return !fRespectCTM; }

sigma()

SkScalar SkBlurMaskFilterImpl::sigma ( ) const

inline

Definition at line 45 of file SkBlurMaskFilterImpl.h.

{return fSigma;}

type()

SkMaskFilterBase::Type SkBlurMaskFilterImpl::type ( ) const

inlineoverridevirtual

Implements SkMaskFilterBase.

Definition at line 36 of file SkBlurMaskFilterImpl.h.

{ return SkMaskFilterBase::Type::kBlur; }

Friends And Related Symbol Documentation

sk_register_blur_maskfilter_createproc

void sk_register_blur_maskfilter_createproc ( )

friend

Definition at line 533 of file SkBlurMaskFilterImpl.cpp.

{ SK_REGISTER_FLATTENABLE(SkBlurMaskFilterImpl); }

SkBlurMaskFilter

friend class SkBlurMaskFilter

friend

Definition at line 71 of file SkBlurMaskFilterImpl.h.

---

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

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