SkScan_Antihair.cpp File Reference

#include "include/core/SkColorPriv.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRegion.h"
#include "include/core/SkScalar.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFixed.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkSafe32.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkBlitter.h"
#include "src/core/SkFDot6.h"
#include "src/core/SkLineClipper.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkScan.h"
#include <algorithm>
#include <cstdint>

Go to the source code of this file.

Classes
class	SkAntiHairBlitter
class	HLine_SkAntiHairBlitter
class	Horish_SkAntiHairBlitter
class	VLine_SkAntiHairBlitter
class	Vertish_SkAntiHairBlitter

Macros
#define	OUTSET_BEFORE_CLIP_TEST   true
#define	HLINE_STACK_BUFFER   100
#define	ApplyGamma(table, alpha)   SkToU8(alpha)
#define	SkBITCOUNT(x)   (sizeof(x) << 3)
#define	SkAlphaMulRound(a, b)   SkMulDiv255Round(a, b)

Typedefs
typedef int	FDot8

Functions
static int	SmallDot6Scale (int value, int dot6)
static void	call_hline_blitter (SkBlitter *blitter, int x, int y, int count, U8CPU alpha)
static SkFixed	fastfixdiv (SkFDot6 a, SkFDot6 b)
static int	bad_int (int x)
static int	any_bad_ints (int a, int b, int c, int d)
static int	contribution_64 (SkFDot6 ordinate)
static void	do_anti_hairline (SkFDot6 x0, SkFDot6 y0, SkFDot6 x1, SkFDot6 y1, const SkIRect *clip, SkBlitter *blitter)
static FDot8	SkFixedToFDot8 (SkFixed x)
static void	do_scanline (FDot8 L, int top, FDot8 R, U8CPU alpha, SkBlitter *blitter)
static void	antifilldot8 (FDot8 L, FDot8 T, FDot8 R, FDot8 B, SkBlitter *blitter, bool fillInner)
static void	antifillrect (const SkXRect &xr, SkBlitter *blitter)
static void	antifillrect (const SkRect &r, SkBlitter *blitter)
static void	fillcheckrect (int L, int T, int R, int B, SkBlitter *blitter)
static FDot8	SkScalarToFDot8 (SkScalar x)
static int	FDot8Floor (FDot8 x)
static int	FDot8Ceil (FDot8 x)
static U8CPU	InvAlphaMul (U8CPU a, U8CPU b)
static void	inner_scanline (FDot8 L, int top, FDot8 R, U8CPU alpha, SkBlitter *blitter)
static void	innerstrokedot8 (FDot8 L, FDot8 T, FDot8 R, FDot8 B, SkBlitter *blitter)
static void	align_thin_stroke (FDot8 &edge1, FDot8 &edge2)

Macro Definition Documentation

ApplyGamma

#define ApplyGamma	(		table,
			alpha
	)		SkToU8(alpha)

Definition at line 75 of file SkScan_Antihair.cpp.

HLINE_STACK_BUFFER

#define HLINE_STACK_BUFFER   100

Definition at line 44 of file SkScan_Antihair.cpp.

OUTSET_BEFORE_CLIP_TEST

#define OUTSET_BEFORE_CLIP_TEST   true

Definition at line 42 of file SkScan_Antihair.cpp.

SkAlphaMulRound

#define SkAlphaMulRound	(		a,
			b
	)		SkMulDiv255Round(a, b)

Definition at line 834 of file SkScan_Antihair.cpp.

SkBITCOUNT

#define SkBITCOUNT

(

x

)

(sizeof(x) << 3)

Definition at line 275 of file SkScan_Antihair.cpp.

Typedef Documentation

FDot8

typedef int FDot8

Definition at line 635 of file SkScan_Antihair.cpp.

Function Documentation

align_thin_stroke()

static void align_thin_stroke ( FDot8 &  edge1, FDot8 &  edge2  )

inlinestatic

Definition at line 927 of file SkScan_Antihair.cpp.

                                                                 {
    SkASSERT(edge1 <= edge2);
 
    if (FDot8Floor(edge1) == FDot8Floor(edge2)) {
        edge2 -= (edge1 & 0xFF);
        edge1 &= ~0xFF;
    }
}

antifilldot8()

static void antifilldot8 ( FDot8  L, FDot8  T, FDot8  R, FDot8  B, SkBlitter *  blitter, bool  fillInner  )

static

Definition at line 667 of file SkScan_Antihair.cpp.

                                         {
    // check for empty now that we're in our reduced precision space
    if (L >= R || T >= B) {
        return;
    }
    int top = T >> 8;
    if (top == ((B - 1) >> 8)) {   // just one scanline high
        do_scanline(L, top, R, B - T - 1, blitter);
        return;
    }
 
    if (T & 0xFF) {
        do_scanline(L, top, R, 256 - (T & 0xFF), blitter);
        top += 1;
    }
 
    int bot = B >> 8;
    int height = bot - top;
    if (height > 0) {
        int left = L >> 8;
        if (left == ((R - 1) >> 8)) {   // just 1-pixel wide
            blitter->blitV(left, top, height, R - L - 1);
        } else {
            if (L & 0xFF) {
                blitter->blitV(left, top, height, 256 - (L & 0xFF));
                left += 1;
            }
            int rite = R >> 8;
            int width = rite - left;
            if (width > 0 && fillInner) {
                blitter->blitRect(left, top, width, height);
            }
            if (R & 0xFF) {
                blitter->blitV(rite, top, height, R & 0xFF);
            }
        }
    }
 
    if (B & 0xFF) {
        do_scanline(L, bot, R, B & 0xFF, blitter);
    }
}

antifillrect() [1/2]

static void antifillrect ( const SkRect &  r, SkBlitter *  blitter  )

static

Definition at line 779 of file SkScan_Antihair.cpp.

                                                              {
    SkXRect xr;
 
    XRect_set(&xr, r);
    antifillrect(xr, blitter);
}

antifillrect() [2/2]

static void antifillrect ( const SkXRect &  xr, SkBlitter *  blitter  )

static

Definition at line 711 of file SkScan_Antihair.cpp.

                                                                {
    antifilldot8(SkFixedToFDot8(xr.fLeft), SkFixedToFDot8(xr.fTop),
                 SkFixedToFDot8(xr.fRight), SkFixedToFDot8(xr.fBottom),
                 blitter, true);
}

any_bad_ints()

static int any_bad_ints ( int  a, int  b, int  c, int  d  )

static

Definition at line 283 of file SkScan_Antihair.cpp.

                                                    {
    return (bad_int(a) | bad_int(b) | bad_int(c) | bad_int(d)) >> (SkBITCOUNT(int) - 1);
}

bad_int()

static int bad_int ( int  x )

inlinestatic

Definition at line 279 of file SkScan_Antihair.cpp.

                                 {
    return x & -x;
}

call_hline_blitter()

static void call_hline_blitter ( SkBlitter *  blitter, int  x, int  y, int  count, U8CPU  alpha  )

static

Definition at line 80 of file SkScan_Antihair.cpp.

                                            {
    SkASSERT(count > 0);
 
    int16_t runs[HLINE_STACK_BUFFER + 1];
    uint8_t  aa[HLINE_STACK_BUFFER];
 
    do {
        // In theory, we should be able to just do this once (outside of the loop),
        // since aa[] and runs[] are supposed" to be const when we call the blitter.
        // In reality, some wrapper-blitters (e.g. SkRgnClipBlitter) cast away that
        // constness, and modify the buffers in-place. Hence the need to be defensive
        // here and reseed the aa value.
        aa[0] = ApplyGamma(gGammaTable, alpha);
 
        int n = count;
        if (n > HLINE_STACK_BUFFER) {
            n = HLINE_STACK_BUFFER;
        }
        runs[0] = SkToS16(n);
        runs[n] = 0;
        blitter->blitAntiH(x, y, aa, runs);
        x += n;
        count -= n;
    } while (count > 0);
}

contribution_64()

static int contribution_64 ( SkFDot6  ordinate )

static

Definition at line 309 of file SkScan_Antihair.cpp.

                                             {
#if 0
    int result = ordinate & 63;
    if (0 == result) {
        result = 64;
    }
#else
    int result = ((ordinate - 1) & 63) + 1;
#endif
    SkASSERT(result > 0 && result <= 64);
    return result;
}

do_anti_hairline()

static void do_anti_hairline ( SkFDot6  x0, SkFDot6  y0, SkFDot6  x1, SkFDot6  y1, const SkIRect *  clip, SkBlitter *  blitter  )

static

Definition at line 322 of file SkScan_Antihair.cpp.

                                                                      {
    // check for integer NaN (0x80000000) which we can't handle (can't negate it)
    // It appears typically from a huge float (inf or nan) being converted to int.
    // If we see it, just don't draw.
    if (any_bad_ints(x0, y0, x1, y1)) {
        return;
    }
 
    // The caller must clip the line to [-32767.0 ... 32767.0] ahead of time
    // (in dot6 format)
    SkASSERT(canConvertFDot6ToFixed(x0));
    SkASSERT(canConvertFDot6ToFixed(y0));
    SkASSERT(canConvertFDot6ToFixed(x1));
    SkASSERT(canConvertFDot6ToFixed(y1));
 
    if (SkAbs32(x1 - x0) > SkIntToFDot6(511) || SkAbs32(y1 - y0) > SkIntToFDot6(511)) {
        /*  instead of (x0 + x1) >> 1, we shift each separately. This is less
            precise, but avoids overflowing the intermediate result if the
            values are huge. A better fix might be to clip the original pts
            directly (i.e. do the divide), so we don't spend time subdividing
            huge lines at all.
         */
        int hx = (x0 >> 1) + (x1 >> 1);
        int hy = (y0 >> 1) + (y1 >> 1);
        do_anti_hairline(x0, y0, hx, hy, clip, blitter);
        do_anti_hairline(hx, hy, x1, y1, clip, blitter);
        return;
    }
 
    int         scaleStart, scaleStop;
    int         istart, istop;
    SkFixed     fstart, slope;
 
    HLine_SkAntiHairBlitter     hline_blitter;
    Horish_SkAntiHairBlitter    horish_blitter;
    VLine_SkAntiHairBlitter     vline_blitter;
    Vertish_SkAntiHairBlitter   vertish_blitter;
    SkAntiHairBlitter*          hairBlitter = nullptr;
 
    if (SkAbs32(x1 - x0) > SkAbs32(y1 - y0)) {   // mostly horizontal
        if (x0 > x1) {    // we want to go left-to-right
            using std::swap;
            swap(x0, x1);
            swap(y0, y1);
        }
 
        istart = SkFDot6Floor(x0);
        istop = SkFDot6Ceil(x1);
        fstart = SkFDot6ToFixed(y0);
        if (y0 == y1) {   // completely horizontal, take fast case
            slope = 0;
            hairBlitter = &hline_blitter;
        } else {
            slope = fastfixdiv(y1 - y0, x1 - x0);
            SkASSERT(slope >= -SK_Fixed1 && slope <= SK_Fixed1);
            fstart += (slope * (32 - (x0 & 63)) + 32) >> 6;
            hairBlitter = &horish_blitter;
        }
 
        SkASSERT(istop > istart);
        if (istop - istart == 1) {
            // we are within a single pixel
            scaleStart = x1 - x0;
            SkASSERT(scaleStart >= 0 && scaleStart <= 64);
            scaleStop = 0;
        } else {
            scaleStart = 64 - (x0 & 63);
            scaleStop = x1 & 63;
        }
 
        if (clip){
            if (istart >= clip->fRight || istop <= clip->fLeft) {
                return;
            }
            if (istart < clip->fLeft) {
                fstart += slope * (clip->fLeft - istart);
                istart = clip->fLeft;
                scaleStart = 64;
                if (istop - istart == 1) {
                    // we are within a single pixel
                    scaleStart = contribution_64(x1);
                    scaleStop = 0;
                }
            }
            if (istop > clip->fRight) {
                istop = clip->fRight;
                scaleStop = 0;  // so we don't draw this last column
            }
 
            SkASSERT(istart <= istop);
            if (istart == istop) {
                return;
            }
            // now test if our Y values are completely inside the clip
            int top, bottom;
            if (slope >= 0) { // T2B
                top = SkFixedFloorToInt(fstart - SK_FixedHalf);
                bottom = SkFixedCeilToInt(fstart + (istop - istart - 1) * slope + SK_FixedHalf);
            } else {           // B2T
                bottom = SkFixedCeilToInt(fstart + SK_FixedHalf);
                top = SkFixedFloorToInt(fstart + (istop - istart - 1) * slope - SK_FixedHalf);
            }
#ifdef OUTSET_BEFORE_CLIP_TEST
            top -= 1;
            bottom += 1;
#endif
            if (top >= clip->fBottom || bottom <= clip->fTop) {
                return;
            }
            if (clip->fTop <= top && clip->fBottom >= bottom) {
                clip = nullptr;
            }
        }
    } else {   // mostly vertical
        if (y0 > y1) {  // we want to go top-to-bottom
            using std::swap;
            swap(x0, x1);
            swap(y0, y1);
        }
 
        istart = SkFDot6Floor(y0);
        istop = SkFDot6Ceil(y1);
        fstart = SkFDot6ToFixed(x0);
        if (x0 == x1) {
            if (y0 == y1) { // are we zero length?
                return;     // nothing to do
            }
            slope = 0;
            hairBlitter = &vline_blitter;
        } else {
            slope = fastfixdiv(x1 - x0, y1 - y0);
            SkASSERT(slope <= SK_Fixed1 && slope >= -SK_Fixed1);
            fstart += (slope * (32 - (y0 & 63)) + 32) >> 6;
            hairBlitter = &vertish_blitter;
        }
 
        SkASSERT(istop > istart);
        if (istop - istart == 1) {
            // we are within a single pixel
            scaleStart = y1 - y0;
            SkASSERT(scaleStart >= 0 && scaleStart <= 64);
            scaleStop = 0;
        } else {
            scaleStart = 64 - (y0 & 63);
            scaleStop = y1 & 63;
        }
 
        if (clip) {
            if (istart >= clip->fBottom || istop <= clip->fTop) {
                return;
            }
            if (istart < clip->fTop) {
                fstart += slope * (clip->fTop - istart);
                istart = clip->fTop;
                scaleStart = 64;
                if (istop - istart == 1) {
                    // we are within a single pixel
                    scaleStart = contribution_64(y1);
                    scaleStop = 0;
                }
            }
            if (istop > clip->fBottom) {
                istop = clip->fBottom;
                scaleStop = 0;  // so we don't draw this last row
            }
 
            SkASSERT(istart <= istop);
            if (istart == istop)
                return;
 
            // now test if our X values are completely inside the clip
            int left, right;
            if (slope >= 0) { // L2R
                left = SkFixedFloorToInt(fstart - SK_FixedHalf);
                right = SkFixedCeilToInt(fstart + (istop - istart - 1) * slope + SK_FixedHalf);
            } else {           // R2L
                right = SkFixedCeilToInt(fstart + SK_FixedHalf);
                left = SkFixedFloorToInt(fstart + (istop - istart - 1) * slope - SK_FixedHalf);
            }
#ifdef OUTSET_BEFORE_CLIP_TEST
            left -= 1;
            right += 1;
#endif
            if (left >= clip->fRight || right <= clip->fLeft) {
                return;
            }
            if (clip->fLeft <= left && clip->fRight >= right) {
                clip = nullptr;
            }
        }
    }
 
    SkRectClipBlitter   rectClipper;
    if (clip) {
        rectClipper.init(blitter, *clip);
        blitter = &rectClipper;
    }
 
    SkASSERT(hairBlitter);
    hairBlitter->setup(blitter);
 
#ifdef SK_DEBUG
    if (scaleStart > 0 && scaleStop > 0) {
        // be sure we don't draw twice in the same pixel
        SkASSERT(istart < istop - 1);
    }
#endif
 
    fstart = hairBlitter->drawCap(istart, fstart, slope, scaleStart);
    istart += 1;
    int fullSpans = istop - istart - (scaleStop > 0);
    if (fullSpans > 0) {
        fstart = hairBlitter->drawLine(istart, istart + fullSpans, fstart, slope);
    }
    if (scaleStop > 0) {
        hairBlitter->drawCap(istop - 1, fstart, slope, scaleStop);
    }
}

do_scanline()

static void do_scanline ( FDot8  L, int  top, FDot8  R, U8CPU  alpha, SkBlitter *  blitter  )

static

Definition at line 641 of file SkScan_Antihair.cpp.

                                            {
    SkASSERT(L < R);
 
    if ((L >> 8) == ((R - 1) >> 8)) {  // 1x1 pixel
        blitter->blitV(L >> 8, top, 1, SkAlphaMul(alpha, R - L));
        return;
    }
 
    int left = L >> 8;
 
    if (L & 0xFF) {
        blitter->blitV(left, top, 1, SkAlphaMul(alpha, 256 - (L & 0xFF)));
        left += 1;
    }
 
    int rite = R >> 8;
    int width = rite - left;
    if (width > 0) {
        call_hline_blitter(blitter, left, top, width, alpha);
    }
    if (R & 0xFF) {
        blitter->blitV(rite, top, 1, SkAlphaMul(alpha, R & 0xFF));
    }
}

fastfixdiv()

static SkFixed fastfixdiv ( SkFDot6  a, SkFDot6  b  )

inlinestatic

Definition at line 269 of file SkScan_Antihair.cpp.

                                                       {
    SkASSERT((SkLeftShift(a, 16) >> 16) == a);
    SkASSERT(b != 0);
    return SkLeftShift(a, 16) / b;
}

FDot8Ceil()

static int FDot8Ceil ( FDot8  x )

inlinestatic

Definition at line 851 of file SkScan_Antihair.cpp.

                                     {
    return (x + 0xFF) >> 8;
}

FDot8Floor()

static int FDot8Floor ( FDot8  x )

inlinestatic

Definition at line 847 of file SkScan_Antihair.cpp.

                                      {
    return x >> 8;
}

fillcheckrect()

static void fillcheckrect ( int  L, int  T, int  R, int  B, SkBlitter *  blitter  )

static

Definition at line 837 of file SkScan_Antihair.cpp.

                                                                          {
    if (L < R && T < B) {
        blitter->blitRect(L, T, R - L, B - T);
    }
}

inner_scanline()

static void inner_scanline ( FDot8  L, int  top, FDot8  R, U8CPU  alpha, SkBlitter *  blitter  )

static

Definition at line 862 of file SkScan_Antihair.cpp.

                                               {
    SkASSERT(L < R);
 
    if ((L >> 8) == ((R - 1) >> 8)) {  // 1x1 pixel
        FDot8 widClamp = R - L;
        // border case clamp 256 to 255 instead of going through call_hline_blitter
        // see skbug/4406
        widClamp = widClamp - (widClamp >> 8);
        blitter->blitV(L >> 8, top, 1, InvAlphaMul(alpha, widClamp));
        return;
    }
 
    int left = L >> 8;
    if (L & 0xFF) {
        blitter->blitV(left, top, 1, InvAlphaMul(alpha, L & 0xFF));
        left += 1;
    }
 
    int rite = R >> 8;
    int width = rite - left;
    if (width > 0) {
        call_hline_blitter(blitter, left, top, width, alpha);
    }
 
    if (R & 0xFF) {
        blitter->blitV(rite, top, 1, InvAlphaMul(alpha, ~R & 0xFF));
    }
}

innerstrokedot8()

static void innerstrokedot8 ( FDot8  L, FDot8  T, FDot8  R, FDot8  B, SkBlitter *  blitter  )

static

Definition at line 892 of file SkScan_Antihair.cpp.

                                                {
    SkASSERT(L < R && T < B);
 
    int top = T >> 8;
    if (top == ((B - 1) >> 8)) {   // just one scanline high
        // We want the inverse of B-T, since we're the inner-stroke
        int alpha = 256 - (B - T);
        if (alpha) {
            inner_scanline(L, top, R, alpha, blitter);
        }
        return;
    }
 
    if (T & 0xFF) {
        inner_scanline(L, top, R, T & 0xFF, blitter);
        top += 1;
    }
 
    int bot = B >> 8;
    int height = bot - top;
    if (height > 0) {
        if (L & 0xFF) {
            blitter->blitV(L >> 8, top, height, L & 0xFF);
        }
        if (R & 0xFF) {
            blitter->blitV(R >> 8, top, height, ~R & 0xFF);
        }
    }
 
    if (B & 0xFF) {
        inner_scanline(L, bot, R, ~B & 0xFF, blitter);
    }
}

InvAlphaMul()

static U8CPU InvAlphaMul ( U8CPU  a, U8CPU  b  )

inlinestatic

Definition at line 856 of file SkScan_Antihair.cpp.

                                                  {
    // need precise rounding (not just SkAlphaMul) so that values like
    // a=228, b=252 don't overflow the result
    return SkToU8(a + b - SkAlphaMulRound(a, b));
}

SkFixedToFDot8()

static FDot8 SkFixedToFDot8 ( SkFixed  x )

inlinestatic

Definition at line 637 of file SkScan_Antihair.cpp.

                                              {
    return (x + 0x80) >> 8;
}

SkScalarToFDot8()

static FDot8 SkScalarToFDot8 ( SkScalar  x )

inlinestatic

Definition at line 843 of file SkScan_Antihair.cpp.

                                                {
    return (int)(x * 256);
}

SmallDot6Scale()

static int SmallDot6Scale ( int  value, int  dot6  )

inlinestatic

Definition at line 46 of file SkScan_Antihair.cpp.

                                                      {
    SkASSERT((int16_t)value == value);
    SkASSERT((unsigned)dot6 <= 64);
    return (value * dot6) >> 6;
}