Revert "Revert "speed up A8 by creating a new entry-point in SkDraw that blits the path's coverage directly into an A8 target, regardless of the previous pixel values.""

This reverts commit 3c77887b3eb2d32ab668ab4e5f2f9e79103956e8.

BUG=

Review URL: https://codereview.chromium.org/50673005

git-svn-id: http://skia.googlecode.com/svn/trunk@12167 2bbb7eff-a529-9590-31e7-b0007b416f81

10 files changed, 229 insertions, 21 deletions

diff --git a/bench/CoverageBench.cpp b/bench/CoverageBench.cpp
new file mode 100644
index 0000000000..de09733cf8
--- /dev/null
+++ b/bench/CoverageBench.cpp
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkBenchmark.h"
+#include "SkBitmap.h"
+#include "SkCanvas.h"
+#include "SkColorPriv.h"
+#include "SkDraw.h"
+#include "SkMatrix.h"
+#include "SkPath.h"
+#include "SkRasterClip.h"
+
+class DrawPathBench : public SkBenchmark {
+    SkPaint     fPaint;
+    SkString    fName;
+    SkPath      fPath;
+    SkRasterClip fRC;
+    SkBitmap    fBitmap;
+    SkMatrix    fIdentity;
+    SkDraw      fDraw;
+    bool        fDrawCoverage;
+public:
+    DrawPathBench(bool drawCoverage) : fDrawCoverage(drawCoverage) {
+        fPaint.setAntiAlias(true);
+        fName.printf("draw_coverage_%s", drawCoverage ? "true" : "false");
+
+        fPath.moveTo(0, 0);
+        fPath.quadTo(500, 0, 500, 500);
+        fPath.quadTo(250, 0, 0, 500);
+
+        fBitmap.setConfig(SkBitmap::kA8_Config, 500, 500);
+        fBitmap.allocPixels();
+
+        fIdentity.setIdentity();
+        fRC.setRect(fPath.getBounds().round());
+
+        fDraw.fBitmap   = &fBitmap;
+        fDraw.fMatrix   = &fIdentity;
+        fDraw.fClip     = &fRC.bwRgn();
+        fDraw.fRC       = &fRC;
+    }
+    
+protected:
+    virtual const char* onGetName() SK_OVERRIDE {
+        return fName.c_str();
+    }
+    
+    virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
+        if (fDrawCoverage) {
+            for (int i = 0; i < this->getLoops(); ++i) {
+                fDraw.drawPathCoverage(fPath, fPaint);
+            }
+        } else {
+            for (int i = 0; i < this->getLoops(); ++i) {
+                fDraw.drawPath(fPath, fPaint);
+            }
+        }
+    }
+    
+private:
+    typedef SkBenchmark INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+DEF_BENCH( return new DrawPathBench(false) )
+DEF_BENCH( return new DrawPathBench(true) )
diff --git a/gyp/bench.gypi b/gyp/bench.gypi
index de1d861bdf..0274176a1c 100644
--- a/gyp/bench.gypi
+++ b/gyp/bench.gypi
@@ -19,6 +19,7 @@
     '../bench/ChromeBench.cpp',
     '../bench/CmapBench.cpp',
     '../bench/ColorFilterBench.cpp',
+    '../bench/CoverageBench.cpp',
     '../bench/DashBench.cpp',
     '../bench/DecodeBench.cpp',
     '../bench/DeferredCanvasBench.cpp',
diff --git a/include/core/SkDraw.h b/include/core/SkDraw.h
index 772e11e00d..9183094679 100644
--- a/include/core/SkDraw.h
+++ b/include/core/SkDraw.h
@@ -43,8 +43,15 @@ public:
      *  affect the geometry/rasterization, then the pre matrix can just be
      *  pre-concated with the current matrix.
      */
-    void    drawPath(const SkPath& srcPath, const SkPaint&,
-                     const SkMatrix* prePathMatrix, bool pathIsMutable) const;
+    void    drawPath(const SkPath& path, const SkPaint& paint,
+                     const SkMatrix* prePathMatrix, bool pathIsMutable) const {
+        this->drawPath(path, paint, prePathMatrix, pathIsMutable, false);
+    }
+
+    void drawPath(const SkPath& path, const SkPaint& paint) const {
+        this->drawPath(path, paint, NULL, false, false);
+    }
+
     void    drawBitmap(const SkBitmap&, const SkMatrix&, const SkPaint&) const;
     void    drawSprite(const SkBitmap&, int x, int y, const SkPaint&) const;
     void    drawText(const char text[], size_t byteLength, SkScalar x,
@@ -65,8 +72,14 @@ public:
                          const uint16_t indices[], int ptCount,
                          const SkPaint& paint) const;
 
-    void drawPath(const SkPath& src, const SkPaint& paint) const {
-        this->drawPath(src, paint, NULL, false);
+    /**
+     *  Overwrite the target with the path's coverage (i.e. its mask).
+     *  Will overwrite the entire device, so it need not be zero'd first.
+     *
+     *  Only device A8 is supported right now.
+     */
+    void drawPathCoverage(const SkPath& src, const SkPaint& paint) const {
+        this->drawPath(src, paint, NULL, false, true);
     }
 
     /** Helper function that creates a mask from a path and an optional maskfilter.
@@ -107,6 +120,9 @@ private:
     void    drawDevMask(const SkMask& mask, const SkPaint&) const;
     void    drawBitmapAsMask(const SkBitmap&, const SkPaint&) const;
 
+    void    drawPath(const SkPath&, const SkPaint&, const SkMatrix* preMatrix,
+                     bool pathIsMutable, bool drawCoverage) const;
+
     /**
      *  Return the current clip bounds, in local coordinates, with slop to account
      *  for antialiasing or hairlines (i.e. device-bounds outset by 1, and then
diff --git a/include/core/SkRect.h b/include/core/SkRect.h
index 98acb1cda3..8bfa57a8f9 100644
--- a/include/core/SkRect.h
+++ b/include/core/SkRect.h
@@ -730,7 +730,7 @@ struct SK_API SkRect {
 
     /**
      *  Set the dst rectangle by rounding this rectangle's coordinates to their
-     *  nearest integer values using SkScalarRound.
+     *  nearest integer values using SkScalarRoundToInt.
      */
     void round(SkIRect* dst) const {
         SkASSERT(dst);
@@ -772,6 +772,15 @@ struct SK_API SkRect {
                  SkScalarFloorToInt(fRight), SkScalarFloorToInt(fBottom));
     }
 
+    /**
+     *  Return a new SkIRect which is contains the rounded coordinates of this
+     *  rect using SkScalarRoundToInt.
+     */
+    SkIRect round() const {
+        SkIRect ir;
+        this->round(&ir);
+        return ir;
+    }
 
     /**
      *  Swap top/bottom or left/right if there are flipped (i.e. if width()
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index f4e1a37c80..f46db357d4 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -850,14 +850,16 @@ static XferInterp interpret_xfermode(const SkPaint& paint, SkXfermode* xfer,
 SkBlitter* SkBlitter::Choose(const SkBitmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
-                             void* storage, size_t storageSize) {
+                             void* storage, size_t storageSize,
+                             bool drawCoverage) {
     SkASSERT(storageSize == 0 || storage != NULL);
 
     SkBlitter*  blitter = NULL;
 
     // which check, in case we're being called by a client with a dummy device
     // (e.g. they have a bounder that always aborts the draw)
-    if (SkBitmap::kNo_Config == device.config()) {
+    if (SkBitmap::kNo_Config == device.config() ||
+            (drawCoverage && (SkBitmap::kA8_Config != device.config()))) {
         SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
         return blitter;
     }
@@ -940,6 +942,7 @@ SkBlitter* SkBlitter::Choose(const SkBitmap& device,
         return blitter;
     }
 
+    
     switch (device.config()) {
         case SkBitmap::kA1_Config:
             SK_PLACEMENT_NEW_ARGS(blitter, SkA1_Blitter,
@@ -947,7 +950,12 @@ SkBlitter* SkBlitter::Choose(const SkBitmap& device,
             break;
 
         case SkBitmap::kA8_Config:
-            if (shader) {
+            if (drawCoverage) {
+                SkASSERT(NULL == shader);
+                SkASSERT(NULL == paint->getXfermode());
+                SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Coverage_Blitter,
+                                      storage, storageSize, (device, *paint));
+            } else if (shader) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Shader_Blitter,
                                       storage, storageSize, (device, *paint));
             } else {
diff --git a/src/core/SkBlitter.h b/src/core/SkBlitter.h
index 0a075f89ad..b659fe4735 100644
--- a/src/core/SkBlitter.h
+++ b/src/core/SkBlitter.h
@@ -76,7 +76,8 @@ public:
     static SkBlitter* Choose(const SkBitmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& paint,
-                             void* storage, size_t storageSize);
+                             void* storage, size_t storageSize,
+                             bool drawCoverage = false);
 
     static SkBlitter* ChooseSprite(const SkBitmap& device,
                                    const SkPaint&,
diff --git a/src/core/SkBlitter_A8.cpp b/src/core/SkBlitter_A8.cpp
index 7fca29ecf5..1df033f54b 100644
--- a/src/core/SkBlitter_A8.cpp
+++ b/src/core/SkBlitter_A8.cpp
@@ -347,3 +347,93 @@ void SkA8_Shader_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
         alpha += mask.fRowBytes;
     }
 }
+
+///////////////////////////////////////////////////////////////////////////////
+
+#define SK_A8_COVERAGE_BLIT_SKIP_ZEROS
+
+SkA8_Coverage_Blitter::SkA8_Coverage_Blitter(const SkBitmap& device,
+                             const SkPaint& paint) : SkRasterBlitter(device) {
+    SkASSERT(NULL == paint.getShader());
+    SkASSERT(NULL == paint.getXfermode());
+    SkASSERT(NULL == paint.getColorFilter());
+}
+
+void SkA8_Coverage_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
+                                      const int16_t runs[]) {
+    SkASSERT(0 == x);
+
+    uint8_t* device = fDevice.getAddr8(x, y);
+    SkDEBUGCODE(int totalCount = 0;)
+    
+    for (;;) {
+        int count = runs[0];
+        SkASSERT(count >= 0);
+        if (count == 0) {
+            return;
+        }
+#ifdef SK_A8_COVERAGE_BLIT_SKIP_ZEROS
+        if (antialias[0])
+#endif
+        {
+            memset(device, antialias[0], count);
+        }
+        runs += count;
+        antialias += count;
+        device += count;
+
+        SkDEBUGCODE(totalCount += count;)
+    }
+    SkASSERT(fDevice.width() == totalCount);
+}
+
+void SkA8_Coverage_Blitter::blitH(int x, int y, int width) {
+    memset(fDevice.getAddr8(x, y), 0xFF, width);
+}
+
+void SkA8_Coverage_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
+#ifdef SK_A8_COVERAGE_BLIT_SKIP_ZEROS
+    if (0 == alpha) {
+        return;
+    }
+#endif
+    uint8_t* dst = fDevice.getAddr8(x, y);
+    const size_t dstRB = fDevice.rowBytes();
+    while (--height >= 0) {
+        *dst = alpha;
+        dst += dstRB;
+    }
+}
+
+void SkA8_Coverage_Blitter::blitRect(int x, int y, int width, int height) {
+    uint8_t* dst = fDevice.getAddr8(x, y);
+    const size_t dstRB = fDevice.rowBytes();
+    while (--height >= 0) {
+        memset(dst, 0xFF, width);
+        dst += dstRB;
+    }
+}
+
+void SkA8_Coverage_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
+    SkASSERT(SkMask::kA8_Format == mask.fFormat);
+
+    int x = clip.fLeft;
+    int y = clip.fTop;
+    int width = clip.width();
+    int height = clip.height();
+
+    uint8_t* dst = fDevice.getAddr8(x, y);
+    const uint8_t* src = mask.getAddr8(x, y);
+    const size_t srcRB = mask.fRowBytes;
+    const size_t dstRB = fDevice.rowBytes();
+    
+    while (--height >= 0) {
+        memcpy(dst, src, width);
+        dst += dstRB;
+        src += srcRB;
+    }
+}
+
+const SkBitmap* SkA8_Coverage_Blitter::justAnOpaqueColor(uint32_t*) {
+    return NULL;
+}
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 9455509c48..673b874545 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -40,6 +40,17 @@ private:
 
 ///////////////////////////////////////////////////////////////////////////////
 
+class SkA8_Coverage_Blitter : public SkRasterBlitter {
+public:
+    SkA8_Coverage_Blitter(const SkBitmap& device, const SkPaint& paint);
+    virtual void blitH(int x, int y, int width) SK_OVERRIDE;
+    virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]) SK_OVERRIDE;
+    virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
+    virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
+    virtual void blitMask(const SkMask&, const SkIRect&) SK_OVERRIDE;
+    virtual const SkBitmap* justAnOpaqueColor(uint32_t*) SK_OVERRIDE;
+};
+
 class SkA8_Blitter : public SkRasterBlitter {
 public:
     SkA8_Blitter(const SkBitmap& device, const SkPaint& paint);
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index df73f7ae37..af4f1ca047 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -59,9 +59,9 @@ public:
         fBlitter = NULL;
     }
     SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix,
-                        const SkPaint& paint) {
+                        const SkPaint& paint, bool drawCoverage = false) {
         fBlitter = SkBlitter::Choose(device, matrix, paint,
-                                     fStorage, sizeof(fStorage));
+                                     fStorage, sizeof(fStorage), drawCoverage);
     }
 
     ~SkAutoBlitterChoose();
@@ -1023,7 +1023,8 @@ bool SkDrawTreatAsHairline(const SkPaint& paint, const SkMatrix& matrix,
 }
 
 void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
-                      const SkMatrix* prePathMatrix, bool pathIsMutable) const {
+                      const SkMatrix* prePathMatrix, bool pathIsMutable,
+                      bool drawCoverage) const {
     SkDEBUGCODE(this->validate();)
 
     // nothing to draw
@@ -1112,7 +1113,7 @@ void SkDraw::drawPath(const SkPath& origSrcPath, const SkPaint& origPaint,
     // transform the path into device space
     pathPtr->transform(*matrix, devPathPtr);
 
-    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint);
+    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, *paint, drawCoverage);
 
     if (paint->getMaskFilter()) {
         SkPaint::Style style = doFill ? SkPaint::kFill_Style :
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index 5fb944bac4..eefc951e7e 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -73,16 +73,16 @@ void GrSWMaskHelper::draw(const SkPath& path, const SkStrokeRec& stroke, SkRegio
             paint.setStrokeWidth(stroke.getWidth());
         }
     }
-
-    SkXfermode* mode = SkXfermode::Create(op_to_mode(op));
-
-    paint.setXfermode(mode);
     paint.setAntiAlias(antiAlias);
-    paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
 
-    fDraw.drawPath(path, paint);
-
-    SkSafeUnref(mode);
+    if (SkRegion::kReplace_Op == op && 0xFF == alpha) {
+        SkASSERT(0xFF == paint.getAlpha());
+        fDraw.drawPathCoverage(path, paint);
+    } else {
+        paint.setXfermodeMode(op_to_mode(op));
+        paint.setColor(SkColorSetARGB(alpha, alpha, alpha, alpha));
+        fDraw.drawPath(path, paint);
+    }
 }
 
 bool GrSWMaskHelper::init(const SkIRect& resultBounds,