Revert of change SkDraw and all Blitters to use pixmap instead of bitmap

src/core/SkDraw.cpp

 /*
  * 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.
  */
 #define __STDC_LIMIT_MACROS
 
 #include "SkDraw.h"
 #include "SkBlitter.h"
@@ skipping 26 matching lines @@
 //#define TRACE_BITMAP_DRAWS
 
 
 /** Helper for allocating small blitters on the stack.
  */
 class SkAutoBlitterChoose : SkNoncopyable {
 public:
     SkAutoBlitterChoose() {
         fBlitter = NULL;
     }
-    SkAutoBlitterChoose(const SkPixmap& dst, const SkMatrix& matrix,
+    SkAutoBlitterChoose(const SkBitmap& device, const SkMatrix& matrix,
                         const SkPaint& paint, bool drawCoverage = false) {
-        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
+        fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator,
+                                     drawCoverage);
     }
-    
+
     SkBlitter*  operator->() { return fBlitter; }
     SkBlitter*  get() const { return fBlitter; }
 
-    void choose(const SkPixmap& dst, const SkMatrix& matrix,
+    void choose(const SkBitmap& device, const SkMatrix& matrix,
                 const SkPaint& paint, bool drawCoverage = false) {
         SkASSERT(!fBlitter);
-        fBlitter = SkBlitter::Choose(dst, matrix, paint, &fAllocator, drawCoverage);
+        fBlitter = SkBlitter::Choose(device, matrix, paint, &fAllocator,
+                                     drawCoverage);
     }
 
 private:
     // Owned by fAllocator, which will handle the delete.
     SkBlitter*          fBlitter;
     SkTBlitterAllocator fAllocator;
 };
 #define SkAutoBlitterChoose(...) SK_REQUIRE_LOCAL_VAR(SkAutoBlitterChoose)
 
 /**
@@ skipping 74 matching lines @@
 }
 
 static void D16_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
     sk_memset16((uint16_t*)pixels, data, SkToInt(bytes >> 1));
 }
 
 static void DA8_Src_BitmapXferProc(void* pixels, size_t bytes, uint32_t data) {
     memset(pixels, data, bytes);
 }
 
-static BitmapXferProc ChooseBitmapXferProc(const SkPixmap& dst, const SkPaint& paint,
+static BitmapXferProc ChooseBitmapXferProc(const SkBitmap& bitmap,
+                                           const SkPaint& paint,
                                            uint32_t* data) {
     // todo: we can apply colorfilter up front if no shader, so we wouldn't
     // need to abort this fastpath
     if (paint.getShader() || paint.getColorFilter()) {
         return NULL;
     }
 
     SkXfermode::Mode mode;
     if (!SkXfermode::AsMode(paint.getXfermode(), &mode)) {
         return NULL;
@@ skipping 16 matching lines @@
 //            SkDebugf("--- D_Clear_BitmapXferProc\n");
             return D_Clear_BitmapXferProc;  // ignore data
         case SkXfermode::kDst_Mode:
 //            SkDebugf("--- D_Dst_BitmapXferProc\n");
             return D_Dst_BitmapXferProc;    // ignore data
         case SkXfermode::kSrc_Mode: {
             /*
                 should I worry about dithering for the lower depths?
             */
             SkPMColor pmc = SkPreMultiplyColor(color);
-            switch (dst.colorType()) {
+            switch (bitmap.colorType()) {
                 case kN32_SkColorType:
                     if (data) {
                         *data = pmc;
                     }
 //                    SkDebugf("--- D32_Src_BitmapXferProc\n");
                     return D32_Src_BitmapXferProc;
                 case kRGB_565_SkColorType:
                     if (data) {
                         *data = SkPixel32ToPixel16(pmc);
                     }
 //                    SkDebugf("--- D16_Src_BitmapXferProc\n");
                     return D16_Src_BitmapXferProc;
                 case kAlpha_8_SkColorType:
                     if (data) {
                         *data = SkGetPackedA32(pmc);
                     }
 //                    SkDebugf("--- DA8_Src_BitmapXferProc\n");
                     return DA8_Src_BitmapXferProc;
                 default:
                     break;
             }
             break;
         }
         default:
             break;
     }
     return NULL;
 }
 
-static void CallBitmapXferProc(const SkPixmap& dst, const SkIRect& rect, BitmapXferProc proc,
-                               uint32_t procData) {
+static void CallBitmapXferProc(const SkBitmap& bitmap, const SkIRect& rect,
+                               BitmapXferProc proc, uint32_t procData) {
     int shiftPerPixel;
-    switch (dst.colorType()) {
+    switch (bitmap.colorType()) {
         case kN32_SkColorType:
             shiftPerPixel = 2;
             break;
         case kRGB_565_SkColorType:
             shiftPerPixel = 1;
             break;
         case kAlpha_8_SkColorType:
             shiftPerPixel = 0;
             break;
         default:
             SkDEBUGFAIL("Can't use xferproc on this config");
             return;
     }
 
-    uint8_t* pixels = (uint8_t*)dst.writable_addr();
+    uint8_t* pixels = (uint8_t*)bitmap.getPixels();
     SkASSERT(pixels);
-    const size_t rowBytes = dst.rowBytes();
+    const size_t rowBytes = bitmap.rowBytes();
     const int widthBytes = rect.width() << shiftPerPixel;
 
     // skip down to the first scanline and X position
     pixels += rect.fTop * rowBytes + (rect.fLeft << shiftPerPixel);
     for (int scans = rect.height() - 1; scans >= 0; --scans) {
         proc(pixels, widthBytes, procData);
         pixels += rowBytes;
     }
 }
 
 void SkDraw::drawPaint(const SkPaint& paint) const {
     SkDEBUGCODE(this->validate();)
 
     if (fRC->isEmpty()) {
         return;
     }
 
     SkIRect    devRect;
-    devRect.set(0, 0, fDst.width(), fDst.height());
+    devRect.set(0, 0, fBitmap->width(), fBitmap->height());
 
     if (fRC->isBW()) {
         /*  If we don't have a shader (i.e. we're just a solid color) we may
             be faster to operate directly on the device bitmap, rather than invoking
             a blitter. Esp. true for xfermodes, which require a colorshader to be
             present, which is just redundant work. Since we're drawing everywhere
             in the clip, we don't have to worry about antialiasing.
         */
         uint32_t procData = 0;  // to avoid the warning
-        BitmapXferProc proc = ChooseBitmapXferProc(fDst, paint, &procData);
+        BitmapXferProc proc = ChooseBitmapXferProc(*fBitmap, paint, &procData);
         if (proc) {
             if (D_Dst_BitmapXferProc == proc) { // nothing to do
                 return;
             }
 
             SkRegion::Iterator iter(fRC->bwRgn());
             while (!iter.done()) {
-                CallBitmapXferProc(fDst, iter.rect(), proc, procData);
+                CallBitmapXferProc(*fBitmap, iter.rect(), proc, procData);
                 iter.next();
             }
             return;
         }
     }
 
     // normal case: use a blitter
-    SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
+    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
     SkScan::FillIRect(devRect, *fRC, blitter.get());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 struct PtProcRec {
     SkCanvas::PointMode fMode;
     const SkPaint*  fPaint;
     const SkRegion* fClip;
     const SkRasterClip* fRC;
@@ skipping 25 matching lines @@
         }
     }
 }
 
 static void bw_pt_rect_16_hair_proc(const PtProcRec& rec,
                                     const SkPoint devPts[], int count,
                                     SkBlitter* blitter) {
     SkASSERT(rec.fRC->isRect());
     const SkIRect& r = rec.fRC->getBounds();
     uint32_t value;
-    const SkPixmap* dst = blitter->justAnOpaqueColor(&value);
-    SkASSERT(dst);
+    const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value);
+    SkASSERT(bitmap);
 
-    uint16_t* addr = dst->writable_addr16(0, 0);
-    size_t    rb = dst->rowBytes();
+    uint16_t* addr = bitmap->getAddr16(0, 0);
+    size_t    rb = bitmap->rowBytes();
 
     for (int i = 0; i < count; i++) {
         int x = SkScalarFloorToInt(devPts[i].fX);
         int y = SkScalarFloorToInt(devPts[i].fY);
         if (r.contains(x, y)) {
             ((uint16_t*)((char*)addr + y * rb))[x] = SkToU16(value);
         }
     }
 }
 
 static void bw_pt_rect_32_hair_proc(const PtProcRec& rec,
                                     const SkPoint devPts[], int count,
                                     SkBlitter* blitter) {
     SkASSERT(rec.fRC->isRect());
     const SkIRect& r = rec.fRC->getBounds();
     uint32_t value;
-    const SkPixmap* dst = blitter->justAnOpaqueColor(&value);
-    SkASSERT(dst);
+    const SkBitmap* bitmap = blitter->justAnOpaqueColor(&value);
+    SkASSERT(bitmap);
 
-    SkPMColor* addr = dst->writable_addr32(0, 0);
-    size_t     rb = dst->rowBytes();
+    SkPMColor* addr = bitmap->getAddr32(0, 0);
+    size_t     rb = bitmap->rowBytes();
 
     for (int i = 0; i < count; i++) {
         int x = SkScalarFloorToInt(devPts[i].fX);
         int y = SkScalarFloorToInt(devPts[i].fY);
         if (r.contains(x, y)) {
             ((SkPMColor*)((char*)addr + y * rb))[x] = value;
         }
     }
 }
 
@@ skipping 135 matching lines @@
             };
             proc = gAAProcs[fMode];
         } else if (fPaint->getStrokeCap() != SkPaint::kRound_Cap) {
             SkASSERT(SkCanvas::kPoints_PointMode == fMode);
             proc = aa_square_proc;
         }
     } else {    // BW
         if (fRadius <= SK_FixedHalf) {    // small radii and hairline
             if (SkCanvas::kPoints_PointMode == fMode && fClip->isRect()) {
                 uint32_t value;
-                const SkPixmap* bm = blitter->justAnOpaqueColor(&value);
+                const SkBitmap* bm = blitter->justAnOpaqueColor(&value);
                 if (bm && kRGB_565_SkColorType == bm->colorType()) {
                     proc = bw_pt_rect_16_hair_proc;
                 } else if (bm && kN32_SkColorType == bm->colorType()) {
                     proc = bw_pt_rect_32_hair_proc;
                 } else {
                     proc = bw_pt_rect_hair_proc;
                 }
             } else {
                 static Proc gBWProcs[] = {
                     bw_pt_hair_proc, bw_line_hair_proc, bw_poly_hair_proc
@@ skipping 26 matching lines @@
     SkASSERT(pts != NULL);
     SkDEBUGCODE(this->validate();)
 
      // nothing to draw
     if (fRC->isEmpty()) {
         return;
     }
 
     PtProcRec rec;
     if (!forceUseDevice && rec.init(mode, paint, fMatrix, fRC)) {
-        SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
+        SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
 
         SkPoint             devPts[MAX_DEV_PTS];
         const SkMatrix*     matrix = fMatrix;
         SkBlitter*          bltr = blitter.get();
         PtProcRec::Proc     proc = rec.chooseProc(&bltr);
         // we have to back up subsequent passes if we're in polygon mode
         const size_t backup = (SkCanvas::kPolygon_PointMode == mode);
 
         do {
             int n = SkToInt(count);
@@ skipping 273 matching lines @@
                 : compute_stroke_size(paint, *fMatrix);
             bbox.outset(SkScalarHalf(ssize.x()), SkScalarHalf(ssize.y()));
         }
     }
 
     SkIRect ir = bbox.roundOut();
     if (fRC->quickReject(ir)) {
         return;
     }
 
-    SkDeviceLooper looper(fDst, *fRC, ir, paint.isAntiAlias());
+    SkDeviceLooper looper(*fBitmap, *fRC, ir, paint.isAntiAlias());
     while (looper.next()) {
         SkRect localDevRect;
         looper.mapRect(&localDevRect, devRect);
         SkMatrix localMatrix;
         looper.mapMatrix(&localMatrix, *matrix);
 
-        SkAutoBlitterChoose blitterStorage(looper.getPixmap(), localMatrix, paint);
+        SkAutoBlitterChoose blitterStorage(looper.getBitmap(), localMatrix, paint);
         const SkRasterClip& clip = looper.getRC();
         SkBlitter*          blitter = blitterStorage.get();
 
         // we want to "fill" if we are kFill or kStrokeAndFill, since in the latter
         // case we are also hairline (if we've gotten to here), which devolves to
         // effectively just kFill
         switch (rtype) {
             case kFill_RectType:
                 if (paint.isAntiAlias()) {
                     SkScan::AntiFillRect(localDevRect, clip, blitter);
@@ skipping 30 matching lines @@
 
     SkMask dstM;
     if (paint.getMaskFilter() &&
             paint.getMaskFilter()->filterMask(&dstM, srcM, *fMatrix, NULL)) {
         mask = &dstM;
     } else {
         dstM.fImage = NULL;
     }
     SkAutoMaskFreeImage ami(dstM.fImage);
 
-    SkAutoBlitterChoose blitterChooser(fDst, *fMatrix, paint);
+    SkAutoBlitterChoose blitterChooser(*fBitmap, *fMatrix, paint);
     SkBlitter* blitter = blitterChooser.get();
 
     SkAAClipBlitterWrapper wrapper;
     const SkRegion* clipRgn;
 
     if (fRC->isBW()) {
         clipRgn = &fRC->bwRgn();
     } else {
         wrapper.init(*fRC, blitter);
         clipRgn = &wrapper.getRgn();
@@ skipping 57 matching lines @@
 
         if (paint.getRasterizer()) {
             goto DRAW_PATH;
         }
     }
 
     if (paint.getMaskFilter()) {
         // Transform the rrect into device space.
         SkRRect devRRect;
         if (rrect.transform(*fMatrix, &devRRect)) {
-            SkAutoBlitterChoose blitter(fDst, *fMatrix, paint);
+            SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, paint);
             if (paint.getMaskFilter()->filterRRect(devRRect, *fMatrix, *fRC, blitter.get(),
                                                    SkPaint::kFill_Style)) {
                 return; // filterRRect() called the blitter, so we're done
             }
         }
     }
 
 DRAW_PATH:
     // Now fall back to the default case of using a path.
     SkPath path;
@@ skipping 98 matching lines @@
 
     // avoid possibly allocating a new path in transform if we can
     SkPath* devPathPtr = pathIsMutable ? pathPtr : &tmpPath;
 
     // transform the path into device space
     pathPtr->transform(*matrix, devPathPtr);
 
     SkBlitter* blitter = NULL;
     SkAutoBlitterChoose blitterStorage;
     if (NULL == customBlitter) {
-        blitterStorage.choose(fDst, *fMatrix, *paint, drawCoverage);
+        blitterStorage.choose(*fBitmap, *fMatrix, *paint, drawCoverage);
         blitter = blitterStorage.get();
     } else {
         blitter = customBlitter;
     }
 
     if (paint->getMaskFilter()) {
         SkPaint::Style style = doFill ? SkPaint::kFill_Style :
             SkPaint::kStroke_Style;
         if (paint->getMaskFilter()->filterPath(*devPathPtr, *fMatrix, *fRC, blitter, style)) {
             return; // filterPath() called the blitter, so we're done
@@ skipping 53 matching lines @@
 
         r.set(0, 0,
               SkIntToScalar(bitmap.width()), SkIntToScalar(bitmap.height()));
         fMatrix->mapRect(&r);
         r.round(&mask.fBounds);
 
         // set the mask's bounds to the transformed bitmap-bounds,
         // clipped to the actual device
         {
             SkIRect    devBounds;
-            devBounds.set(0, 0, fDst.width(), fDst.height());
+            devBounds.set(0, 0, fBitmap->width(), fBitmap->height());
             // need intersect(l, t, r, b) on irect
             if (!mask.fBounds.intersect(devBounds)) {
                 return;
             }
         }
 
         mask.fFormat = SkMask::kA8_Format;
         mask.fRowBytes = SkAlign4(mask.fBounds.width());
         size_t size = mask.computeImageSize();
         if (0 == size) {
@@ skipping 77 matching lines @@
         // (more or less) identity.
         //
         SkAutoPixmapUnlock unlocker;
         if (!bitmap.requestLock(&unlocker)) {
             return;
         }
         const SkPixmap& pmap = unlocker.pixmap();
         int ix = SkScalarRoundToInt(matrix.getTranslateX());
         int iy = SkScalarRoundToInt(matrix.getTranslateY());
         if (clipHandlesSprite(*fRC, ix, iy, pmap)) {
+            SkPixmap dstPM;
+            if (!fBitmap->peekPixels(&dstPM)) {
+                return;
+            }
             SkTBlitterAllocator allocator;
             // blitter will be owned by the allocator.
-            SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, ix, iy, &allocator);
+            SkBlitter* blitter = SkBlitter::ChooseSprite(dstPM, paint, pmap, ix, iy, &allocator);
             if (blitter) {
                 SkScan::FillIRect(SkIRect::MakeXYWH(ix, iy, pmap.width(), pmap.height()),
                                   *fRC, blitter);
                 return;
             }
             // if !blitter, then we fall-through to the slower case
         }
     }
 
     // now make a temp draw on the stack, and use it
@@ skipping 34 matching lines @@
     SkPaint paint(origPaint);
     paint.setStyle(SkPaint::kFill_Style);
 
     SkAutoPixmapUnlock unlocker;
     if (!bitmap.requestLock(&unlocker)) {
         return;
     }
     const SkPixmap& pmap = unlocker.pixmap();
 
     if (NULL == paint.getColorFilter() && clipHandlesSprite(*fRC, x, y, pmap)) {
+        SkPixmap dstPM;
+        if (!fBitmap->peekPixels(&dstPM)) {
+            return;
+        }
         SkTBlitterAllocator allocator;
         // blitter will be owned by the allocator.
-        SkBlitter* blitter = SkBlitter::ChooseSprite(fDst, paint, pmap, x, y, &allocator);
+        SkBlitter* blitter = SkBlitter::ChooseSprite(dstPM, paint, pmap, x, y, &allocator);
         if (blitter) {
             SkScan::FillIRect(bounds, *fRC, blitter);
             return;
         }
     }
 
     SkMatrix        matrix;
     SkRect          r;
 
     // get a scalar version of our rect
@@ skipping 278 matching lines @@
         x -= stopX;
         y -= stopY;
     }
 
     const char* stop = text + byteLength;
 
     SkAAClipBlitter     aaBlitter;
     SkAutoBlitterChoose blitterChooser;
     SkBlitter*          blitter = NULL;
     if (needsRasterTextBlit(*this)) {
-        blitterChooser.choose(fDst, *fMatrix, paint);
+        blitterChooser.choose(*fBitmap, *fMatrix, paint);
         blitter = blitterChooser.get();
         if (fRC->isAA()) {
             aaBlitter.init(blitter, &fRC->aaRgn());
             blitter = &aaBlitter;
         }
     }
 
     SkAutoKern          autokern;
     SkDraw1Glyph        d1g;
     SkDraw1Glyph::Proc  proc = d1g.init(this, blitter, cache, paint);
@@ skipping 98 matching lines @@
     }
 
     SkDrawCacheProc     glyphCacheProc = paint.getDrawCacheProc();
     SkAutoGlyphCache    autoCache(paint, &fDevice->getLeakyProperties(), fMatrix);
     SkGlyphCache*       cache = autoCache.getCache();
 
     SkAAClipBlitterWrapper wrapper;
     SkAutoBlitterChoose blitterChooser;
     SkBlitter* blitter = NULL;
     if (needsRasterTextBlit(*this)) {
-        blitterChooser.choose(fDst, *fMatrix, paint);
+        blitterChooser.choose(*fBitmap, *fMatrix, paint);
         blitter = blitterChooser.get();
         if (fRC->isAA()) {
             wrapper.init(*fRC, blitter);
             blitter = wrapper.getBlitter();
         }
     }
 
     const char*        stop = text + byteLength;
     SkTextAlignProc    alignProc(paint.getTextAlign());
     SkDraw1Glyph       d1g;
@@ skipping 309 matching lines @@
                 releaseMode = true;
             }
             composeShader.reset(SkNEW_ARGS(SkComposeShader, (&triShader, shader, xmode)));
             p.setShader(composeShader);
             if (releaseMode) {
                 xmode->unref();
             }
         }
     }
 
-    SkAutoBlitterChoose blitter(fDst, *fMatrix, p);
+    SkAutoBlitterChoose blitter(*fBitmap, *fMatrix, p);
     // Abort early if we failed to create a shader context.
     if (blitter->isNullBlitter()) {
         return;
     }
 
     // setup our state and function pointer for iterating triangles
     VertState       state(count, indices, indexCount);
     VertState::Proc vertProc = state.chooseProc(vmode);
 
     if (textures || colors) {
@@ skipping 50 matching lines @@
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 
 void SkDraw::validate() const {
+    SkASSERT(fBitmap != NULL);
     SkASSERT(fMatrix != NULL);
     SkASSERT(fClip != NULL);
     SkASSERT(fRC != NULL);
 
     const SkIRect&  cr = fRC->getBounds();
     SkIRect         br;
 
-    br.set(0, 0, fDst.width(), fDst.height());
+    br.set(0, 0, fBitmap->width(), fBitmap->height());
     SkASSERT(cr.isEmpty() || br.contains(cr));
 }
 
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkPath.h"
 #include "SkDraw.h"
 #include "SkRegion.h"
@@ skipping 35 matching lines @@
         static const int MAX_MARGIN = 128;
         if (!bounds->intersect(clipBounds->makeOutset(SkMin32(margin.fX, MAX_MARGIN),
                                                       SkMin32(margin.fY, MAX_MARGIN)))) {
             return false;
         }
     }
 
     return true;
 }
 
-static void draw_into_mask(const SkMask& mask, const SkPath& devPath, SkPaint::Style style) {
-    SkDraw draw;
-    if (!draw.fDst.reset(mask)) {
-        return;
-    }
-
+static void draw_into_mask(const SkMask& mask, const SkPath& devPath,
+                           SkPaint::Style style) {
+    SkBitmap        bm;
+    SkDraw          draw;
     SkRasterClip    clip;
     SkMatrix        matrix;
     SkPaint         paint;
 
+    bm.installPixels(SkImageInfo::MakeA8(mask.fBounds.width(), mask.fBounds.height()),
+                     mask.fImage, mask.fRowBytes);
+
     clip.setRect(SkIRect::MakeWH(mask.fBounds.width(), mask.fBounds.height()));
     matrix.setTranslate(-SkIntToScalar(mask.fBounds.fLeft),
                         -SkIntToScalar(mask.fBounds.fTop));
 
+    draw.fBitmap    = &bm;
     draw.fRC        = &clip;
     draw.fClip      = &clip.bwRgn();
     draw.fMatrix    = &matrix;
     paint.setAntiAlias(true);
     paint.setStyle(style);
     draw.drawPath(devPath, paint);
 }
 
 bool SkDraw::DrawToMask(const SkPath& devPath, const SkIRect* clipBounds,
                         const SkMaskFilter* filter, const SkMatrix* filterMatrix,
@@ skipping 15 matching lines @@
         mask->fImage = SkMask::AllocImage(size);
         memset(mask->fImage, 0, mask->computeImageSize());
     }
 
     if (SkMask::kJustComputeBounds_CreateMode != mode) {
         draw_into_mask(*mask, devPath, style);
     }
 
     return true;
 }