The Tor Browser / file revision

 /*

  * 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.

  */

 #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)

 /** @file

     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

     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

     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.

  */

 //#define FORCE_SUPERMASK

 //#define FORCE_RLE

 //#define SK_USE_LEGACY_AA_COVERAGE

 ///////////////////////////////////////////////////////////////////////////////

 /// Base class for a single-pass supersampled blitter.

 class BaseSuperBlitter : public SkBlitter {

 public:

     BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,

                      const SkRegion& clip);

     /// Must be explicitly defined on subclasses.

     virtual void blitAntiH(int x, int y, const SkAlpha antialias[],

                            const int16_t runs[]) SK_OVERRIDE {

         SkDEBUGFAIL("How did I get here?");

     }

     /// May not be called on BaseSuperBlitter because it blits out of order.

     virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE {

         SkDEBUGFAIL("How did I get here?");

     }

 protected:

     SkBlitter*  fRealBlitter;

     /// Current y coordinate, in destination coordinates.

     int         fCurrIY;

     /// 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;

     SkDEBUGCODE(int fCurrX;)

     /// Current y coordinate in supersampled coordinates.

     int fCurrY;

     /// Initial y coordinate (top of bounds).

     int fTop;

 };

 BaseSuperBlitter::BaseSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,

                                    const SkRegion& clip) {

     fRealBlitter = realBlitter;

     /*

      *  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;

     fLeft = left;

     fSuperLeft = left << SHIFT;

     fWidth = right - left;

 #if 0

     fCurrIY = -1;

     fCurrY = -1;

 #else

     fTop = ir.fTop;

     fCurrIY = ir.fTop - 1;

     fCurrY = (ir.fTop << SHIFT) - 1;

 #endif

     SkDEBUGCODE(fCurrX = -1;)

 }

 /// Run-length-encoded supersampling antialiased blitter.

 class SuperBlitter : public BaseSuperBlitter {

 public:

     SuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,

                  const SkRegion& clip);

     virtual ~SuperBlitter() {

         this->flush();

         sk_free(fRuns.fRuns);

     }

     /// Once fRuns contains a complete supersampled row, flush() blits

     /// it out through the wrapped blitter.

     void flush();

     /// Blits a row of pixels, with location and width specified

     /// in supersampled coordinates.

     virtual void blitH(int x, int y, int width) SK_OVERRIDE;

     /// Blits a rectangle of pixels, with location and size specified

     /// in supersampled coordinates.

     virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;

 private:

     SkAlphaRuns fRuns;

     int         fOffsetX;

 };

 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);

     fOffsetX = 0;

 }

 void SuperBlitter::flush() {

     if (fCurrIY >= fTop) {

         if (!fRuns.empty()) {

         //  SkDEBUGCODE(fRuns.dump();)

             fRealBlitter->blitAntiH(fLeft, fCurrIY, fRuns.fAlpha, fRuns.fRuns);

             fRuns.reset(fWidth);

             fOffsetX = 0;

         }

         fCurrIY = fTop - 1;

         SkDEBUGCODE(fCurrX = -1;)

     }

 }

 /** 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) {

     aa <<= 8 - 2*SHIFT;

 #ifdef SK_USE_LEGACY_AA_COVERAGE

     aa -= aa >> (8 - SHIFT - 1);

 #endif

     return aa;

 }

 /** coverage_to_exact_alpha() is being used by our blitter, which wants

     a final value in [0, 255].

 */

 static inline int coverage_to_exact_alpha(int aa) {

     int alpha = (256 >> SHIFT) * aa;

     // clamp 256->255

     return alpha - (alpha >> 8);

 }

 void SuperBlitter::blitH(int x, int y, int width) {

     SkASSERT(width > 0);

     int iy = y >> SHIFT;

     SkASSERT(iy >= fCurrIY);

     x -= fSuperLeft;

     // hack, until I figure out why my cubics (I think) go beyond the bounds

     if (x < 0) {

         width += x;

         x = 0;

     }

 #ifdef SK_DEBUG

     SkASSERT(y != fCurrY || x >= fCurrX);

 #endif

     SkASSERT(y >= fCurrY);

     if (fCurrY != y) {

         fOffsetX = 0;

         fCurrY = y;

     }

     if (iy != fCurrIY) {  // new scanline

         this->flush();

         fCurrIY = iy;

     }

     int start = x;

     int stop = x + width;

     SkASSERT(start >= 0 && stop > start);

     // integer-pixel-aligned ends of blit, rounded out

     int fb = start & MASK;

     int fe = stop & MASK;

     int n = (stop >> SHIFT) - (start >> SHIFT) - 1;

     if (n < 0) {

         fb = fe - fb;

         n = 0;

         fe = 0;

     } else {

         if (fb == 0) {

             n += 1;

         } else {

             fb = SCALE - fb;

         }

     }

     fOffsetX = fRuns.add(x >> SHIFT, coverage_to_partial_alpha(fb),

                          n, coverage_to_partial_alpha(fe),

                          (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT),

                          fOffsetX);

 #ifdef SK_DEBUG

     fRuns.assertValid(y & MASK, (1 << (8 - SHIFT)));

     fCurrX = x + width;

 #endif

 }

 #if 0 // UNUSED

 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;

 }

 #endif

 void SuperBlitter::blitRect(int x, int y, int width, int height) {

     SkASSERT(width > 0);

     SkASSERT(height > 0);

     // blit leading rows

     while ((y & MASK)) {

         this->blitH(x, y++, width);

         if (--height <= 0) {

             return;

         }

     }

     SkASSERT(height > 0);

     // 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.

     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;

         }

         // 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.

         int ileft = x >> SHIFT;

         int xleft = x & MASK;

         // 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.

         int irite = (x + width) >> SHIFT;

         int xrite = (x + width) & MASK;

         if (!xrite) {

             xrite = SCALE;

             irite--;

         }

         // 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();

         int n = irite - ileft - 1;

         if (n < 0) {

             // If n < 0, we'll only have a single partially-transparent column

             // of pixels to render.

             xleft = xrite - xleft;

             SkASSERT(xleft <= SCALE);

             SkASSERT(xleft > 0);

             xrite = 0;

             fRealBlitter->blitV(ileft + fLeft, start_y, count,

                 coverage_to_exact_alpha(xleft));

         } else {

             // With n = 0, we have two possibly-transparent columns of pixels

             // to render; with n > 0, we have opaque columns between them.

             xleft = SCALE - xleft;

             // 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);

             SkASSERT(coverageL > 0 || n > 0 || coverageR > 0);

             SkASSERT((coverageL != 0) + n + (coverageR != 0) <= fWidth);

             fRealBlitter->blitAntiRect(ileft + fLeft, start_y, n, count,

                                        coverageL, coverageR);

         }

         // preamble for our next call to blitH()

         fCurrIY = stop_y - 1;

         fOffsetX = 0;

         fCurrY = y - 1;

         fRuns.reset(fWidth);

         x = origX;

     }

     // catch any remaining few rows

     SkASSERT(height <= MASK);

     while (--height >= 0) {

         this->blitH(x, y++, width);

     }

 }

 ///////////////////////////////////////////////////////////////////////////////

 /// Masked supersampling antialiased blitter.

 class MaskSuperBlitter : public BaseSuperBlitter {

 public:

     MaskSuperBlitter(SkBlitter* realBlitter, const SkIRect& ir,

                      const SkRegion& clip);

     virtual ~MaskSuperBlitter() {

         fRealBlitter->blitMask(fMask, fClipRect);

     }

     virtual void blitH(int x, int y, int width) SK_OVERRIDE;

     static bool CanHandleRect(const SkIRect& bounds) {

 #ifdef FORCE_RLE

         return false;

 #endif

         int width = bounds.width();

         int64_t rb = SkAlign4(width);

         // use 64bits to detect overflow

         int64_t storage = rb * bounds.height();

         return (width <= MaskSuperBlitter::kMAX_WIDTH) &&

                (storage <= MaskSuperBlitter::kMAX_STORAGE);

     }

 private:

     enum {

 #ifdef FORCE_SUPERMASK

         kMAX_WIDTH = 2048,

         kMAX_STORAGE = 1024 * 1024 * 2

 #else

         kMAX_WIDTH = 32,    // so we don't try to do very wide things, where the RLE blitter would be faster

         kMAX_STORAGE = 1024

 #endif

     };

     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;

     fClipRect = ir;

     fClipRect.intersect(clip.getBounds());

     // 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);

 }

 static void add_aa_span(uint8_t* alpha, U8CPU startAlpha) {

     /*  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));

 }

 static inline uint32_t quadplicate_byte(U8CPU value) {

     uint32_t pair = (value << 8) | value;

     return (pair << 16) | pair;

 }

 // 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));

 }

 // 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) {

     SkASSERT(middleCount >= 0);

     saturated_add(alpha, startAlpha);

     alpha += 1;

     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) {

         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[]

     saturated_add(alpha, stopAlpha);

 }

 void MaskSuperBlitter::blitH(int x, int y, int width) {

     int iy = (y >> SHIFT);

     SkASSERT(iy >= fMask.fBounds.fTop && iy < fMask.fBounds.fBottom);

     iy -= fMask.fBounds.fTop;   // make it relative to 0

     // 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;

     }

 #ifdef SK_DEBUG

     {

         int ix = x >> SHIFT;

         SkASSERT(ix >= fMask.fBounds.fLeft && ix < fMask.fBounds.fRight);

     }

 #endif

     x -= (fMask.fBounds.fLeft << SHIFT);

     // hack, until I figure out why my cubics (I think) go beyond the bounds

     if (x < 0) {

         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);

     int fb = start & MASK;

     int fe = stop & MASK;

     int n = (stop >> SHIFT) - (start >> SHIFT) - 1;

     if (n < 0) {

         SkASSERT(row >= fMask.fImage);

         SkASSERT(row < fMask.fImage + kMAX_STORAGE + 1);

         add_aa_span(row, coverage_to_partial_alpha(fe - fb));

     } else {

         fb = SCALE - fb;

         SkASSERT(row >= fMask.fImage);

         SkASSERT(row + n + 1 < fMask.fImage + kMAX_STORAGE + 1);

         add_aa_span(row,  coverage_to_partial_alpha(fb),

                     n, coverage_to_partial_alpha(fe),

                     (1 << (8 - SHIFT)) - (((y & MASK) + 1) >> SHIFT));

     }

 #ifdef SK_DEBUG

     fCurrX = x + width;

 #endif

 }

 ///////////////////////////////////////////////////////////////////////////////

 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;

 }

 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);

 }

 static bool safeRoundOut(const SkRect& src, SkIRect* dst, int32_t maxInt) {

     const SkScalar maxScalar = SkIntToScalar(maxInt);

     if (fitsInsideLimit(src, maxScalar)) {

         src.roundOut(dst);

         return true;

     }

     return false;

 }

 void SkScan::AntiFillPath(const SkPath& path, const SkRegion& origClip,

                           SkBlitter* blitter, bool forceRLE) {

     if (origClip.isEmpty()) {

         return;

     }

     SkIRect ir;

     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;

     }

     if (ir.isEmpty()) {

         if (path.isInverseFillType()) {

             blitter->blitRegion(origClip);

         }

         return;

     }

     // 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;

     }

     // 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).

     //

     // 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...

     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);

     const SkIRect*  clipRect = clipper.getClipRect();

     if (clipper.getBlitter() == NULL) { // clipped out

         if (path.isInverseFillType()) {

             blitter->blitRegion(*clipRgn);

         }

         return;

     }

     // now use the (possibly wrapped) blitter

     blitter = clipper.getBlitter();

     if (path.isInverseFillType()) {

         sk_blit_above(blitter, ir, *clipRgn);

     }

     SkIRect superRect, *superClipRect = NULL;

     if (clipRect) {

         superRect.set(  clipRect->fLeft << SHIFT, clipRect->fTop << SHIFT,

                         clipRect->fRight << SHIFT, clipRect->fBottom << SHIFT);

         superClipRect = &superRect;

     }

     SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);

     // MaskSuperBlitter can't handle drawing outside of ir, so we can't use it

     // if we're an inverse filltype

     if (!path.isInverseFillType() && MaskSuperBlitter::CanHandleRect(ir) && !forceRLE) {

         MaskSuperBlitter    superBlit(blitter, ir, *clipRgn);

         SkASSERT(SkIntToScalar(ir.fTop) <= path.getBounds().fTop);

         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);

     } else {

         SuperBlitter    superBlit(blitter, ir, *clipRgn);

         sk_fill_path(path, superClipRect, &superBlit, ir.fTop, ir.fBottom, SHIFT, *clipRgn);

     }

     if (path.isInverseFillType()) {

         sk_blit_below(blitter, ir, *clipRgn);

     }

 }

 ///////////////////////////////////////////////////////////////////////////////

 #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);

     }

 }