SkBlurMaskFilterImpl.cpp File Reference

#include "src/core/SkBlurMaskFilterImpl.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkBlurTypes.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMaskFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathBuilder.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRRect.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/effects/SkImageFilters.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkTLazy.h"
#include "src/core/SkBlitter_A8.h"
#include "src/core/SkBlurMask.h"
#include "src/core/SkCachedData.h"
#include "src/core/SkDrawBase.h"
#include "src/core/SkMask.h"
#include "src/core/SkMaskCache.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkResourceCache.h"
#include "src/core/SkWriteBuffer.h"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <utility>

Go to the source code of this file.

Functions
static bool	prepare_to_draw_into_mask (const SkRect &bounds, SkMaskBuilder *mask)
template<typename Proc >
bool	draw_into_mask (SkMaskBuilder *mask, const SkRect &bounds, Proc proc)
static bool	draw_rects_into_mask (const SkRect rects[], int count, SkMaskBuilder *mask)
static bool	draw_rrect_into_mask (const SkRRect rrect, SkMaskBuilder *mask)
static bool	rect_exceeds (const SkRect &r, SkScalar v)
static SkCachedData *	copy_mask_to_cacheddata (SkMaskBuilder *mask)
static SkCachedData *	find_cached_rrect (SkTLazy< SkMask > *mask, SkScalar sigma, SkBlurStyle style, const SkRRect &rrect)
static SkCachedData *	add_cached_rrect (SkMaskBuilder *mask, SkScalar sigma, SkBlurStyle style, const SkRRect &rrect)
static SkCachedData *	find_cached_rects (SkTLazy< SkMask > *mask, SkScalar sigma, SkBlurStyle style, const SkRect rects[], int count)
static SkCachedData *	add_cached_rects (SkMaskBuilder *mask, SkScalar sigma, SkBlurStyle style, const SkRect rects[], int count)
void	sk_register_blur_maskfilter_createproc ()

Variables
static const bool	c_analyticBlurRRect {true}
static const bool	c_analyticBlurNinepatch {true}

Function Documentation

add_cached_rects()

static SkCachedData * add_cached_rects ( SkMaskBuilder *  mask, SkScalar  sigma, SkBlurStyle  style, const SkRect  rects[], int  count  )

static

Definition at line 233 of file SkBlurMaskFilterImpl.cpp.

                                                                       {
    SkCachedData* cache = copy_mask_to_cacheddata(mask);
    if (cache) {
        SkMaskCache::Add(sigma, style, rects, count, *mask, cache);
    }
    return cache;
}

add_cached_rrect()

static SkCachedData * add_cached_rrect ( SkMaskBuilder *  mask, SkScalar  sigma, SkBlurStyle  style, const SkRRect &  rrect  )

static

Definition at line 219 of file SkBlurMaskFilterImpl.cpp.

                                                            {
    SkCachedData* cache = copy_mask_to_cacheddata(mask);
    if (cache) {
        SkMaskCache::Add(sigma, style, rrect, *mask, cache);
    }
    return cache;
}

copy_mask_to_cacheddata()

static SkCachedData * copy_mask_to_cacheddata ( SkMaskBuilder *  mask )

static

Definition at line 203 of file SkBlurMaskFilterImpl.cpp.

                                                                  {
    const size_t size = mask->computeTotalImageSize();
    SkCachedData* data = SkResourceCache::NewCachedData(size);
    if (data) {
        memcpy(data->writable_data(), mask->fImage, size);
        SkMaskBuilder::FreeImage(mask->image());
        mask->image() = (uint8_t*)data->writable_data();
    }
    return data;
}

draw_into_mask()

template<typename Proc >

bool draw_into_mask	(	SkMaskBuilder *	mask,
		const SkRect &	bounds,
		Proc	proc
	)

Definition at line 148 of file SkBlurMaskFilterImpl.cpp.

                                                                                                   {
    if (!prepare_to_draw_into_mask(bounds, mask)) {
        return false;
    }
 
    const int dx = mask->fBounds.fLeft;
    const int dy = mask->fBounds.fTop;
    SkRasterClip rclip(mask->fBounds);
    rclip.setRect(mask->fBounds.makeOffset(-dx, -dy));
 
    SkASSERT(mask->fFormat == SkMask::kA8_Format);
    auto info = SkImageInfo::MakeA8(mask->fBounds.width(), mask->fBounds.height());
    auto pm = SkPixmap(info, mask->fImage, mask->fRowBytes);
 
    SkMatrix ctm = SkMatrix::Translate(-SkIntToScalar(dx), -SkIntToScalar(dy));
 
    SkDrawBase draw;
    draw.fBlitterChooser = SkA8Blitter_Choose;
    draw.fCTM = &ctm;
    draw.fDst = pm;
    draw.fRC  = &rclip;
 
    SkPaint paint;
    paint.setAntiAlias(true);
 
    proc(draw, paint);
    return true;
}

draw_rects_into_mask()

static bool draw_rects_into_mask ( const SkRect  rects[], int  count, SkMaskBuilder *  mask  )

static

Definition at line 177 of file SkBlurMaskFilterImpl.cpp.

                                                                                       {
    return draw_into_mask(mask, rects[0], [&](SkDrawBase& draw, const SkPaint& paint) {
        if (1 == count) {
            draw.drawRect(rects[0], paint);
        } else {
            // todo: do I need a fast way to do this?
            SkPath path = SkPathBuilder().addRect(rects[0])
                                         .addRect(rects[1])
                                         .setFillType(SkPathFillType::kEvenOdd)
                                         .detach();
            draw.drawPath(path, paint);
        }
    });
}

draw_rrect_into_mask()

static bool draw_rrect_into_mask ( const SkRRect  rrect, SkMaskBuilder *  mask  )

static

Definition at line 192 of file SkBlurMaskFilterImpl.cpp.

                                                                           {
    return draw_into_mask(mask, rrect.rect(), [&](SkDrawBase& draw, const SkPaint& paint) {
        draw.drawRRect(rrect, paint);
    });
}

find_cached_rects()

static SkCachedData * find_cached_rects ( SkTLazy< SkMask > *  mask, SkScalar  sigma, SkBlurStyle  style, const SkRect  rects[], int  count  )

static

Definition at line 228 of file SkBlurMaskFilterImpl.cpp.

                                                                        {
    return SkMaskCache::FindAndRef(sigma, style, rects, count, mask);
}

find_cached_rrect()

static SkCachedData * find_cached_rrect ( SkTLazy< SkMask > *  mask, SkScalar  sigma, SkBlurStyle  style, const SkRRect &  rrect  )

static

Definition at line 214 of file SkBlurMaskFilterImpl.cpp.

                                                             {
    return SkMaskCache::FindAndRef(sigma, style, rrect, mask);
}

prepare_to_draw_into_mask()

static bool prepare_to_draw_into_mask ( const SkRect &  bounds, SkMaskBuilder *  mask  )

static

Definition at line 134 of file SkBlurMaskFilterImpl.cpp.

                                                                                 {
    SkASSERT(mask != nullptr);
 
    mask->bounds() = bounds.roundOut();
    mask->rowBytes() = SkAlign4(mask->fBounds.width());
    mask->format() = SkMask::kA8_Format;
    const size_t size = mask->computeImageSize();
    mask->image() = SkMaskBuilder::AllocImage(size, SkMaskBuilder::kZeroInit_Alloc);
    if (nullptr == mask->fImage) {
        return false;
    }
    return true;
}

rect_exceeds()

static bool rect_exceeds ( const SkRect &  r, SkScalar  v  )

static

Definition at line 198 of file SkBlurMaskFilterImpl.cpp.

                                                      {
    return r.fLeft < -v || r.fTop < -v || r.fRight > v || r.fBottom > v ||
           r.width() > v || r.height() > v;
}

sk_register_blur_maskfilter_createproc()

void sk_register_blur_maskfilter_createproc

(

)

Definition at line 533 of file SkBlurMaskFilterImpl.cpp.

{ SK_REGISTER_FLATTENABLE(SkBlurMaskFilterImpl); }

Variable Documentation

c_analyticBlurNinepatch

const bool c_analyticBlurNinepatch {true}

static

Definition at line 378 of file SkBlurMaskFilterImpl.cpp.

c_analyticBlurRRect

const bool c_analyticBlurRRect {true}

static

Definition at line 242 of file SkBlurMaskFilterImpl.cpp.