/* libs/graphics/sgl/SkScan_Path.cpp
**
** Copyright 2006, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#include "SkScanPriv.h"
#include "SkBlitter.h"
#include "SkEdge.h"
#include "SkGeometry.h"
#include "SkPath.h"
#include "SkQuadClipper.h"
#include "SkRegion.h"
#include "SkTemplates.h"
#define USE_NEW_BUILDER
#define kEDGE_HEAD_Y SK_MinS32
#define kEDGE_TAIL_Y SK_MaxS32
#ifdef SK_DEBUG
static void validate_sort(const SkEdge* edge) {
int y = kEDGE_HEAD_Y;
while (edge->fFirstY != SK_MaxS32) {
edge->validate();
SkASSERT(y <= edge->fFirstY);
y = edge->fFirstY;
edge = edge->fNext;
}
}
#else
#define validate_sort(edge)
#endif
static inline void remove_edge(SkEdge* edge) {
edge->fPrev->fNext = edge->fNext;
edge->fNext->fPrev = edge->fPrev;
}
static inline void swap_edges(SkEdge* prev, SkEdge* next) {
SkASSERT(prev->fNext == next && next->fPrev == prev);
// remove prev from the list
prev->fPrev->fNext = next;
next->fPrev = prev->fPrev;
// insert prev after next
prev->fNext = next->fNext;
next->fNext->fPrev = prev;
next->fNext = prev;
prev->fPrev = next;
}
static void backward_insert_edge_based_on_x(SkEdge* edge SkDECLAREPARAM(int, curr_y)) {
SkFixed x = edge->fX;
for (;;) {
SkEdge* prev = edge->fPrev;
// add 1 to curr_y since we may have added new edges (built from curves)
// that start on the next scanline
SkASSERT(prev && prev->fFirstY <= curr_y + 1);
if (prev->fX <= x) {
break;
}
swap_edges(prev, edge);
}
}
static void insert_new_edges(SkEdge* newEdge, int curr_y) {
SkASSERT(newEdge->fFirstY >= curr_y);
while (newEdge->fFirstY == curr_y) {
SkEdge* next = newEdge->fNext;
backward_insert_edge_based_on_x(newEdge SkPARAM(curr_y));
newEdge = next;
}
}
#ifdef SK_DEBUG
static void validate_edges_for_y(const SkEdge* edge, int curr_y) {
while (edge->fFirstY <= curr_y) {
SkASSERT(edge->fPrev && edge->fNext);
SkASSERT(edge->fPrev->fNext == edge);
SkASSERT(edge->fNext->fPrev == edge);
SkASSERT(edge->fFirstY <= edge->fLastY);
SkASSERT(edge->fPrev->fX <= edge->fX);
edge = edge->fNext;
}
}
#else
#define validate_edges_for_y(edge, curr_y)
#endif
#if defined _WIN32 && _MSC_VER >= 1300 // disable warning : local variable used without having been initialized
#pragma warning ( push )
#pragma warning ( disable : 4701 )
#endif
typedef void (*PrePostProc)(SkBlitter* blitter, int y, bool isStartOfScanline);
#define PREPOST_START true
#define PREPOST_END false
static void walk_edges(SkEdge* prevHead, SkPath::FillType fillType,
SkBlitter* blitter, int start_y, int stop_y,
PrePostProc proc) {
validate_sort(prevHead->fNext);
int curr_y = start_y;
// returns 1 for evenodd, -1 for winding, regardless of inverse-ness
int windingMask = (fillType & 1) ? 1 : -1;
for (;;) {
int w = 0;
int left SK_INIT_TO_AVOID_WARNING;
bool in_interval = false;
SkEdge* currE = prevHead->fNext;
SkFixed prevX = prevHead->fX;
validate_edges_for_y(currE, curr_y);
if (proc) {
proc(blitter, curr_y, PREPOST_START); // pre-proc
}
while (currE->fFirstY <= curr_y) {
SkASSERT(currE->fLastY >= curr_y);
int x = (currE->fX + SK_Fixed1/2) >> 16;
w += currE->fWinding;
if ((w & windingMask) == 0) { // we finished an interval
SkASSERT(in_interval);
int width = x - left;
SkASSERT(width >= 0);
if (width)
blitter->blitH(left, curr_y, width);
in_interval = false;
} else if (!in_interval) {
left = x;
in_interval = true;
}
SkEdge* next = currE->fNext;
SkFixed newX;
if (currE->fLastY == curr_y) { // are we done with this edge?
if (currE->fCurveCount < 0) {
if (((SkCubicEdge*)currE)->updateCubic()) {
SkASSERT(currE->fFirstY == curr_y + 1);
newX = currE->fX;
goto NEXT_X;
}
} else if (currE->fCurveCount > 0) {
if (((SkQuadraticEdge*)currE)->updateQuadratic()) {
newX = currE->fX;
goto NEXT_X;
}
}
remove_edge(currE);
} else {
SkASSERT(currE->fLastY > curr_y);
newX = currE->fX + currE->fDX;
currE->fX = newX;
NEXT_X:
if (newX < prevX) { // ripple currE backwards until it is x-sorted
backward_insert_edge_based_on_x(currE SkPARAM(curr_y));
} else {
prevX = newX;
}
}
currE = next;
SkASSERT(currE);
}
if (proc) {
proc(blitter, curr_y, PREPOST_END); // post-proc
}
curr_y += 1;
if (curr_y >= stop_y) {
break;
}
// now currE points to the first edge with a Yint larger than curr_y
insert_new_edges(currE, curr_y);
}
}
///////////////////////////////////////////////////////////////////////////////
// this guy overrides blitH, and will call its proxy blitter with the inverse
// of the spans it is given (clipped to the left/right of the cliprect)
//
// used to implement inverse filltypes on paths
//
class InverseBlitter : public SkBlitter {
public:
void setBlitter(SkBlitter* blitter, const SkIRect& clip, int shift) {
fBlitter = blitter;
fFirstX = clip.fLeft << shift;
fLastX = clip.fRight << shift;
}
void prepost(int y, bool isStart) {
if (isStart) {
fPrevX = fFirstX;
} else {
int invWidth = fLastX - fPrevX;
if (invWidth > 0) {
fBlitter->blitH(fPrevX, y, invWidth);
}
}
}
// overrides
virtual void blitH(int x, int y, int width) {
int invWidth = x - fPrevX;
if (invWidth > 0) {
fBlitter->blitH(fPrevX, y, invWidth);
}
fPrevX = x + width;
}
// we do not expect to get called with these entrypoints
virtual void blitAntiH(int, int, const SkAlpha[], const int16_t runs[]) {
SkASSERT(!"blitAntiH unexpected");
}
virtual void blitV(int x, int y, int height, SkAlpha alpha) {
SkASSERT(!"blitV unexpected");
}
virtual void blitRect(int x, int y, int width, int height) {
SkASSERT(!"blitRect unexpected");
}
virtual void blitMask(const SkMask&, const SkIRect& clip) {
SkASSERT(!"blitMask unexpected");
}
virtual const SkBitmap* justAnOpaqueColor(uint32_t* value) {
SkASSERT(!"justAnOpaqueColor unexpected");
return NULL;
}
private:
SkBlitter* fBlitter;
int fFirstX, fLastX, fPrevX;
};
static void PrePostInverseBlitterProc(SkBlitter* blitter, int y, bool isStart) {
((InverseBlitter*)blitter)->prepost(y, isStart);
}
///////////////////////////////////////////////////////////////////////////////
#if defined _WIN32 && _MSC_VER >= 1300
#pragma warning ( pop )
#endif
#ifdef USE_NEW_BUILDER
#include "SkEdgeBuilder.h"
#else
static int build_edges(SkEdge edge[], const SkPath& path,
const SkIRect* clipRect, SkEdge* list[], int shiftUp) {
SkEdge** start = list;
SkPath::Iter iter(path, true);
SkPoint pts[4];
SkPath::Verb verb;
SkQuadClipper qclipper;
if (clipRect) {
SkIRect r;
r.set(clipRect->fLeft >> shiftUp, clipRect->fTop >> shiftUp,
clipRect->fRight >> shiftUp, clipRect->fBottom >> shiftUp);
qclipper.setClip(r);
}
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kLine_Verb:
if (edge->setLine(pts[0], pts[1], clipRect, shiftUp)) {
*list++ = edge;
edge = (SkEdge*)((char*)edge + sizeof(SkEdge));
}
break;
case SkPath::kQuad_Verb: {
SkPoint tmp[5], clippedPts[3];
SkPoint* p = tmp;
int count = SkChopQuadAtYExtrema(pts, tmp);
do {
const SkPoint* qpts = p;
if (clipRect) {
if (!qclipper.clipQuad(p, clippedPts)) {
goto NEXT_CHOPPED_QUAD;
}
qpts = clippedPts;
}
if (((SkQuadraticEdge*)edge)->setQuadratic(qpts, shiftUp)) {
*list++ = edge;
edge = (SkEdge*)((char*)edge + sizeof(SkQuadraticEdge));
}
NEXT_CHOPPED_QUAD:
p += 2;
} while (--count >= 0);
break;
}
case SkPath::kCubic_Verb: {
SkPoint tmp[10];
SkPoint* p = tmp;
int count = SkChopCubicAtYExtrema(pts, tmp);
SkASSERT(count >= 0 && count <= 2);
do {
if (((SkCubicEdge*)edge)->setCubic(p, clipRect, shiftUp))
{
*list++ = edge;
edge = (SkEdge*)((char*)edge + sizeof(SkCubicEdge));
}
p += 3;
} while (--count >= 0);
break;
}
default:
break;
}
}
return (int)(list - start);
}
#ifdef SK_DEBUG
/* 'quick' computation of the max sized needed to allocated for
our edgelist.
*/
static int worst_case_edge_count(const SkPath& path, size_t* storage) {
size_t size = 0;
int edgeCount = 0;
SkPath::Iter iter(path, true);
SkPath::Verb verb;
while ((verb = iter.next(NULL)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kLine_Verb:
edgeCount += 1;
size += sizeof(SkQuadraticEdge); // treat line like Quad (in case its > 512)
break;
case SkPath::kQuad_Verb:
edgeCount += 2; // might need 2 edges when we chop on Y extrema
size += 2 * sizeof(SkQuadraticEdge);
break;
case SkPath::kCubic_Verb:
edgeCount += 3; // might need 3 edges when we chop on Y extrema
size += 3 * sizeof(SkCubicEdge);
break;
default:
break;
}
}
SkASSERT(storage);
*storage = size;
return edgeCount;
}
#endif
/* Much faster than worst_case_edge_count, but over estimates even more
*/
static int cheap_worst_case_edge_count(const SkPath& path, size_t* storage) {
int ptCount = path.getPoints(NULL, 0);
// worst case is curve, close, curve, close, as that is
// 2 lines per pt, or : pts * 2
// 2 quads + 1 line per 2 pts, or : pts * 3 / 2
// 3 cubics + 1 line per 3 pts : pts * 4 / 3
int edgeCount = ptCount << 1;
// worst storage, due to relative size of different edge types, is
// quads * 3 / 2
size_t quadSize = (ptCount * 3 >> 1) * sizeof(SkQuadraticEdge);
#if 0
size_t lineSize = (ptCount << 1) * sizeof(SkEdge);
size_t cubicSize = (ptCount * 3 / 4) * sizeof(SkCubicEdge);
SkASSERT(lineSize <= quadSize);
SkASSERT(cubicSize <= quadSize);
#endif
*storage = quadSize;
return edgeCount;
}
#endif
///////////////////////////////////////////////////////////////////////////////
extern "C" {
static int edge_compare(const void* a, const void* b) {
const SkEdge* edgea = *(const SkEdge**)a;
const SkEdge* edgeb = *(const SkEdge**)b;
int valuea = edgea->fFirstY;
int valueb = edgeb->fFirstY;
if (valuea == valueb) {
valuea = edgea->fX;
valueb = edgeb->fX;
}
// this overflows if valuea >>> valueb or vice-versa
// return valuea - valueb;
// do perform the slower but safe compares
return (valuea < valueb) ? -1 : (valuea > valueb);
}
}
static SkEdge* sort_edges(SkEdge* list[], int count, SkEdge** last) {
qsort(list, count, sizeof(SkEdge*), edge_compare);
// now make the edges linked in sorted order
for (int i = 1; i < count; i++) {
list[i - 1]->fNext = list[i];
list[i]->fPrev = list[i - 1];
}
*last = list[count - 1];
return list[0];
}
// clipRect may be null, even though we always have a clip. This indicates that
// the path is contained in the clip, and so we can ignore it during the blit
//
// clipRect (if no null) has already been shifted up
//
void sk_fill_path(const SkPath& path, const SkIRect* clipRect, SkBlitter* blitter,
int start_y, int stop_y, int shiftEdgesUp,
const SkRegion& clipRgn) {
SkASSERT(&path && blitter);
#ifdef USE_NEW_BUILDER
SkEdgeBuilder builder;
int count = builder.build(path, clipRect, shiftEdgesUp);
SkEdge** list = builder.edgeList();
#else
size_t size;
int maxCount = cheap_worst_case_edge_count(path, &size);
#ifdef SK_DEBUG
{
size_t size2;
int maxCount2 = worst_case_edge_count(path, &size2);
SkASSERT(maxCount >= maxCount2 && size >= size2);
}
#endif
SkAutoMalloc memory(maxCount * sizeof(SkEdge*) + size);
SkEdge** list = (SkEdge**)memory.get();
SkEdge* initialEdge = (SkEdge*)(list + maxCount);
int count = build_edges(initialEdge, path, clipRect, list,
shiftEdgesUp);
SkASSERT(count <= maxCount);
#endif
if (count < 2) {
if (path.isInverseFillType()) {
const SkIRect& clipRect = clipRgn.getBounds();
blitter->blitRect(clipRect.fLeft << shiftEdgesUp,
clipRect.fTop << shiftEdgesUp,
clipRect.width() << shiftEdgesUp,
clipRect.height() << shiftEdgesUp);
}
return;
}
SkEdge headEdge, tailEdge, *last;
// this returns the first and last edge after they're sorted into a dlink list
SkEdge* edge = sort_edges(list, count, &last);
headEdge.fPrev = NULL;
headEdge.fNext = edge;
headEdge.fFirstY = kEDGE_HEAD_Y;
headEdge.fX = SK_MinS32;
edge->fPrev = &headEdge;
tailEdge.fPrev = last;
tailEdge.fNext = NULL;
tailEdge.fFirstY = kEDGE_TAIL_Y;
last->fNext = &tailEdge;
// now edge is the head of the sorted linklist
start_y <<= shiftEdgesUp;
stop_y <<= shiftEdgesUp;
if (clipRect && start_y < clipRect->fTop) {
start_y = clipRect->fTop;
}
if (clipRect && stop_y > clipRect->fBottom) {
stop_y = clipRect->fBottom;
}
InverseBlitter ib;
PrePostProc proc = NULL;
if (path.isInverseFillType()) {
ib.setBlitter(blitter, clipRgn.getBounds(), shiftEdgesUp);
blitter = &ib;
proc = PrePostInverseBlitterProc;
}
walk_edges(&headEdge, path.getFillType(), blitter, start_y, stop_y, proc);
}
void sk_blit_above(SkBlitter* blitter, const SkIRect& ir, const SkRegion& clip) {
const SkIRect& cr = clip.getBounds();
SkIRect tmp;
tmp.fLeft = cr.fLeft;
tmp.fRight = cr.fRight;
tmp.fTop = cr.fTop;
tmp.fBottom = ir.fTop;
if (!tmp.isEmpty()) {
blitter->blitRectRegion(tmp, clip);
}
}
void sk_blit_below(SkBlitter* blitter, const SkIRect& ir, const SkRegion& clip) {
const SkIRect& cr = clip.getBounds();
SkIRect tmp;
tmp.fLeft = cr.fLeft;
tmp.fRight = cr.fRight;
tmp.fTop = ir.fBottom;
tmp.fBottom = cr.fBottom;
if (!tmp.isEmpty()) {
blitter->blitRectRegion(tmp, clip);
}
}
///////////////////////////////////////////////////////////////////////////////
SkScanClipper::SkScanClipper(SkBlitter* blitter, const SkRegion* clip,
const SkIRect& ir) {
fBlitter = NULL; // null means blit nothing
fClipRect = NULL;
if (clip) {
fClipRect = &clip->getBounds();
if (!SkIRect::Intersects(*fClipRect, ir)) { // completely clipped out
return;
}
if (clip->isRect()) {
if (fClipRect->contains(ir)) {
fClipRect = NULL;
} else {
// only need a wrapper blitter if we're horizontally clipped
if (fClipRect->fLeft > ir.fLeft || fClipRect->fRight < ir.fRight) {
fRectBlitter.init(blitter, *fClipRect);
blitter = &fRectBlitter;
}
}
} else {
fRgnBlitter.init(blitter, clip);
blitter = &fRgnBlitter;
}
}
fBlitter = blitter;
}
///////////////////////////////////////////////////////////////////////////////
static bool clip_to_limit(const SkRegion& orig, SkRegion* reduced) {
const int32_t limit = 32767;
SkIRect limitR;
limitR.set(-limit, -limit, limit, limit);
if (limitR.contains(orig.getBounds())) {
return false;
}
reduced->op(orig, limitR, SkRegion::kIntersect_Op);
return true;
}
void SkScan::FillPath(const SkPath& path, const SkRegion& origClip,
SkBlitter* blitter) {
if (origClip.isEmpty()) {
return;
}
// Our edges are fixed-point, and don't like the bounds of the clip to
// exceed that. Here we trim the clip just so we don't overflow later on
const SkRegion* clipPtr = &origClip;
SkRegion finiteClip;
if (clip_to_limit(origClip, &finiteClip)) {
if (finiteClip.isEmpty()) {
return;
}
clipPtr = &finiteClip;
}
// don't reference "origClip" any more, just use clipPtr
SkIRect ir;
path.getBounds().round(&ir);
if (ir.isEmpty()) {
if (path.isInverseFillType()) {
blitter->blitRegion(*clipPtr);
}
return;
}
SkScanClipper clipper(blitter, clipPtr, ir);
blitter = clipper.getBlitter();
if (blitter) {
// we have to keep our calls to blitter in sorted order, so we
// must blit the above section first, then the middle, then the bottom.
if (path.isInverseFillType()) {
sk_blit_above(blitter, ir, *clipPtr);
}
sk_fill_path(path, clipper.getClipRect(), blitter, ir.fTop, ir.fBottom,
0, *clipPtr);
if (path.isInverseFillType()) {
sk_blit_below(blitter, ir, *clipPtr);
}
} else {
// what does it mean to not have a blitter if path.isInverseFillType???
}
}
///////////////////////////////////////////////////////////////////////////////
static int build_tri_edges(SkEdge edge[], const SkPoint pts[],
const SkIRect* clipRect, SkEdge* list[]) {
SkEdge** start = list;
if (edge->setLine(pts[0], pts[1], clipRect, 0)) {
*list++ = edge;
edge = (SkEdge*)((char*)edge + sizeof(SkEdge));
}
if (edge->setLine(pts[1], pts[2], clipRect, 0)) {
*list++ = edge;
edge = (SkEdge*)((char*)edge + sizeof(SkEdge));
}
if (edge->setLine(pts[2], pts[0], clipRect, 0)) {
*list++ = edge;
}
return (int)(list - start);
}
static void sk_fill_triangle(const SkPoint pts[], const SkIRect* clipRect,
SkBlitter* blitter, const SkIRect& ir) {
SkASSERT(pts && blitter);
SkEdge edgeStorage[3];
SkEdge* list[3];
int count = build_tri_edges(edgeStorage, pts, clipRect, list);
if (count < 2) {
return;
}
SkEdge headEdge, tailEdge, *last;
// this returns the first and last edge after they're sorted into a dlink list
SkEdge* edge = sort_edges(list, count, &last);
headEdge.fPrev = NULL;
headEdge.fNext = edge;
headEdge.fFirstY = kEDGE_HEAD_Y;
headEdge.fX = SK_MinS32;
edge->fPrev = &headEdge;
tailEdge.fPrev = last;
tailEdge.fNext = NULL;
tailEdge.fFirstY = kEDGE_TAIL_Y;
last->fNext = &tailEdge;
// now edge is the head of the sorted linklist
int stop_y = ir.fBottom;
if (clipRect && stop_y > clipRect->fBottom) {
stop_y = clipRect->fBottom;
}
int start_y = ir.fTop;
if (clipRect && start_y < clipRect->fTop) {
start_y = clipRect->fTop;
}
walk_edges(&headEdge, SkPath::kEvenOdd_FillType, blitter, start_y, stop_y, NULL);
}
void SkScan::FillTriangle(const SkPoint pts[], const SkRegion* clip,
SkBlitter* blitter) {
if (clip && clip->isEmpty()) {
return;
}
SkRect r;
SkIRect ir;
r.set(pts, 3);
r.round(&ir);
if (ir.isEmpty()) {
return;
}
SkScanClipper clipper(blitter, clip, ir);
blitter = clipper.getBlitter();
if (NULL != blitter) {
sk_fill_triangle(pts, clipper.getClipRect(), blitter, ir);
}
}