Revert[2] SkDraw and all Blitters to use pixmap instead of bitmapi

src/core/SkBlitter_RGB16.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.
  */
 
-
 #include "SkBlitRow.h"
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkShader.h"
 #include "SkUtils.h"
 #include "SkUtilsArm.h"
 #include "SkXfermode.h"
 
 #if SK_MIPS_HAS_DSP
@@ skipping 31 matching lines @@
         if (count & 1) {
             dst[count - 1] = value;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkRGB16_Blitter : public SkRasterBlitter {
 public:
-    SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint);
+    SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint);
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
-    virtual void blitMask(const SkMask&,
-                          const SkIRect&) override;
-    const SkBitmap* justAnOpaqueColor(uint32_t*) override;
+    void blitMask(const SkMask&, const SkIRect&) override;
+    const SkPixmap* justAnOpaqueColor(uint32_t*) override;
 
 protected:
     SkPMColor   fSrcColor32;
     uint32_t    fExpandedRaw16;
     unsigned    fScale;
     uint16_t    fColor16;       // already scaled by fScale
     uint16_t    fRawColor16;    // unscaled
     uint16_t    fRawDither16;   // unscaled
     SkBool8     fDoDither;
 
     SkBlitRow::ColorProc16 fColorProc16;
 
     // illegal
     SkRGB16_Blitter& operator=(const SkRGB16_Blitter&);
 
     typedef SkRasterBlitter INHERITED;
 };
 
 class SkRGB16_Opaque_Blitter : public SkRGB16_Blitter {
 public:
-    SkRGB16_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint);
+    SkRGB16_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint);
     void blitH(int x, int y, int width) override;
-    virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
-                           const int16_t* runs) override;
+    void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override;
     void blitV(int x, int y, int height, SkAlpha alpha) override;
     void blitRect(int x, int y, int width, int height) override;
-    virtual void blitMask(const SkMask&,
-                          const SkIRect&) override;
+    void blitMask(const SkMask&, const SkIRect&) override;
 
 private:
     typedef SkRGB16_Blitter INHERITED;
 };
 
 #ifdef USE_BLACK_BLITTER
 class SkRGB16_Black_Blitter : public SkRGB16_Opaque_Blitter {
 public:
-    SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint);
+    SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint);
     void blitMask(const SkMask&, const SkIRect&) override;
-    virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
-                           const int16_t* runs) override;
+    void blitAntiH(int x, int y, const SkAlpha* antialias, const int16_t* runs) override;
 
 private:
     typedef SkRGB16_Opaque_Blitter INHERITED;
 };
 #endif
 
 class SkRGB16_Shader_Blitter : public SkShaderBlitter {
 public:
-    SkRGB16_Shader_Blitter(const SkBitmap& device, const SkPaint& paint,
+    SkRGB16_Shader_Blitter(const SkPixmap& device, const SkPaint& paint,
                            SkShader::Context* shaderContext);
     virtual ~SkRGB16_Shader_Blitter();
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) override;
     void blitRect(int x, int y, int width, int height) override;
 
 protected:
     SkPMColor*          fBuffer;
     SkBlitRow::Proc16   fOpaqueProc;
     SkBlitRow::Proc16   fAlphaProc;
 
 private:
     // illegal
     SkRGB16_Shader_Blitter& operator=(const SkRGB16_Shader_Blitter&);
 
     typedef SkShaderBlitter INHERITED;
 };
 
 // used only if the shader can perform shadSpan16
 class SkRGB16_Shader16_Blitter : public SkRGB16_Shader_Blitter {
 public:
-    SkRGB16_Shader16_Blitter(const SkBitmap& device, const SkPaint& paint,
+    SkRGB16_Shader16_Blitter(const SkPixmap& device, const SkPaint& paint,
                              SkShader::Context* shaderContext);
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) override;
     void blitRect(int x, int y, int width, int height) override;
 
 private:
     typedef SkRGB16_Shader_Blitter INHERITED;
 };
 
 class SkRGB16_Shader_Xfermode_Blitter : public SkShaderBlitter {
 public:
-    SkRGB16_Shader_Xfermode_Blitter(const SkBitmap& device, const SkPaint& paint,
+    SkRGB16_Shader_Xfermode_Blitter(const SkPixmap& device, const SkPaint& paint,
                                     SkShader::Context* shaderContext);
     virtual ~SkRGB16_Shader_Xfermode_Blitter();
     void blitH(int x, int y, int width) override;
     virtual void blitAntiH(int x, int y, const SkAlpha* antialias,
                            const int16_t* runs) override;
 
 private:
     SkXfermode* fXfermode;
     SkPMColor*  fBuffer;
     uint8_t*    fAAExpand;
 
     // illegal
     SkRGB16_Shader_Xfermode_Blitter& operator=(const SkRGB16_Shader_Xfermode_Blitter&);
 
     typedef SkShaderBlitter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 #ifdef USE_BLACK_BLITTER
-SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkBitmap& device, const SkPaint& paint)
+SkRGB16_Black_Blitter::SkRGB16_Black_Blitter(const SkPixmap& device, const SkPaint& paint)
     : INHERITED(device, paint) {
     SkASSERT(paint.getShader() == NULL);
     SkASSERT(paint.getColorFilter() == NULL);
     SkASSERT(paint.getXfermode() == NULL);
     SkASSERT(paint.getColor() == SK_ColorBLACK);
 }
 
 #if 1
 #define black_8_pixels(mask, dst)       \
     do {                                \
@@ skipping 16 matching lines @@
     if (mask & 0x08) dst[4] = 0;
     if (mask & 0x04) dst[5] = 0;
     if (mask & 0x02) dst[6] = 0;
     if (mask & 0x01) dst[7] = 0;
 }
 #endif
 
 #define SK_BLITBWMASK_NAME                  SkRGB16_Black_BlitBW
 #define SK_BLITBWMASK_ARGS
 #define SK_BLITBWMASK_BLIT8(mask, dst)      black_8_pixels(mask, dst)
-#define SK_BLITBWMASK_GETADDR               getAddr16
+#define SK_BLITBWMASK_GETADDR               writable_addr16
 #define SK_BLITBWMASK_DEVTYPE               uint16_t
 #include "SkBlitBWMaskTemplate.h"
 
 void SkRGB16_Black_Blitter::blitMask(const SkMask& mask,
                                      const SkIRect& clip) {
     if (mask.fFormat == SkMask::kBW_Format) {
         SkRGB16_Black_BlitBW(fDevice, mask, clip);
     } else {
-        uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop);
+        uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop);
         const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop);
         unsigned width = clip.width();
         unsigned height = clip.height();
         size_t deviceRB = fDevice.rowBytes() - (width << 1);
         unsigned maskRB = mask.fRowBytes - width;
 
         SkASSERT((int)height > 0);
         SkASSERT((int)width > 0);
         SkASSERT((int)deviceRB >= 0);
         SkASSERT((int)maskRB >= 0);
 
         do {
             unsigned w = width;
             do {
                 unsigned aa = *alpha++;
                 *device = SkAlphaMulRGB16(*device, SkAlpha255To256(255 - aa));
                 device += 1;
             } while (--w != 0);
             device = (uint16_t*)((char*)device + deviceRB);
             alpha += maskRB;
         } while (--height != 0);
     }
 }
 
 void SkRGB16_Black_Blitter::blitAntiH(int x, int y,
                                       const SkAlpha* SK_RESTRICT antialias,
                                       const int16_t* SK_RESTRICT runs) {
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
 
     for (;;) {
         int count = runs[0];
         SkASSERT(count >= 0);
         if (count <= 0) {
             return;
         }
         runs += count;
 
         unsigned aa = antialias[0];
@@ skipping 11 matching lines @@
             }
         }
         device += count;
     }
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Opaque_Blitter::SkRGB16_Opaque_Blitter(const SkBitmap& device,
-                                               const SkPaint& paint)
-: INHERITED(device, paint) {}
+SkRGB16_Opaque_Blitter::SkRGB16_Opaque_Blitter(const SkPixmap& device, const SkPaint& paint)
+    : INHERITED(device, paint) {}
 
 void SkRGB16_Opaque_Blitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     SkASSERT(x + width <= fDevice.width());
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     uint16_t srcColor = fColor16;
 
     SkASSERT(fRawColor16 == srcColor);
     if (fDoDither) {
         uint16_t ditherColor = fRawDither16;
         if ((x ^ y) & 1) {
             SkTSwap(ditherColor, srcColor);
         }
         sk_dither_memset16(device, srcColor, ditherColor, width);
     } else {
         sk_memset16(device, srcColor, width);
     }
 }
 
 // return 1 or 0 from a bool
 static inline int Bool2Int(int value) {
     return !!value;
 }
 
 void SkRGB16_Opaque_Blitter::blitAntiH(int x, int y,
                                        const SkAlpha* SK_RESTRICT antialias,
                                        const int16_t* SK_RESTRICT runs) {
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     uint16_t    srcColor = fRawColor16;
     uint32_t    srcExpanded = fExpandedRaw16;
     int         ditherInt = Bool2Int(fDoDither);
     uint16_t    ditherColor = fRawDither16;
     // if we have no dithering, this will always fail
     if ((x ^ y) & ditherInt) {
         SkTSwap(ditherColor, srcColor);
     }
     for (;;) {
         int count = runs[0];
@@ skipping 44 matching lines @@
         if (mask & 0x10) dst[3] = color;    \
         if (mask & 0x08) dst[4] = color;    \
         if (mask & 0x04) dst[5] = color;    \
         if (mask & 0x02) dst[6] = color;    \
         if (mask & 0x01) dst[7] = color;    \
     } while (0)
 
 #define SK_BLITBWMASK_NAME                  SkRGB16_BlitBW
 #define SK_BLITBWMASK_ARGS                  , uint16_t color
 #define SK_BLITBWMASK_BLIT8(mask, dst)      solid_8_pixels(mask, dst, color)
-#define SK_BLITBWMASK_GETADDR               getAddr16
+#define SK_BLITBWMASK_GETADDR               writable_addr16
 #define SK_BLITBWMASK_DEVTYPE               uint16_t
 #include "SkBlitBWMaskTemplate.h"
 
 #if !defined(SK_MIPS_HAS_DSP)
 static U16CPU blend_compact(uint32_t src32, uint32_t dst32, unsigned scale5) {
     return SkCompact_rgb_16(dst32 + ((src32 - dst32) * scale5 >> 5));
 }
 #endif
 
 void SkRGB16_Opaque_Blitter::blitMask(const SkMask& mask,
                                       const SkIRect& clip) {
     if (mask.fFormat == SkMask::kBW_Format) {
         SkRGB16_BlitBW(fDevice, mask, clip, fColor16);
         return;
     }
 
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop);
     const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop);
     int width = clip.width();
     int height = clip.height();
     size_t      deviceRB = fDevice.rowBytes() - (width << 1);
     unsigned    maskRB = mask.fRowBytes - width;
     uint32_t    expanded32 = fExpandedRaw16;
 
 #if SK_ARM_NEON_IS_ALWAYS && defined(SK_CPU_LENDIAN)
 #define    UNROLL    8
     do {
@@ skipping 74 matching lines @@
                                     SkAlpha255To256(*alpha++) >> 3);
             device += 1;
         } while (--w != 0);
         device = (uint16_t*)((char*)device + deviceRB);
         alpha += maskRB;
     } while (--height != 0);
 #endif
 }
 
 void SkRGB16_Opaque_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
 
     // TODO: respect fDoDither
     unsigned scale5 = SkAlpha255To256(alpha) >> 3;
     uint32_t src32 =  fExpandedRaw16 * scale5;
     scale5 = 32 - scale5;
     do {
         uint32_t dst32 = SkExpand_rgb_16(*device) * scale5;
         *device = SkCompact_rgb_16((src32 + dst32) >> 5);
         device = (uint16_t*)((char*)device + deviceRB);
     } while (--height != 0);
 }
 
 void SkRGB16_Opaque_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height());
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     size_t      deviceRB = fDevice.rowBytes();
     uint16_t    color16 = fColor16;
 
     if (fDoDither) {
         uint16_t ditherColor = fRawDither16;
         if ((x ^ y) & 1) {
             SkTSwap(ditherColor, color16);
         }
         while (--height >= 0) {
             sk_dither_memset16(device, color16, ditherColor, width);
             SkTSwap(ditherColor, color16);
             device = (uint16_t*)((char*)device + deviceRB);
         }
     } else {  // no dither
         while (--height >= 0) {
             sk_memset16(device, color16, width);
             device = (uint16_t*)((char*)device + deviceRB);
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Blitter::SkRGB16_Blitter(const SkBitmap& device, const SkPaint& paint)
+SkRGB16_Blitter::SkRGB16_Blitter(const SkPixmap& device, const SkPaint& paint)
     : INHERITED(device) {
     SkColor color = paint.getColor();
 
     fSrcColor32 = SkPreMultiplyColor(color);
     fScale = SkAlpha255To256(SkColorGetA(color));
 
     int r = SkColorGetR(color);
     int g = SkColorGetG(color);
     int b = SkColorGetB(color);
 
@@ skipping 16 matching lines @@
         flags |= SkBlitRow::kSrcPixelAlpha_Flag;
     }
 
     if (fDoDither) {
         flags |= SkBlitRow::kDither_Flag;
     }
 
     fColorProc16 = SkBlitRow::ColorFactory16(flags);
 }
 
-const SkBitmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) {
+const SkPixmap* SkRGB16_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (!fDoDither && 256 == fScale) {
         *value = fRawColor16;
         return &fDevice;
     }
     return NULL;
 }
 
 void SkRGB16_Blitter::blitH(int x, int y, int width) {
     SkASSERT(width > 0);
     SkASSERT(x + width <= fDevice.width());
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
 
     fColorProc16(device, fSrcColor32, width, x, y);
 }
 
 void SkRGB16_Blitter::blitAntiH(int x, int y,
                                 const SkAlpha* SK_RESTRICT antialias,
                                 const int16_t* SK_RESTRICT runs) {
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     uint32_t    srcExpanded = fExpandedRaw16;
     unsigned    scale = fScale;
 
     // TODO: respect fDoDither
     for (;;) {
         int count = runs[0];
         SkASSERT(count >= 0);
         if (count <= 0) {
             return;
         }
@@ skipping 23 matching lines @@
     if (bw & 0x10) dst[3] = srcColor + SkAlphaMulRGB16(dst[3], dst_scale);
     if (bw & 0x08) dst[4] = srcColor + SkAlphaMulRGB16(dst[4], dst_scale);
     if (bw & 0x04) dst[5] = srcColor + SkAlphaMulRGB16(dst[5], dst_scale);
     if (bw & 0x02) dst[6] = srcColor + SkAlphaMulRGB16(dst[6], dst_scale);
     if (bw & 0x01) dst[7] = srcColor + SkAlphaMulRGB16(dst[7], dst_scale);
 }
 
 #define SK_BLITBWMASK_NAME                  SkRGB16_BlendBW
 #define SK_BLITBWMASK_ARGS                  , unsigned dst_scale, U16CPU src_color
 #define SK_BLITBWMASK_BLIT8(mask, dst)      blend_8_pixels(mask, dst, dst_scale, src_color)
-#define SK_BLITBWMASK_GETADDR               getAddr16
+#define SK_BLITBWMASK_GETADDR               writable_addr16
 #define SK_BLITBWMASK_DEVTYPE               uint16_t
 #include "SkBlitBWMaskTemplate.h"
 
 void SkRGB16_Blitter::blitMask(const SkMask& mask,
                                const SkIRect& clip) {
     if (mask.fFormat == SkMask::kBW_Format) {
         SkRGB16_BlendBW(fDevice, mask, clip, 256 - fScale, fColor16);
         return;
     }
 
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(clip.fLeft, clip.fTop);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(clip.fLeft, clip.fTop);
     const uint8_t* SK_RESTRICT alpha = mask.getAddr8(clip.fLeft, clip.fTop);
     int width = clip.width();
     int height = clip.height();
     size_t      deviceRB = fDevice.rowBytes() - (width << 1);
     unsigned    maskRB = mask.fRowBytes - width;
     uint32_t    color32 = fExpandedRaw16;
 
     unsigned scale256 = fScale;
     do {
         int w = width;
         do {
             unsigned aa = *alpha++;
             unsigned scale = SkAlpha255To256(aa) * scale256 >> (8 + 3);
             uint32_t src32 = color32 * scale;
             uint32_t dst32 = SkExpand_rgb_16(*device) * (32 - scale);
             *device++ = SkCompact_rgb_16((src32 + dst32) >> 5);
         } while (--w != 0);
         device = (uint16_t*)((char*)device + deviceRB);
         alpha += maskRB;
     } while (--height != 0);
 }
 
 void SkRGB16_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
 
     // TODO: respect fDoDither
     unsigned scale5 = SkAlpha255To256(alpha) * fScale >> (8 + 3);
     uint32_t src32 =  fExpandedRaw16 * scale5;
     scale5 = 32 - scale5;
     do {
         uint32_t dst32 = SkExpand_rgb_16(*device) * scale5;
         *device = SkCompact_rgb_16((src32 + dst32) >> 5);
         device = (uint16_t*)((char*)device + deviceRB);
     } while (--height != 0);
 }
 
 void SkRGB16_Blitter::blitRect(int x, int y, int width, int height) {
     SkASSERT(x + width <= fDevice.width() && y + height <= fDevice.height());
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     size_t    deviceRB = fDevice.rowBytes();
 
     while (--height >= 0) {
         fColorProc16(device, fSrcColor32, width, x, y);
         device = (uint16_t*)((char*)device + deviceRB);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkBitmap& device,
+SkRGB16_Shader16_Blitter::SkRGB16_Shader16_Blitter(const SkPixmap& device,
                                                    const SkPaint& paint,
                                                    SkShader::Context* shaderContext)
-    : SkRGB16_Shader_Blitter(device, paint, shaderContext) {
+    : SkRGB16_Shader_Blitter(device, paint, shaderContext)
+{
     SkASSERT(SkShader::CanCallShadeSpan16(fShaderFlags));
 }
 
 void SkRGB16_Shader16_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
-    uint16_t* SK_RESTRICT device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT device = fDevice.writable_addr16(x, y);
     SkShader::Context*    shaderContext = fShaderContext;
 
     int alpha = shaderContext->getSpan16Alpha();
     if (0xFF == alpha) {
         shaderContext->shadeSpan16(x, y, device, width);
     } else {
         uint16_t* span16 = (uint16_t*)fBuffer;
         shaderContext->shadeSpan16(x, y, span16, width);
         SkBlendRGB16(span16, device, SkAlpha255To256(alpha), width);
     }
 }
 
 void SkRGB16_Shader16_Blitter::blitRect(int x, int y, int width, int height) {
     SkShader::Context* shaderContext = fShaderContext;
-    uint16_t*          dst = fDevice.getAddr16(x, y);
+    uint16_t*          dst = fDevice.writable_addr16(x, y);
     size_t             dstRB = fDevice.rowBytes();
     int                alpha = shaderContext->getSpan16Alpha();
 
     if (0xFF == alpha) {
         if (fShaderFlags & SkShader::kConstInY16_Flag) {
             // have the shader blit directly into the device the first time
             shaderContext->shadeSpan16(x, y, dst, width);
             // and now just memcpy that line on the subsequent lines
             if (--height > 0) {
                 const uint16_t* orig = dst;
@@ skipping 27 matching lines @@
             } while (--height);
         }
     }
 }
 
 void SkRGB16_Shader16_Blitter::blitAntiH(int x, int y,
                                          const SkAlpha* SK_RESTRICT antialias,
                                          const int16_t* SK_RESTRICT runs) {
     SkShader::Context*     shaderContext = fShaderContext;
     SkPMColor* SK_RESTRICT span = fBuffer;
-    uint16_t* SK_RESTRICT  device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
 
     int alpha = shaderContext->getSpan16Alpha();
     uint16_t* span16 = (uint16_t*)span;
 
     if (0xFF == alpha) {
         for (;;) {
             int count = *runs;
             if (count <= 0) {
                 break;
             }
@@ skipping 30 matching lines @@
             device += count;
             runs += count;
             antialias += count;
             x += count;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkBitmap& device,
+SkRGB16_Shader_Blitter::SkRGB16_Shader_Blitter(const SkPixmap& device,
                                                const SkPaint& paint,
                                                SkShader::Context* shaderContext)
-: INHERITED(device, paint, shaderContext) {
+    : INHERITED(device, paint, shaderContext)
+{
     SkASSERT(paint.getXfermode() == NULL);
 
     fBuffer = (SkPMColor*)sk_malloc_throw(device.width() * sizeof(SkPMColor));
 
     // compute SkBlitRow::Procs
     unsigned flags = 0;
 
     uint32_t shaderFlags = fShaderFlags;
     // shaders take care of global alpha, so we never set it in SkBlitRow
     if (!(shaderFlags & SkShader::kOpaqueAlpha_Flag)) {
@@ skipping 11 matching lines @@
 
 SkRGB16_Shader_Blitter::~SkRGB16_Shader_Blitter() {
     sk_free(fBuffer);
 }
 
 void SkRGB16_Shader_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
     fShaderContext->shadeSpan(x, y, fBuffer, width);
     // shaders take care of global alpha, so we pass 0xFF (should be ignored)
-    fOpaqueProc(fDevice.getAddr16(x, y), fBuffer, width, 0xFF, x, y);
+    fOpaqueProc(fDevice.writable_addr16(x, y), fBuffer, width, 0xFF, x, y);
 }
 
 void SkRGB16_Shader_Blitter::blitRect(int x, int y, int width, int height) {
     SkShader::Context* shaderContext = fShaderContext;
     SkBlitRow::Proc16  proc = fOpaqueProc;
     SkPMColor*         buffer = fBuffer;
-    uint16_t*          dst = fDevice.getAddr16(x, y);
+    uint16_t*          dst = fDevice.writable_addr16(x, y);
     size_t             dstRB = fDevice.rowBytes();
 
     if (fShaderFlags & SkShader::kConstInY32_Flag) {
         shaderContext->shadeSpan(x, y, buffer, width);
         do {
             proc(dst, buffer, width, 0xFF, x, y);
             y += 1;
             dst = (uint16_t*)((char*)dst + dstRB);
         } while (--height);
     } else {
@@ skipping 18 matching lines @@
         count += n;
     }
     return count;
 }
 
 void SkRGB16_Shader_Blitter::blitAntiH(int x, int y,
                                        const SkAlpha* SK_RESTRICT antialias,
                                        const int16_t* SK_RESTRICT runs) {
     SkShader::Context*     shaderContext = fShaderContext;
     SkPMColor* SK_RESTRICT span = fBuffer;
-    uint16_t* SK_RESTRICT  device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
 
     for (;;) {
         int count = *runs;
         if (count <= 0) {
             break;
         }
         int aa = *antialias;
         if (0 == aa) {
             device += count;
             runs += count;
@@ skipping 25 matching lines @@
             count = *runs;
             SkASSERT(count > 0);
             aa = *antialias;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////
 
 SkRGB16_Shader_Xfermode_Blitter::SkRGB16_Shader_Xfermode_Blitter(
-                                const SkBitmap& device, const SkPaint& paint,
+                                const SkPixmap& device, const SkPaint& paint,
                                 SkShader::Context* shaderContext)
-: INHERITED(device, paint, shaderContext) {
+    : INHERITED(device, paint, shaderContext)
+{
     fXfermode = paint.getXfermode();
     SkASSERT(fXfermode);
     fXfermode->ref();
 
     int width = device.width();
     fBuffer = (SkPMColor*)sk_malloc_throw((width + (SkAlign4(width) >> 2)) * sizeof(SkPMColor));
     fAAExpand = (uint8_t*)(fBuffer + width);
 }
 
 SkRGB16_Shader_Xfermode_Blitter::~SkRGB16_Shader_Xfermode_Blitter() {
     fXfermode->unref();
     sk_free(fBuffer);
 }
 
 void SkRGB16_Shader_Xfermode_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x + width <= fDevice.width());
 
-    uint16_t*   device = fDevice.getAddr16(x, y);
+    uint16_t*   device = fDevice.writable_addr16(x, y);
     SkPMColor*  span = fBuffer;
 
     fShaderContext->shadeSpan(x, y, span, width);
     fXfermode->xfer16(device, span, width, NULL);
 }
 
 void SkRGB16_Shader_Xfermode_Blitter::blitAntiH(int x, int y,
                                 const SkAlpha* SK_RESTRICT antialias,
                                 const int16_t* SK_RESTRICT runs) {
     SkShader::Context*     shaderContext = fShaderContext;
     SkXfermode*            mode = fXfermode;
     SkPMColor* SK_RESTRICT span = fBuffer;
     uint8_t* SK_RESTRICT   aaExpand = fAAExpand;
-    uint16_t* SK_RESTRICT  device = fDevice.getAddr16(x, y);
+    uint16_t* SK_RESTRICT  device = fDevice.writable_addr16(x, y);
 
     for (;;) {
         int count = *runs;
         if (count <= 0) {
             break;
         }
         int aa = *antialias;
         if (0 == aa) {
             device += count;
             runs += count;
@@ skipping 29 matching lines @@
             SkASSERT(nonZeroCount > 0);
             count = *runs;
             SkASSERT(count > 0);
             aa = *antialias;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device, const SkPaint& paint,
+SkBlitter* SkBlitter_ChooseD565(const SkPixmap& device, const SkPaint& paint,
         SkShader::Context* shaderContext,
         SkTBlitterAllocator* allocator) {
     SkASSERT(allocator != NULL);
 
     SkBlitter* blitter;
     SkShader* shader = paint.getShader();
     SkXfermode* mode = paint.getXfermode();
 
     // we require a shader if there is an xfermode, handled by our caller
     SkASSERT(NULL == mode || shader);
@@ skipping 19 matching lines @@
 #endif
         } else if (0xFF == SkColorGetA(color)) {
             blitter = allocator->createT<SkRGB16_Opaque_Blitter>(device, paint);
         } else {
             blitter = allocator->createT<SkRGB16_Blitter>(device, paint);
         }
     }
 
     return blitter;
 }