SkMaskFilter.cpp File Reference

#include "include/core/SkMaskFilter.h"
#include "include/core/SkFlattenable.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPath.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkRegion.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkTemplates.h"
#include "src/base/SkAutoMalloc.h"
#include "src/base/SkTLazy.h"
#include "src/core/SkBlitter.h"
#include "src/core/SkCachedData.h"
#include "src/core/SkDraw.h"
#include "src/core/SkMask.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkPathPriv.h"
#include "src/core/SkRasterClip.h"
#include <algorithm>
#include <cstdint>

Go to the source code of this file.

Functions
static SkMask	extractMaskSubset (const SkMask &src, SkIRect bounds, int32_t newX, int32_t newY)
static void	blitClippedMask (SkBlitter *blitter, const SkMask &mask, const SkIRect &bounds, const SkIRect &clipR)
static void	blitClippedRect (SkBlitter *blitter, const SkIRect &rect, const SkIRect &clipR)
static void	draw_nine_clipped (const SkMask &mask, const SkIRect &outerR, const SkIPoint &center, bool fillCenter, const SkIRect &clipR, SkBlitter *blitter)
static void	draw_nine (const SkMask &mask, const SkIRect &outerR, const SkIPoint &center, bool fillCenter, const SkRasterClip &clip, SkBlitter *blitter)
static int	countNestedRects (const SkPath &path, SkRect rects[2])

Function Documentation

blitClippedMask()

static void blitClippedMask ( SkBlitter *  blitter, const SkMask &  mask, const SkIRect &  bounds, const SkIRect &  clipR  )

static

Definition at line 66 of file SkMaskFilter.cpp.

                                                                         {
    SkIRect r;
    if (r.intersect(bounds, clipR)) {
        blitter->blitMask(mask, r);
    }
}

blitClippedRect()

static void blitClippedRect ( SkBlitter *  blitter, const SkIRect &  rect, const SkIRect &  clipR  )

static

Definition at line 74 of file SkMaskFilter.cpp.

                                                                                           {
    SkIRect r;
    if (r.intersect(rect, clipR)) {
        blitter->blitRect(r.left(), r.top(), r.width(), r.height());
    }
}

countNestedRects()

static int countNestedRects ( const SkPath &  path, SkRect  rects[2]  )

static

Definition at line 206 of file SkMaskFilter.cpp.

                                                                 {
    if (SkPathPriv::IsNestedFillRects(path, rects)) {
        return 2;
    }
    return path.isRect(&rects[0]);
}

draw_nine()

static void draw_nine ( const SkMask &  mask, const SkIRect &  outerR, const SkIPoint &  center, bool  fillCenter, const SkRasterClip &  clip, SkBlitter *  blitter  )

static

Definition at line 189 of file SkMaskFilter.cpp.

                                                                                     {
    // if we get here, we need to (possibly) resolve the clip and blitter
    SkAAClipBlitterWrapper wrapper(clip, blitter);
    blitter = wrapper.getBlitter();
 
    SkRegion::Cliperator clipper(wrapper.getRgn(), outerR);
 
    if (!clipper.done()) {
        const SkIRect& cr = clipper.rect();
        do {
            draw_nine_clipped(mask, outerR, center, fillCenter, cr, blitter);
            clipper.next();
        } while (!clipper.done());
    }
}

draw_nine_clipped()

static void draw_nine_clipped ( const SkMask &  mask, const SkIRect &  outerR, const SkIPoint &  center, bool  fillCenter, const SkIRect &  clipR, SkBlitter *  blitter  )

static

Definition at line 81 of file SkMaskFilter.cpp.

                                                                        {
    int cx = center.x();
    int cy = center.y();
    SkIRect bounds;
 
    // top-left
    bounds = mask.fBounds;
    bounds.fRight = cx;
    bounds.fBottom = cy;
    if (bounds.width() > 0 && bounds.height() > 0) {
        SkMask m = extractMaskSubset(mask, bounds, outerR.left(), outerR.top());
        blitClippedMask(blitter, m, m.fBounds, clipR);
    }
 
    // top-right
    bounds = mask.fBounds;
    bounds.fLeft = cx + 1;
    bounds.fBottom = cy;
    if (bounds.width() > 0 && bounds.height() > 0) {
        SkMask m = extractMaskSubset(mask, bounds, outerR.right() - bounds.width(), outerR.top());
        blitClippedMask(blitter, m, m.fBounds, clipR);
    }
 
    // bottom-left
    bounds = mask.fBounds;
    bounds.fRight = cx;
    bounds.fTop = cy + 1;
    if (bounds.width() > 0 && bounds.height() > 0) {
        SkMask m = extractMaskSubset(mask, bounds, outerR.left(), outerR.bottom() - bounds.height());
        blitClippedMask(blitter, m, m.fBounds, clipR);
    }
 
    // bottom-right
    bounds = mask.fBounds;
    bounds.fLeft = cx + 1;
    bounds.fTop = cy + 1;
    if (bounds.width() > 0 && bounds.height() > 0) {
        SkMask m = extractMaskSubset(mask, bounds, outerR.right() - bounds.width(),
                                                   outerR.bottom() - bounds.height());
        blitClippedMask(blitter, m, m.fBounds, clipR);
    }
 
    SkIRect innerR;
    innerR.setLTRB(outerR.left() + cx - mask.fBounds.left(),
                   outerR.top() + cy - mask.fBounds.top(),
                   outerR.right() + (cx + 1 - mask.fBounds.right()),
                   outerR.bottom() + (cy + 1 - mask.fBounds.bottom()));
    if (fillCenter) {
        blitClippedRect(blitter, innerR, clipR);
    }
 
    const int innerW = innerR.width();
    size_t storageSize = (innerW + 1) * (sizeof(int16_t) + sizeof(uint8_t));
    SkAutoSMalloc<4*1024> storage(storageSize);
    int16_t* runs = (int16_t*)storage.get();
    uint8_t* alpha = (uint8_t*)(runs + innerW + 1);
 
    SkIRect r;
    // top
    r.setLTRB(innerR.left(), outerR.top(), innerR.right(), innerR.top());
    if (r.intersect(clipR)) {
        int startY = std::max(0, r.top() - outerR.top());
        int stopY = startY + r.height();
        int width = r.width();
        for (int y = startY; y < stopY; ++y) {
            runs[0] = width;
            runs[width] = 0;
            alpha[0] = *mask.getAddr8(cx, mask.fBounds.top() + y);
            blitter->blitAntiH(r.left(), outerR.top() + y, alpha, runs);
        }
    }
    // bottom
    r.setLTRB(innerR.left(), innerR.bottom(), innerR.right(), outerR.bottom());
    if (r.intersect(clipR)) {
        int startY = outerR.bottom() - r.bottom();
        int stopY = startY + r.height();
        int width = r.width();
        for (int y = startY; y < stopY; ++y) {
            runs[0] = width;
            runs[width] = 0;
            alpha[0] = *mask.getAddr8(cx, mask.fBounds.bottom() - y - 1);
            blitter->blitAntiH(r.left(), outerR.bottom() - y - 1, alpha, runs);
        }
    }
    // left
    r.setLTRB(outerR.left(), innerR.top(), innerR.left(), innerR.bottom());
    if (r.intersect(clipR)) {
        SkMask leftMask(mask.getAddr8(mask.fBounds.left() + r.left() - outerR.left(),
                                      mask.fBounds.top() + cy),
                        r,
                        0,    // so we repeat the scanline for our height
                        SkMask::kA8_Format);
        blitter->blitMask(leftMask, r);
    }
    // right
    r.setLTRB(innerR.right(), innerR.top(), outerR.right(), innerR.bottom());
    if (r.intersect(clipR)) {
        SkMask rightMask(mask.getAddr8(mask.fBounds.right() - outerR.right() + r.left(),
                                       mask.fBounds.top() + cy),
                         r,
                         0,    // so we repeat the scanline for our height
                         SkMask::kA8_Format);
        blitter->blitMask(rightMask, r);
    }
}

extractMaskSubset()

static SkMask extractMaskSubset ( const SkMask &  src, SkIRect  bounds, int32_t  newX, int32_t  newY  )

static

Definition at line 54 of file SkMaskFilter.cpp.

                                                                                               {
    SkASSERT(src.fBounds.contains(bounds));
 
    const int dx = bounds.left() - src.fBounds.left();
    const int dy = bounds.top() - src.fBounds.top();
    bounds.offsetTo(newX, newY);
    return SkMask(src.fImage + dy * src.fRowBytes + dx,
                  bounds,
                  src.fRowBytes,
                  src.fFormat);
}