2011-07-28 14:26:00 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyright 2006 The Android Open Source Project
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
|
|
|
|
#include "SkScanPriv.h"
|
|
|
|
#include "SkPath.h"
|
|
|
|
#include "SkMatrix.h"
|
|
|
|
#include "SkBlitter.h"
|
|
|
|
#include "SkRegion.h"
|
|
|
|
#include "SkAntiRun.h"
|
|
|
|
|
|
|
|
#define SHIFT 2
|
|
|
|
#define SCALE (1 << SHIFT)
|
|
|
|
#define MASK (SCALE - 1)
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/** @file
|
2011-06-09 15:54:38 +00:00
|
|
|
We have two techniques for capturing the output of the supersampler:
|
|
|
|
- SUPERMASK, which records a large mask-bitmap
|
|
|
|
this is often faster for small, complex objects
|
|
|
|
- RLE, which records a rle-encoded scanline
|
|
|
|
this is often faster for large objects with big spans
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
These blitters use two coordinate systems:
|
|
|
|
- destination coordinates, scale equal to the output - often
|
|
|
|
abbreviated with 'i' or 'I' in variable names
|
|
|
|
- supersampled coordinates, scale equal to the output * SCALE
|
|
|
|
|
2012-05-09 14:07:34 +00:00
|
|
|
Enabling SK_USE_LEGACY_AA_COVERAGE keeps the aa coverage calculations as
|
|
|
|
they were before the fix that unified the output of the RLE and MASK
|
|
|
|
supersamplers.
|
2011-06-09 15:54:38 +00:00
|
|
|
*/
|
2012-05-09 14:07:34 +00:00
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
//#define FORCE_SUPERMASK
|
|
|
|
//#define FORCE_RLE
|
2012-05-09 14:33:02 +00:00
|
|
|
//#define SK_USE_LEGACY_AA_COVERAGE
|
2011-04-11 19:43:58 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Base class for a single-pass supersampled blitter.
|
2008-12-17 15:59:43 +00:00
|
|
|
class BaseSuperBlitter : public SkBlitter {
|
|
|
|
public:
|
|
|
|
BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
|
|
|
|
const SkRegion& clip);
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Must be explicitly defined on subclasses.
|
2008-12-17 15:59:43 +00:00
|
|
|
virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
|
2011-10-31 19:37:58 +00:00
|
|
|
const int16_t runs[]) SK_OVERRIDE {
|
2011-12-28 14:59:50 +00:00
|
|
|
SkDEBUGFAIL("How did I get here?");
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
2011-12-01 20:41:24 +00:00
|
|
|
/// May not be called on BaseSuperBlitter because it blits out of order.
|
2011-10-31 19:37:58 +00:00
|
|
|
virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {
|
2011-12-28 14:59:50 +00:00
|
|
|
SkDEBUGFAIL("How did I get here?");
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
SkBlitter* fRealBlitter;
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Current y coordinate, in destination coordinates.
|
2008-12-17 15:59:43 +00:00
|
|
|
int fCurrIY;
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Widest row of region to be blitted, in destination coordinates.
|
|
|
|
int fWidth;
|
|
|
|
/// Leftmost x coordinate in any row, in destination coordinates.
|
|
|
|
int fLeft;
|
|
|
|
/// Leftmost x coordinate in any row, in supersampled coordinates.
|
|
|
|
int fSuperLeft;
|
2008-12-17 15:59:43 +00:00
|
|
|
|
|
|
|
SkDEBUGCODE(int fCurrX;)
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Current y coordinate in supersampled coordinates.
|
2011-05-31 19:18:02 +00:00
|
|
|
int fCurrY;
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Initial y coordinate (top of bounds).
|
2011-10-24 12:19:46 +00:00
|
|
|
int fTop;
|
2008-12-17 15:59:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
|
|
|
|
const SkRegion& clip) {
|
|
|
|
fRealBlitter = realBlitter;
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2012-02-23 19:20:19 +00:00
|
|
|
/*
|
|
|
|
* We use the clip bounds instead of the ir, since we may be asked to
|
|
|
|
* draw outside of the rect if we're a inverse filltype
|
|
|
|
*/
|
|
|
|
const int left = clip.getBounds().fLeft;
|
|
|
|
const int right = clip.getBounds().fRight;
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
fLeft = left;
|
|
|
|
fSuperLeft = left << SHIFT;
|
|
|
|
fWidth = right - left;
|
2011-10-24 12:19:46 +00:00
|
|
|
#if 0
|
2008-12-17 15:59:43 +00:00
|
|
|
fCurrIY = -1;
|
2011-06-01 17:32:11 +00:00
|
|
|
fCurrY = -1;
|
2011-10-24 12:19:46 +00:00
|
|
|
#else
|
|
|
|
fTop = ir.fTop;
|
|
|
|
fCurrIY = ir.fTop - 1;
|
|
|
|
fCurrY = (ir.fTop << SHIFT) - 1;
|
|
|
|
#endif
|
2011-06-01 17:32:11 +00:00
|
|
|
SkDEBUGCODE(fCurrX = -1;)
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Run-length-encoded supersampling antialiased blitter.
|
2008-12-17 15:59:43 +00:00
|
|
|
class SuperBlitter : public BaseSuperBlitter {
|
|
|
|
public:
|
|
|
|
SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
|
|
|
|
const SkRegion& clip);
|
|
|
|
|
|
|
|
virtual ~SuperBlitter() {
|
|
|
|
this->flush();
|
|
|
|
sk_free(fRuns.fRuns);
|
|
|
|
}
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Once fRuns contains a complete supersampled row, flush() blits
|
|
|
|
/// it out through the wrapped blitter.
|
2008-12-17 15:59:43 +00:00
|
|
|
void flush();
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Blits a row of pixels, with location and width specified
|
|
|
|
/// in supersampled coordinates.
|
2011-10-31 19:37:58 +00:00
|
|
|
virtual void blitH(int x, int y, int width) SK_OVERRIDE;
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Blits a rectangle of pixels, with location and size specified
|
|
|
|
/// in supersampled coordinates.
|
2011-10-31 19:37:58 +00:00
|
|
|
virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
|
2008-12-17 15:59:43 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
SkAlphaRuns fRuns;
|
2011-05-31 19:18:02 +00:00
|
|
|
int fOffsetX;
|
2008-12-17 15:59:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
SuperBlitter::SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
|
|
|
|
const SkRegion& clip)
|
|
|
|
: BaseSuperBlitter(realBlitter, ir, clip) {
|
|
|
|
const int width = fWidth;
|
|
|
|
|
|
|
|
// extra one to store the zero at the end
|
|
|
|
fRuns.fRuns = (int16_t*)sk_malloc_throw((width + 1 + (width + 2)/2) * sizeof(int16_t));
|
|
|
|
fRuns.fAlpha = (uint8_t*)(fRuns.fRuns + width + 1);
|
|
|
|
fRuns.reset(width);
|
2011-05-31 19:18:02 +00:00
|
|
|
|
|
|
|
fOffsetX = 0;
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
void SuperBlitter::flush() {
|
2011-10-24 12:19:46 +00:00
|
|
|
if (fCurrIY >= fTop) {
|
2011-04-11 19:43:58 +00:00
|
|
|
if (!fRuns.empty()) {
|
2008-12-17 15:59:43 +00:00
|
|
|
// SkDEBUGCODE(fRuns.dump();)
|
|
|
|
fRealBlitter->blitAntiH(fLeft, fCurrIY, fRuns.fAlpha, fRuns.fRuns);
|
|
|
|
fRuns.reset(fWidth);
|
2011-05-31 19:18:02 +00:00
|
|
|
fOffsetX = 0;
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
2011-10-24 12:19:46 +00:00
|
|
|
fCurrIY = fTop - 1;
|
2008-12-17 15:59:43 +00:00
|
|
|
SkDEBUGCODE(fCurrX = -1;)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-02-23 19:34:34 +00:00
|
|
|
/** coverage_to_partial_alpha() is being used by SkAlphaRuns, which
|
|
|
|
*accumulates* SCALE pixels worth of "alpha" in [0,(256/SCALE)]
|
|
|
|
to produce a final value in [0, 255] and handles clamping 256->255
|
|
|
|
itself, with the same (alpha - (alpha >> 8)) correction as
|
|
|
|
coverage_to_exact_alpha().
|
|
|
|
*/
|
|
|
|
static inline int coverage_to_partial_alpha(int aa) {
|
2008-12-17 15:59:43 +00:00
|
|
|
aa <<= 8 - 2*SHIFT;
|
2012-05-09 14:07:34 +00:00
|
|
|
#ifdef SK_USE_LEGACY_AA_COVERAGE
|
2008-12-17 15:59:43 +00:00
|
|
|
aa -= aa >> (8 - SHIFT - 1);
|
2012-02-23 19:34:34 +00:00
|
|
|
#endif
|
2012-05-09 14:07:34 +00:00
|
|
|
return aa;
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
2012-02-23 19:34:34 +00:00
|
|
|
/** coverage_to_exact_alpha() is being used by our blitter, which wants
|
|
|
|
a final value in [0, 255].
|
|
|
|
*/
|
2011-12-27 13:59:20 +00:00
|
|
|
static inline int coverage_to_exact_alpha(int aa) {
|
2012-01-03 20:12:42 +00:00
|
|
|
int alpha = (256 >> SHIFT) * aa;
|
|
|
|
// clamp 256->255
|
|
|
|
return alpha - (alpha >> 8);
|
2011-12-27 13:59:20 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
void SuperBlitter::blitH(int x, int y, int width) {
|
2011-10-31 19:37:58 +00:00
|
|
|
SkASSERT(width > 0);
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
int iy = y >> SHIFT;
|
|
|
|
SkASSERT(iy >= fCurrIY);
|
|
|
|
|
|
|
|
x -= fSuperLeft;
|
|
|
|
// hack, until I figure out why my cubics (I think) go beyond the bounds
|
2011-04-11 19:43:58 +00:00
|
|
|
if (x < 0) {
|
2008-12-17 15:59:43 +00:00
|
|
|
width += x;
|
|
|
|
x = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef SK_DEBUG
|
|
|
|
SkASSERT(y != fCurrY || x >= fCurrX);
|
|
|
|
#endif
|
2011-05-31 19:18:02 +00:00
|
|
|
SkASSERT(y >= fCurrY);
|
|
|
|
if (fCurrY != y) {
|
|
|
|
fOffsetX = 0;
|
|
|
|
fCurrY = y;
|
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
if (iy != fCurrIY) { // new scanline
|
2008-12-17 15:59:43 +00:00
|
|
|
this->flush();
|
|
|
|
fCurrIY = iy;
|
|
|
|
}
|
|
|
|
|
2011-05-31 14:36:21 +00:00
|
|
|
int start = x;
|
|
|
|
int stop = x + width;
|
|
|
|
|
|
|
|
SkASSERT(start >= 0 && stop > start);
|
2011-12-01 20:41:24 +00:00
|
|
|
// integer-pixel-aligned ends of blit, rounded out
|
|
|
|
int fb = start & MASK;
|
|
|
|
int fe = stop & MASK;
|
2011-05-31 14:36:21 +00:00
|
|
|
int n = (stop >> SHIFT) - (start >> SHIFT) - 1;
|
|
|
|
|
|
|
|
if (n < 0) {
|
|
|
|
fb = fe - fb;
|
|
|
|
n = 0;
|
|
|
|
fe = 0;
|
|
|
|
} else {
|
|
|
|
if (fb == 0) {
|
|
|
|
n += 1;
|
2011-04-11 19:43:58 +00:00
|
|
|
} else {
|
2011-12-27 13:59:20 +00:00
|
|
|
fb = SCALE - fb;
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
}
|
2011-05-31 19:18:02 +00:00
|
|
|
|
2012-02-23 19:34:34 +00:00
|
|
|
fOffsetX = fRuns.add(x >> SHIFT, coverage_to_partial_alpha(fb),
|
|
|
|
n, coverage_to_partial_alpha(fe),
|
2011-05-31 19:18:02 +00:00
|
|
|
(1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT),
|
|
|
|
fOffsetX);
|
2008-12-17 15:59:43 +00:00
|
|
|
|
|
|
|
#ifdef SK_DEBUG
|
|
|
|
fRuns.assertValid(y & MASK, (1 << (8 - SHIFT)));
|
|
|
|
fCurrX = x + width;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-06-06 12:09:34 +00:00
|
|
|
#if 0 // UNUSED
|
2011-12-01 21:47:26 +00:00
|
|
|
static void set_left_rite_runs(SkAlphaRuns& runs, int ileft, U8CPU leftA,
|
|
|
|
int n, U8CPU riteA) {
|
|
|
|
SkASSERT(leftA <= 0xFF);
|
|
|
|
SkASSERT(riteA <= 0xFF);
|
|
|
|
|
|
|
|
int16_t* run = runs.fRuns;
|
|
|
|
uint8_t* aa = runs.fAlpha;
|
|
|
|
|
|
|
|
if (ileft > 0) {
|
|
|
|
run[0] = ileft;
|
|
|
|
aa[0] = 0;
|
|
|
|
run += ileft;
|
|
|
|
aa += ileft;
|
|
|
|
}
|
|
|
|
|
|
|
|
SkASSERT(leftA < 0xFF);
|
|
|
|
if (leftA > 0) {
|
|
|
|
*run++ = 1;
|
|
|
|
*aa++ = leftA;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n > 0) {
|
|
|
|
run[0] = n;
|
|
|
|
aa[0] = 0xFF;
|
|
|
|
run += n;
|
|
|
|
aa += n;
|
|
|
|
}
|
|
|
|
|
|
|
|
SkASSERT(riteA < 0xFF);
|
|
|
|
if (riteA > 0) {
|
|
|
|
*run++ = 1;
|
|
|
|
*aa++ = riteA;
|
|
|
|
}
|
|
|
|
run[0] = 0;
|
|
|
|
}
|
2012-06-06 12:09:34 +00:00
|
|
|
#endif
|
2011-12-01 21:47:26 +00:00
|
|
|
|
2011-10-31 19:37:58 +00:00
|
|
|
void SuperBlitter::blitRect(int x, int y, int width, int height) {
|
|
|
|
SkASSERT(width > 0);
|
|
|
|
SkASSERT(height > 0);
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
// blit leading rows
|
|
|
|
while ((y & MASK)) {
|
2011-10-31 19:37:58 +00:00
|
|
|
this->blitH(x, y++, width);
|
|
|
|
if (--height <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
SkASSERT(height > 0);
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
// Since this is a rect, instead of blitting supersampled rows one at a
|
|
|
|
// time and then resolving to the destination canvas, we can blit
|
|
|
|
// directly to the destintion canvas one row per SCALE supersampled rows.
|
2011-10-31 19:37:58 +00:00
|
|
|
int start_y = y >> SHIFT;
|
|
|
|
int stop_y = (y + height) >> SHIFT;
|
|
|
|
int count = stop_y - start_y;
|
|
|
|
if (count > 0) {
|
|
|
|
y += count << SHIFT;
|
|
|
|
height -= count << SHIFT;
|
|
|
|
|
|
|
|
// save original X for our tail blitH() loop at the bottom
|
|
|
|
int origX = x;
|
|
|
|
|
|
|
|
x -= fSuperLeft;
|
|
|
|
// hack, until I figure out why my cubics (I think) go beyond the bounds
|
|
|
|
if (x < 0) {
|
|
|
|
width += x;
|
|
|
|
x = 0;
|
|
|
|
}
|
|
|
|
|
2011-12-27 13:59:20 +00:00
|
|
|
// There is always a left column, a middle, and a right column.
|
|
|
|
// ileft is the destination x of the first pixel of the entire rect.
|
|
|
|
// xleft is (SCALE - # of covered supersampled pixels) in that
|
|
|
|
// destination pixel.
|
2011-10-31 19:37:58 +00:00
|
|
|
int ileft = x >> SHIFT;
|
2011-12-01 20:41:24 +00:00
|
|
|
int xleft = x & MASK;
|
2011-12-27 13:59:20 +00:00
|
|
|
// irite is the destination x of the last pixel of the OPAQUE section.
|
|
|
|
// xrite is the number of supersampled pixels extending beyond irite;
|
|
|
|
// xrite/SCALE should give us alpha.
|
2011-10-31 19:37:58 +00:00
|
|
|
int irite = (x + width) >> SHIFT;
|
2011-12-01 20:41:24 +00:00
|
|
|
int xrite = (x + width) & MASK;
|
2011-12-27 13:59:20 +00:00
|
|
|
if (!xrite) {
|
|
|
|
xrite = SCALE;
|
|
|
|
irite--;
|
|
|
|
}
|
|
|
|
|
2011-12-28 17:58:07 +00:00
|
|
|
// Need to call flush() to clean up pending draws before we
|
|
|
|
// even consider blitV(), since otherwise it can look nonmonotonic.
|
|
|
|
SkASSERT(start_y > fCurrIY);
|
|
|
|
this->flush();
|
|
|
|
|
2011-10-31 19:37:58 +00:00
|
|
|
int n = irite - ileft - 1;
|
|
|
|
if (n < 0) {
|
2011-12-28 17:58:07 +00:00
|
|
|
// If n < 0, we'll only have a single partially-transparent column
|
|
|
|
// of pixels to render.
|
2011-10-31 19:37:58 +00:00
|
|
|
xleft = xrite - xleft;
|
2011-12-27 13:59:20 +00:00
|
|
|
SkASSERT(xleft <= SCALE);
|
|
|
|
SkASSERT(xleft > 0);
|
2011-10-31 19:37:58 +00:00
|
|
|
xrite = 0;
|
2011-12-27 13:59:20 +00:00
|
|
|
fRealBlitter->blitV(ileft + fLeft, start_y, count,
|
|
|
|
coverage_to_exact_alpha(xleft));
|
2011-10-31 19:37:58 +00:00
|
|
|
} else {
|
2011-12-28 17:58:07 +00:00
|
|
|
// With n = 0, we have two possibly-transparent columns of pixels
|
|
|
|
// to render; with n > 0, we have opaque columns between them.
|
|
|
|
|
2011-12-27 13:59:20 +00:00
|
|
|
xleft = SCALE - xleft;
|
2011-10-31 19:37:58 +00:00
|
|
|
|
2011-12-28 17:58:07 +00:00
|
|
|
// Using coverage_to_exact_alpha is not consistent with blitH()
|
|
|
|
const int coverageL = coverage_to_exact_alpha(xleft);
|
|
|
|
const int coverageR = coverage_to_exact_alpha(xrite);
|
2011-12-27 13:59:20 +00:00
|
|
|
|
2011-12-28 17:58:07 +00:00
|
|
|
SkASSERT(coverageL > 0 || n > 0 || coverageR > 0);
|
|
|
|
SkASSERT((coverageL != 0) + n + (coverageR != 0) <= fWidth);
|
2011-10-31 19:37:58 +00:00
|
|
|
|
2011-12-28 17:58:07 +00:00
|
|
|
fRealBlitter->blitAntiRect(ileft + fLeft, start_y, n, count,
|
|
|
|
coverageL, coverageR);
|
|
|
|
}
|
2011-10-31 19:37:58 +00:00
|
|
|
|
|
|
|
// preamble for our next call to blitH()
|
|
|
|
fCurrIY = stop_y - 1;
|
|
|
|
fOffsetX = 0;
|
|
|
|
fCurrY = y - 1;
|
|
|
|
fRuns.reset(fWidth);
|
|
|
|
x = origX;
|
|
|
|
}
|
|
|
|
|
2011-12-27 13:59:20 +00:00
|
|
|
// catch any remaining few rows
|
2011-12-01 20:41:24 +00:00
|
|
|
SkASSERT(height <= MASK);
|
2011-10-31 19:37:58 +00:00
|
|
|
while (--height >= 0) {
|
|
|
|
this->blitH(x, y++, width);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2011-12-01 20:41:24 +00:00
|
|
|
/// Masked supersampling antialiased blitter.
|
2008-12-17 15:59:43 +00:00
|
|
|
class MaskSuperBlitter : public BaseSuperBlitter {
|
|
|
|
public:
|
|
|
|
MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
|
|
|
|
const SkRegion& clip);
|
|
|
|
virtual ~MaskSuperBlitter() {
|
|
|
|
fRealBlitter->blitMask(fMask, fClipRect);
|
|
|
|
}
|
|
|
|
|
2011-10-31 19:37:58 +00:00
|
|
|
virtual void blitH(int x, int y, int width) SK_OVERRIDE;
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
static bool CanHandleRect(const SkIRect& bounds) {
|
|
|
|
#ifdef FORCE_RLE
|
|
|
|
return false;
|
|
|
|
#endif
|
2008-12-17 15:59:43 +00:00
|
|
|
int width = bounds.width();
|
2012-03-12 16:09:06 +00:00
|
|
|
int64_t rb = SkAlign4(width);
|
|
|
|
// use 64bits to detect overflow
|
|
|
|
int64_t storage = rb * bounds.height();
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
return (width <= MaskSuperBlitter::kMAX_WIDTH) &&
|
2012-03-12 16:09:06 +00:00
|
|
|
(storage <= MaskSuperBlitter::kMAX_STORAGE);
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
private:
|
|
|
|
enum {
|
2011-04-11 19:43:58 +00:00
|
|
|
#ifdef FORCE_SUPERMASK
|
|
|
|
kMAX_WIDTH = 2048,
|
|
|
|
kMAX_STORAGE = 1024 * 1024 * 2
|
|
|
|
#else
|
2008-12-17 15:59:43 +00:00
|
|
|
kMAX_WIDTH = 32, // so we don't try to do very wide things, where the RLE blitter would be faster
|
|
|
|
kMAX_STORAGE = 1024
|
2011-04-11 19:43:58 +00:00
|
|
|
#endif
|
2008-12-17 15:59:43 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
SkMask fMask;
|
|
|
|
SkIRect fClipRect;
|
|
|
|
// we add 1 because add_aa_span can write (unchanged) 1 extra byte at the end, rather than
|
|
|
|
// perform a test to see if stopAlpha != 0
|
|
|
|
uint32_t fStorage[(kMAX_STORAGE >> 2) + 1];
|
|
|
|
};
|
|
|
|
|
|
|
|
MaskSuperBlitter::MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,
|
|
|
|
const SkRegion& clip)
|
|
|
|
: BaseSuperBlitter(realBlitter, ir, clip) {
|
|
|
|
SkASSERT(CanHandleRect(ir));
|
|
|
|
|
|
|
|
fMask.fImage = (uint8_t*)fStorage;
|
|
|
|
fMask.fBounds = ir;
|
|
|
|
fMask.fRowBytes = ir.width();
|
|
|
|
fMask.fFormat = SkMask::kA8_Format;
|
2012-03-12 16:09:06 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
fClipRect = ir;
|
|
|
|
fClipRect.intersect(clip.getBounds());
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
// For valgrind, write 1 extra byte at the end so we don't read
|
|
|
|
// uninitialized memory. See comment in add_aa_span and fStorage[].
|
|
|
|
memset(fStorage, 0, fMask.fBounds.height() * fMask.fRowBytes + 1);
|
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
static void add_aa_span(uint8_t* alpha, U8CPU startAlpha) {
|
2008-12-17 15:59:43 +00:00
|
|
|
/* I should be able to just add alpha[x] + startAlpha.
|
|
|
|
However, if the trailing edge of the previous span and the leading
|
|
|
|
edge of the current span round to the same super-sampled x value,
|
|
|
|
I might overflow to 256 with this add, hence the funny subtract.
|
|
|
|
*/
|
|
|
|
unsigned tmp = *alpha + startAlpha;
|
|
|
|
SkASSERT(tmp <= 256);
|
|
|
|
*alpha = SkToU8(tmp - (tmp >> 8));
|
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
static inline uint32_t quadplicate_byte(U8CPU value) {
|
|
|
|
uint32_t pair = (value << 8) | value;
|
|
|
|
return (pair << 16) | pair;
|
|
|
|
}
|
|
|
|
|
2012-05-09 13:48:50 +00:00
|
|
|
// Perform this tricky subtract, to avoid overflowing to 256. Our caller should
|
|
|
|
// only ever call us with at most enough to hit 256 (never larger), so it is
|
|
|
|
// enough to just subtract the high-bit. Actually clamping with a branch would
|
|
|
|
// be slower (e.g. if (tmp > 255) tmp = 255;)
|
|
|
|
//
|
|
|
|
static inline void saturated_add(uint8_t* ptr, U8CPU add) {
|
|
|
|
unsigned tmp = *ptr + add;
|
|
|
|
SkASSERT(tmp <= 256);
|
|
|
|
*ptr = SkToU8(tmp - (tmp >> 8));
|
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
// minimum count before we want to setup an inner loop, adding 4-at-a-time
|
|
|
|
#define MIN_COUNT_FOR_QUAD_LOOP 16
|
|
|
|
|
|
|
|
static void add_aa_span(uint8_t* alpha, U8CPU startAlpha, int middleCount,
|
|
|
|
U8CPU stopAlpha, U8CPU maxValue) {
|
2008-12-17 15:59:43 +00:00
|
|
|
SkASSERT(middleCount >= 0);
|
|
|
|
|
2012-05-09 13:48:50 +00:00
|
|
|
saturated_add(alpha, startAlpha);
|
|
|
|
alpha += 1;
|
2008-12-17 15:59:43 +00:00
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
if (middleCount >= MIN_COUNT_FOR_QUAD_LOOP) {
|
|
|
|
// loop until we're quad-byte aligned
|
|
|
|
while (SkTCast<intptr_t>(alpha) & 0x3) {
|
|
|
|
alpha[0] = SkToU8(alpha[0] + maxValue);
|
|
|
|
alpha += 1;
|
|
|
|
middleCount -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int bigCount = middleCount >> 2;
|
|
|
|
uint32_t* qptr = reinterpret_cast<uint32_t*>(alpha);
|
|
|
|
uint32_t qval = quadplicate_byte(maxValue);
|
|
|
|
do {
|
|
|
|
*qptr++ += qval;
|
|
|
|
} while (--bigCount > 0);
|
|
|
|
|
|
|
|
middleCount &= 3;
|
|
|
|
alpha = reinterpret_cast<uint8_t*> (qptr);
|
|
|
|
// fall through to the following while-loop
|
|
|
|
}
|
|
|
|
|
|
|
|
while (--middleCount >= 0) {
|
2008-12-17 15:59:43 +00:00
|
|
|
alpha[0] = SkToU8(alpha[0] + maxValue);
|
|
|
|
alpha += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// potentially this can be off the end of our "legal" alpha values, but that
|
|
|
|
// only happens if stopAlpha is also 0. Rather than test for stopAlpha != 0
|
|
|
|
// every time (slow), we just do it, and ensure that we've allocated extra space
|
|
|
|
// (see the + 1 comment in fStorage[]
|
2012-05-09 13:48:50 +00:00
|
|
|
saturated_add(alpha, stopAlpha);
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
void MaskSuperBlitter::blitH(int x, int y, int width) {
|
2008-12-17 15:59:43 +00:00
|
|
|
int iy = (y >> SHIFT);
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
SkASSERT(iy >= fMask.fBounds.fTop && iy < fMask.fBounds.fBottom);
|
|
|
|
iy -= fMask.fBounds.fTop; // make it relative to 0
|
|
|
|
|
2009-08-21 22:00:12 +00:00
|
|
|
// This should never happen, but it does. Until the true cause is
|
|
|
|
// discovered, let's skip this span instead of crashing.
|
|
|
|
// See http://crbug.com/17569.
|
|
|
|
if (iy < 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
#ifdef SK_DEBUG
|
|
|
|
{
|
|
|
|
int ix = x >> SHIFT;
|
|
|
|
SkASSERT(ix >= fMask.fBounds.fLeft && ix < fMask.fBounds.fRight);
|
|
|
|
}
|
|
|
|
#endif
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
x -= (fMask.fBounds.fLeft << SHIFT);
|
|
|
|
|
|
|
|
// hack, until I figure out why my cubics (I think) go beyond the bounds
|
2011-04-11 19:43:58 +00:00
|
|
|
if (x < 0) {
|
2008-12-17 15:59:43 +00:00
|
|
|
width += x;
|
|
|
|
x = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t* row = fMask.fImage + iy * fMask.fRowBytes + (x >> SHIFT);
|
|
|
|
|
|
|
|
int start = x;
|
|
|
|
int stop = x + width;
|
|
|
|
|
|
|
|
SkASSERT(start >= 0 && stop > start);
|
2011-12-01 20:41:24 +00:00
|
|
|
int fb = start & MASK;
|
|
|
|
int fe = stop & MASK;
|
2008-12-17 15:59:43 +00:00
|
|
|
int n = (stop >> SHIFT) - (start >> SHIFT) - 1;
|
|
|
|
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
if (n < 0) {
|
2009-08-12 20:21:49 +00:00
|
|
|
SkASSERT(row >= fMask.fImage);
|
|
|
|
SkASSERT(row < fMask.fImage + kMAX_STORAGE + 1);
|
2012-02-23 19:34:34 +00:00
|
|
|
add_aa_span(row, coverage_to_partial_alpha(fe - fb));
|
2011-04-11 19:43:58 +00:00
|
|
|
} else {
|
2011-12-27 13:59:20 +00:00
|
|
|
fb = SCALE - fb;
|
2009-08-12 20:21:49 +00:00
|
|
|
SkASSERT(row >= fMask.fImage);
|
|
|
|
SkASSERT(row + n + 1 < fMask.fImage + kMAX_STORAGE + 1);
|
2012-02-23 19:34:34 +00:00
|
|
|
add_aa_span(row, coverage_to_partial_alpha(fb),
|
|
|
|
n, coverage_to_partial_alpha(fe),
|
2008-12-17 15:59:43 +00:00
|
|
|
(1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT));
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef SK_DEBUG
|
|
|
|
fCurrX = x + width;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2012-02-28 15:32:42 +00:00
|
|
|
static bool fitsInsideLimit(const SkRect& r, SkScalar max) {
|
|
|
|
const SkScalar min = -max;
|
|
|
|
return r.fLeft > min && r.fTop > min &&
|
|
|
|
r.fRight < max && r.fBottom < max;
|
|
|
|
}
|
|
|
|
|
2012-04-12 14:23:58 +00:00
|
|
|
static int overflows_short_shift(int value, int shift) {
|
|
|
|
const int s = 16 + shift;
|
|
|
|
return (value << s >> s) - value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
Would any of the coordinates of this rectangle not fit in a short,
|
|
|
|
when left-shifted by shift?
|
|
|
|
*/
|
|
|
|
static int rect_overflows_short_shift(SkIRect rect, int shift) {
|
|
|
|
SkASSERT(!overflows_short_shift(8191, SHIFT));
|
|
|
|
SkASSERT(overflows_short_shift(8192, SHIFT));
|
|
|
|
SkASSERT(!overflows_short_shift(32767, 0));
|
|
|
|
SkASSERT(overflows_short_shift(32768, 0));
|
|
|
|
|
|
|
|
// Since we expect these to succeed, we bit-or together
|
|
|
|
// for a tiny extra bit of speed.
|
|
|
|
return overflows_short_shift(rect.fLeft, SHIFT) |
|
|
|
|
overflows_short_shift(rect.fRight, SHIFT) |
|
|
|
|
overflows_short_shift(rect.fTop, SHIFT) |
|
|
|
|
overflows_short_shift(rect.fBottom, SHIFT);
|
|
|
|
}
|
|
|
|
|
2012-02-28 15:32:42 +00:00
|
|
|
static bool safeRoundOut(const SkRect& src, SkIRect* dst, int32_t maxInt) {
|
2012-02-28 16:34:29 +00:00
|
|
|
#ifdef SK_SCALAR_IS_FIXED
|
|
|
|
// the max-int (shifted) is exactly what we want to compare against, to know
|
|
|
|
// if we can survive shifting our fixed-point coordinates
|
|
|
|
const SkFixed maxScalar = maxInt;
|
|
|
|
#else
|
2012-02-28 15:32:42 +00:00
|
|
|
const SkScalar maxScalar = SkIntToScalar(maxInt);
|
2012-02-28 16:34:29 +00:00
|
|
|
#endif
|
2012-02-28 15:32:42 +00:00
|
|
|
if (fitsInsideLimit(src, maxScalar)) {
|
|
|
|
src.roundOut(dst);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
2012-01-30 17:09:45 +00:00
|
|
|
void SkScan::AntiFillPath(const SkPath& path, const SkRegion& origClip,
|
2011-10-03 21:15:46 +00:00
|
|
|
SkBlitter* blitter, bool forceRLE) {
|
2012-01-30 17:09:45 +00:00
|
|
|
if (origClip.isEmpty()) {
|
2008-12-17 15:59:43 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-04-01 18:31:44 +00:00
|
|
|
SkIRect ir;
|
2012-02-28 15:32:42 +00:00
|
|
|
|
|
|
|
if (!safeRoundOut(path.getBounds(), &ir, SK_MaxS32 >> SHIFT)) {
|
|
|
|
#if 0
|
|
|
|
const SkRect& r = path.getBounds();
|
|
|
|
SkDebugf("--- bounds can't fit in SkIRect\n", r.fLeft, r.fTop, r.fRight, r.fBottom);
|
|
|
|
#endif
|
|
|
|
return;
|
|
|
|
}
|
2008-12-17 15:59:43 +00:00
|
|
|
if (ir.isEmpty()) {
|
2011-12-21 19:36:21 +00:00
|
|
|
if (path.isInverseFillType()) {
|
2012-01-30 17:09:45 +00:00
|
|
|
blitter->blitRegion(origClip);
|
2011-12-21 19:36:21 +00:00
|
|
|
}
|
2008-12-17 15:59:43 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-12 14:23:58 +00:00
|
|
|
// If the intersection of the path bounds and the clip bounds
|
|
|
|
// will overflow 32767 when << by SHIFT, we can't supersample,
|
|
|
|
// so draw without antialiasing.
|
|
|
|
SkIRect clippedIR;
|
|
|
|
if (path.isInverseFillType()) {
|
|
|
|
// If the path is an inverse fill, it's going to fill the entire
|
|
|
|
// clip, and we care whether the entire clip exceeds our limits.
|
|
|
|
clippedIR = origClip.getBounds();
|
|
|
|
} else {
|
|
|
|
if (!clippedIR.intersect(ir, origClip.getBounds())) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (rect_overflows_short_shift(clippedIR, SHIFT)) {
|
|
|
|
SkScan::FillPath(path, origClip, blitter);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-01-30 17:09:45 +00:00
|
|
|
// Our antialiasing can't handle a clip larger than 32767, so we restrict
|
|
|
|
// the clip to that limit here. (the runs[] uses int16_t for its index).
|
|
|
|
//
|
2012-04-12 14:23:58 +00:00
|
|
|
// A more general solution (one that could also eliminate the need to
|
|
|
|
// disable aa based on ir bounds (see overflows_short_shift) would be
|
|
|
|
// to tile the clip/target...
|
2012-01-30 17:09:45 +00:00
|
|
|
SkRegion tmpClipStorage;
|
|
|
|
const SkRegion* clipRgn = &origClip;
|
|
|
|
{
|
|
|
|
static const int32_t kMaxClipCoord = 32767;
|
|
|
|
const SkIRect& bounds = origClip.getBounds();
|
|
|
|
if (bounds.fRight > kMaxClipCoord || bounds.fBottom > kMaxClipCoord) {
|
|
|
|
SkIRect limit = { 0, 0, kMaxClipCoord, kMaxClipCoord };
|
|
|
|
tmpClipStorage.op(origClip, limit, SkRegion::kIntersect_Op);
|
|
|
|
clipRgn = &tmpClipStorage;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// for here down, use clipRgn, not origClip
|
|
|
|
|
|
|
|
SkScanClipper clipper(blitter, clipRgn, ir);
|
2008-12-17 15:59:43 +00:00
|
|
|
const SkIRect* clipRect = clipper.getClipRect();
|
|
|
|
|
|
|
|
if (clipper.getBlitter() == NULL) { // clipped out
|
|
|
|
if (path.isInverseFillType()) {
|
2012-01-30 17:09:45 +00:00
|
|
|
blitter->blitRegion(*clipRgn);
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2011-03-02 15:58:18 +00:00
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
// now use the (possibly wrapped) blitter
|
|
|
|
blitter = clipper.getBlitter();
|
|
|
|
|
|
|
|
if (path.isInverseFillType()) {
|
2012-01-30 17:09:45 +00:00
|
|
|
sk_blit_above(blitter, ir, *clipRgn);
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SkIRect superRect, *superClipRect = NULL;
|
|
|
|
|
2011-04-11 19:43:58 +00:00
|
|
|
if (clipRect) {
|
2008-12-17 15:59:43 +00:00
|
|
|
superRect.set( clipRect->fLeft << SHIFT, clipRect->fTop << SHIFT,
|
|
|
|
clipRect->fRight << SHIFT, clipRect->fBottom << SHIFT);
|
|
|
|
superClipRect = &superRect;
|
|
|
|
}
|
|
|
|
|
2009-08-21 22:00:12 +00:00
|
|
|
SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
|
|
|
|
|
2008-12-17 15:59:43 +00:00
|
|
|
// MaskSuperBlitter can't handle drawing outside of ir, so we can't use it
|
|
|
|
// if we're an inverse filltype
|
2011-10-03 21:15:46 +00:00
|
|
|
if (!path.isInverseFillType() && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {
|
2012-01-30 17:09:45 +00:00
|
|
|
MaskSuperBlitter superBlit(blitter, ir, *clipRgn);
|
2009-08-21 22:00:12 +00:00
|
|
|
SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);
|
2012-01-30 17:09:45 +00:00
|
|
|
sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
|
2011-04-11 19:43:58 +00:00
|
|
|
} else {
|
2012-01-30 17:09:45 +00:00
|
|
|
SuperBlitter superBlit(blitter, ir, *clipRgn);
|
|
|
|
sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
2011-03-02 15:58:18 +00:00
|
|
|
|
|
|
|
if (path.isInverseFillType()) {
|
2012-01-30 17:09:45 +00:00
|
|
|
sk_blit_below(blitter, ir, *clipRgn);
|
2011-03-02 15:58:18 +00:00
|
|
|
}
|
2008-12-17 15:59:43 +00:00
|
|
|
}
|
2011-10-12 20:42:05 +00:00
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
#include "SkRasterClip.h"
|
|
|
|
|
|
|
|
void SkScan::FillPath(const SkPath& path, const SkRasterClip& clip,
|
|
|
|
SkBlitter* blitter) {
|
|
|
|
if (clip.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clip.isBW()) {
|
|
|
|
FillPath(path, clip.bwRgn(), blitter);
|
|
|
|
} else {
|
|
|
|
SkRegion tmp;
|
|
|
|
SkAAClipBlitter aaBlitter;
|
|
|
|
|
|
|
|
tmp.setRect(clip.getBounds());
|
|
|
|
aaBlitter.init(blitter, &clip.aaRgn());
|
|
|
|
SkScan::FillPath(path, tmp, &aaBlitter);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SkScan::AntiFillPath(const SkPath& path, const SkRasterClip& clip,
|
|
|
|
SkBlitter* blitter) {
|
|
|
|
if (clip.isEmpty()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (clip.isBW()) {
|
|
|
|
AntiFillPath(path, clip.bwRgn(), blitter);
|
|
|
|
} else {
|
|
|
|
SkRegion tmp;
|
|
|
|
SkAAClipBlitter aaBlitter;
|
|
|
|
|
|
|
|
tmp.setRect(clip.getBounds());
|
|
|
|
aaBlitter.init(blitter, &clip.aaRgn());
|
|
|
|
SkScan::AntiFillPath(path, tmp, &aaBlitter, true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|