remove dst/rendertarget support for kARGB_4444_Config

BUG=

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

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

10 files changed, 8 insertions, 800 deletions

diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index b53e4bc350..da7bff8f8a 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -793,17 +793,11 @@ void SkBitmap::eraseARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) const {
             }
             break;
         }
-        case kARGB_4444_Config:
         case kRGB_565_Config: {
             uint16_t* p = (uint16_t*)fPixels;
-            uint16_t v;
-
-            if (kARGB_4444_Config == fConfig) {
-                v = SkPackARGB4444(a >> 4, r >> 4, g >> 4, b >> 4);
-            } else {    // kRGB_565_Config
-                v = SkPackRGB16(r >> (8 - SK_R16_BITS), g >> (8 - SK_G16_BITS),
-                                b >> (8 - SK_B16_BITS));
-            }
+            uint16_t v = SkPackRGB16(r >> (8 - SK_R16_BITS),
+                                     g >> (8 - SK_G16_BITS),
+                                     b >> (8 - SK_B16_BITS));
             while (--height >= 0) {
                 sk_memset16(p, v, width);
                 p = (uint16_t*)((char*)p + rowBytes);
@@ -1005,12 +999,12 @@ bool SkBitmap::canCopyTo(Config dstConfig) const {
     bool sameConfigs = (this->config() == dstConfig);
     switch (dstConfig) {
         case kA8_Config:
-        case kARGB_4444_Config:
         case kRGB_565_Config:
         case kARGB_8888_Config:
             break;
         case kA1_Config:
         case kIndex8_Config:
+        case kARGB_4444_Config:
             if (!sameConfigs) {
                 return false;
             }
diff --git a/src/core/SkBlitRow_D16.cpp b/src/core/SkBlitRow_D16.cpp
index 309e459c2e..e244723986 100644
--- a/src/core/SkBlitRow_D16.cpp
+++ b/src/core/SkBlitRow_D16.cpp
@@ -224,8 +224,6 @@ static const SkBlitRow::Proc gDefault_565_Procs[] = {
     S32A_D565_Blend_Dither
 };
 
-extern SkBlitRow::Proc SkBlitRow_Factory_4444(unsigned flags);
-
 SkBlitRow::Proc SkBlitRow::Factory(unsigned flags, SkBitmap::Config config) {
     SkASSERT(flags < SK_ARRAY_COUNT(gDefault_565_Procs));
     // just so we don't crash
@@ -240,12 +238,6 @@ SkBlitRow::Proc SkBlitRow::Factory(unsigned flags, SkBitmap::Config config) {
                 proc = gDefault_565_Procs[flags];
             }
             break;
-        case SkBitmap::kARGB_4444_Config:
-            proc = PlatformProcs4444(flags);
-            if (NULL == proc) {
-                proc = SkBlitRow_Factory_4444(flags);
-            }
-            break;
         default:
             break;
     }
diff --git a/src/core/SkBlitRow_D4444.cpp b/src/core/SkBlitRow_D4444.cpp
deleted file mode 100644
index 026d156376..0000000000
--- a/src/core/SkBlitRow_D4444.cpp
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
- * Copyright 2011 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "SkBlitRow.h"
-#include "SkColorPriv.h"
-#include "SkDither.h"
-
-///////////////////////////////////////////////////////////////////////////////
-
-static void S32_D4444_Opaque(uint16_t* SK_RESTRICT dst,
-                             const SkPMColor* SK_RESTRICT src, int count,
-                             U8CPU alpha, int /*x*/, int /*y*/) {
-    SkASSERT(255 == alpha);
-
-    if (count > 0) {
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-            SkASSERT(SkGetPackedA32(c) == 255);
-            *dst++ = SkPixel32ToPixel4444(c);
-        } while (--count != 0);
-    }
-}
-
-static void S32_D4444_Blend(uint16_t* SK_RESTRICT dst,
-                            const SkPMColor* SK_RESTRICT src, int count,
-                            U8CPU alpha, int /*x*/, int /*y*/) {
-    SkASSERT(255 > alpha);
-
-    if (count > 0) {
-        unsigned scale16 = SkAlpha255To256(alpha) >> 4;
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-            SkASSERT(SkGetPackedA32(c) == 255);
-
-            uint32_t src_expand = SkExpand32_4444(c);
-            uint32_t dst_expand = SkExpand_4444(*dst);
-            dst_expand += (src_expand - dst_expand) * scale16 >> 4;
-            *dst++ = SkCompact_4444(dst_expand);
-        } while (--count != 0);
-    }
-}
-
-static void S32A_D4444_Opaque(uint16_t* SK_RESTRICT dst,
-                              const SkPMColor* SK_RESTRICT src, int count,
-                              U8CPU alpha, int /*x*/, int /*y*/) {
-    SkASSERT(255 == alpha);
-
-    if (count > 0) {
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-//            if (__builtin_expect(c!=0, 1))
-            if (c)
-            {
-                unsigned scale16 = SkAlpha255To256(255 - SkGetPackedA32(c)) >> 4;
-                uint32_t src_expand = SkExpand_8888(c);
-                uint32_t dst_expand = SkExpand_4444(*dst) * scale16;
-                *dst = SkCompact_4444((src_expand + dst_expand) >> 4);
-            }
-            dst += 1;
-        } while (--count != 0);
-    }
-}
-
-static void S32A_D4444_Blend(uint16_t* SK_RESTRICT dst,
-                             const SkPMColor* SK_RESTRICT src, int count,
-                             U8CPU alpha, int /*x*/, int /*y*/) {
-    SkASSERT(255 > alpha);
-
-    if (count > 0) {
-        int src_scale = SkAlpha255To256(alpha) >> 4;
-        do {
-            SkPMColor sc = *src++;
-            SkPMColorAssert(sc);
-
-            if (sc) {
-                unsigned dst_scale = 16 - (SkGetPackedA32(sc) * src_scale >> 8);
-                uint32_t src_expand = SkExpand32_4444(sc) * src_scale;
-                uint32_t dst_expand = SkExpand_4444(*dst) * dst_scale;
-                *dst = SkCompact_4444((src_expand + dst_expand) >> 4);
-            }
-            dst += 1;
-        } while (--count != 0);
-    }
-}
-
-/////////////////////////////////////////////////////////////////////////////
-
-static void S32_D4444_Opaque_Dither(uint16_t* SK_RESTRICT dst,
-                                    const SkPMColor* SK_RESTRICT src,
-                                    int count, U8CPU alpha, int x, int y) {
-    SkASSERT(255 == alpha);
-
-    if (count > 0) {
-        DITHER_4444_SCAN(y);
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-
-            unsigned dither = DITHER_VALUE(x);
-            *dst++ = SkDitherARGB32To4444(c, dither);
-            DITHER_INC_X(x);
-        } while (--count != 0);
-    }
-}
-
-static void S32_D4444_Blend_Dither(uint16_t* SK_RESTRICT dst,
-                                   const SkPMColor* SK_RESTRICT src,
-                                   int count, U8CPU alpha, int x, int y) {
-    SkASSERT(255 > alpha);
-
-    if (count > 0) {
-        int scale16 = SkAlpha255To256(alpha) >> 4;
-        DITHER_4444_SCAN(y);
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-            SkASSERT(SkGetPackedA32(c) == 255);
-
-            uint32_t src_expand = SkExpand32_4444(c) * scale16;
-            uint32_t dst_expand = SkExpand_4444(*dst) * (16 - scale16);
-
-            c = SkCompact_8888(src_expand + dst_expand); // convert back to SkPMColor
-            *dst++ = SkDitherARGB32To4444(c, DITHER_VALUE(x));
-            DITHER_INC_X(x);
-        } while (--count != 0);
-    }
-}
-
-static void S32A_D4444_Opaque_Dither(uint16_t* SK_RESTRICT dst,
-                                     const SkPMColor* SK_RESTRICT src,
-                                     int count, U8CPU alpha, int x, int y) {
-    SkASSERT(255 == alpha);
-
-    if (count > 0) {
-        DITHER_4444_SCAN(y);
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-            if (c) {
-                unsigned a = SkGetPackedA32(c);
-                int d = SkAlphaMul(DITHER_VALUE(x), SkAlpha255To256(a));
-
-                unsigned scale16 = SkAlpha255To256(255 - a) >> 4;
-                uint32_t src_expand = SkExpand_8888(c);
-                uint32_t dst_expand = SkExpand_4444(*dst) * scale16;
-                // convert back to SkPMColor
-                c = SkCompact_8888(src_expand + dst_expand);
-                *dst = SkDitherARGB32To4444(c, d);
-            }
-            dst += 1;
-            DITHER_INC_X(x);
-        } while (--count != 0);
-    }
-}
-
-// need DitherExpand888To4444(expand, dither)
-
-static void S32A_D4444_Blend_Dither(uint16_t* SK_RESTRICT dst,
-                                    const SkPMColor* SK_RESTRICT src,
-                                    int count, U8CPU alpha, int x, int y) {
-    SkASSERT(255 > alpha);
-
-    if (count > 0) {
-        int src_scale = SkAlpha255To256(alpha) >> 4;
-        DITHER_4444_SCAN(y);
-        do {
-            SkPMColor c = *src++;
-            SkPMColorAssert(c);
-            if (c) {
-                unsigned a = SkAlpha255To256(SkGetPackedA32(c));
-                int d = SkAlphaMul(DITHER_VALUE(x), a);
-
-                unsigned dst_scale = 16 - SkAlphaMul(src_scale, a);
-                uint32_t src_expand = SkExpand32_4444(c) * src_scale;
-                uint32_t dst_expand = SkExpand_4444(*dst) * dst_scale;
-                // convert back to SkPMColor
-                c = SkCompact_8888(src_expand + dst_expand);
-                *dst = SkDitherARGB32To4444(c, d);
-            }
-            dst += 1;
-            DITHER_INC_X(x);
-        } while (--count != 0);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static const SkBlitRow::Proc gProcs4444[] = {
-    // no dither
-    S32_D4444_Opaque,
-    S32_D4444_Blend,
-
-    S32A_D4444_Opaque,
-    S32A_D4444_Blend,
-
-    // dither
-    S32_D4444_Opaque_Dither,
-    S32_D4444_Blend_Dither,
-
-    S32A_D4444_Opaque_Dither,
-    S32A_D4444_Blend_Dither
-};
-
-SkBlitRow::Proc SkBlitRow_Factory_4444(unsigned flags);
-SkBlitRow::Proc SkBlitRow_Factory_4444(unsigned flags)
-{
-    SkASSERT(flags < SK_ARRAY_COUNT(gProcs4444));
-
-    return gProcs4444[flags];
-}
diff --git a/src/core/SkBlitter.cpp b/src/core/SkBlitter.cpp
index f43ad75a44..162fdbcd29 100644
--- a/src/core/SkBlitter.cpp
+++ b/src/core/SkBlitter.cpp
@@ -956,10 +956,6 @@ SkBlitter* SkBlitter::Choose(const SkBitmap& device,
             }
             break;
 
-        case SkBitmap::kARGB_4444_Config:
-            blitter = SkBlitter_ChooseD4444(device, *paint, storage, storageSize);
-            break;
-
         case SkBitmap::kRGB_565_Config:
             blitter = SkBlitter_ChooseD565(device, *paint, storage, storageSize);
             break;
diff --git a/src/core/SkBlitter_4444.cpp b/src/core/SkBlitter_4444.cpp
deleted file mode 100644
index 0d81f8ddb6..0000000000
--- a/src/core/SkBlitter_4444.cpp
+++ /dev/null
@@ -1,480 +0,0 @@
-
-/*
- * 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 "SkCoreBlitters.h"
-#include "SkColorPriv.h"
-#include "SkDither.h"
-#include "SkShader.h"
-#include "SkTemplatesPriv.h"
-#include "SkUtils.h"
-#include "SkXfermode.h"
-
-static inline SkPMColor SkBlendARGB4444(SkPMColor16 src, SkPMColor16 dst,
-                                        U8CPU aa) {
-    SkASSERT((unsigned)aa <= 255);
-
-    unsigned src_scale = SkAlpha255To256(aa) >> 4;
-    unsigned dst_scale = SkAlpha15To16(15 - SkAlphaMul4(SkGetPackedA4444(src), src_scale));
-
-    uint32_t src32 = SkExpand_4444(src) * src_scale;
-    uint32_t dst32 = SkExpand_4444(dst) * dst_scale;
-    return SkCompact_4444((src32 + dst32) >> 4);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class SkARGB4444_Blitter : public SkRasterBlitter {
-public:
-    SkARGB4444_Blitter(const SkBitmap& device, const SkPaint& paint);
-    virtual void blitH(int x, int y, int width);
-    virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
-                           const int16_t runs[]);
-    virtual void blitV(int x, int y, int height, SkAlpha alpha);
-    virtual void blitRect(int x, int y, int width, int height);
-    virtual void blitMask(const SkMask&, const SkIRect&);
-    virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
-
-protected:
-    SkPMColor16 fPMColor16, fPMColor16Other;
-    SkPMColor16 fRawColor16, fRawColor16Other;
-    uint8_t     fScale16;
-
-private:
-    // illegal
-    SkARGB4444_Blitter& operator=(const SkARGB4444_Blitter&);
-
-    typedef SkRasterBlitter INHERITED;
-};
-
-
-SkARGB4444_Blitter::SkARGB4444_Blitter(const SkBitmap& device,
-                                   const SkPaint& paint) : INHERITED(device) {
-    // cache premultiplied versions in 4444
-    SkPMColor c = SkPreMultiplyColor(paint.getColor());
-    fPMColor16 = SkPixel32ToPixel4444(c);
-    if (paint.isDither()) {
-        fPMColor16Other = SkDitherPixel32To4444(c);
-    } else {
-        fPMColor16Other = fPMColor16;
-    }
-
-    // cache raw versions in 4444
-    fRawColor16 = SkPackARGB4444(0xFF >> 4, SkColorGetR(c) >> 4,
-                                 SkColorGetG(c) >> 4, SkColorGetB(c) >> 4);
-    if (paint.isDither()) {
-        fRawColor16Other = SkDitherARGB32To4444(0xFF, SkColorGetR(c),
-                                                SkColorGetG(c), SkColorGetB(c));
-    } else {
-        fRawColor16Other = fRawColor16;
-    }
-
-    fScale16 = SkAlpha15To16(SkGetPackedA4444(fPMColor16Other));
-    if (16 == fScale16) {
-        // force the original to also be opaque
-        fPMColor16 |= (0xF << SK_A4444_SHIFT);
-    }
-}
-
-const SkBitmap* SkARGB4444_Blitter::justAnOpaqueColor(uint32_t* value) {
-    if (16 == fScale16) {
-        *value = fPMColor16;
-        return &fDevice;
-    }
-    return NULL;
-}
-
-static void src_over_4444(SkPMColor16 dst[], SkPMColor16 color,
-                          SkPMColor16 other, unsigned invScale, int count) {
-    int twice = count >> 1;
-    while (--twice >= 0) {
-        *dst = color + SkAlphaMulQ4(*dst, invScale);
-        dst++;
-        *dst = other + SkAlphaMulQ4(*dst, invScale);
-        dst++;
-    }
-    if (count & 1) {
-        *dst = color + SkAlphaMulQ4(*dst, invScale);
-    }
-}
-
-static inline uint32_t SkExpand_4444_Replicate(SkPMColor16 c) {
-    uint32_t c32 = SkExpand_4444(c);
-    return c32 | (c32 << 4);
-}
-
-static void src_over_4444x(SkPMColor16 dst[], uint32_t color,
-                           uint32_t other, unsigned invScale, int count) {
-    int twice = count >> 1;
-    uint32_t tmp;
-    while (--twice >= 0) {
-        tmp = SkExpand_4444(*dst) * invScale;
-        *dst++ = SkCompact_4444((color + tmp) >> 4);
-        tmp = SkExpand_4444(*dst) * invScale;
-        *dst++ = SkCompact_4444((other + tmp) >> 4);
-    }
-    if (count & 1) {
-        tmp = SkExpand_4444(*dst) * invScale;
-        *dst = SkCompact_4444((color + tmp) >> 4);
-    }
-}
-
-void SkARGB4444_Blitter::blitH(int x, int y, int width) {
-    SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
-
-    if (0 == fScale16) {
-        return;
-    }
-
-    SkPMColor16* device = fDevice.getAddr16(x, y);
-    SkPMColor16  color = fPMColor16;
-    SkPMColor16  other = fPMColor16Other;
-
-    if ((x ^ y) & 1) {
-        SkTSwap<SkPMColor16>(color, other);
-    }
-
-    if (16 == fScale16) {
-        sk_dither_memset16(device, color, other, width);
-    } else {
-        src_over_4444x(device, SkExpand_4444_Replicate(color),
-                       SkExpand_4444_Replicate(other),
-                       16 - fScale16, width);
-    }
-}
-
-void SkARGB4444_Blitter::blitV(int x, int y, int height, SkAlpha alpha) {
-    if (0 == alpha || 0 == fScale16) {
-        return;
-    }
-
-    SkPMColor16* device = fDevice.getAddr16(x, y);
-    SkPMColor16  color = fPMColor16;
-    SkPMColor16  other = fPMColor16Other;
-    size_t       rb = fDevice.rowBytes();
-
-    if ((x ^ y) & 1) {
-        SkTSwap<SkPMColor16>(color, other);
-    }
-
-    if (16 == fScale16 && 255 == alpha) {
-        while (--height >= 0) {
-            *device = color;
-            device = (SkPMColor16*)((char*)device + rb);
-            SkTSwap<SkPMColor16>(color, other);
-        }
-    } else {
-        unsigned alphaScale = SkAlpha255To256(alpha);
-        uint32_t c32 = SkExpand_4444(color) * (alphaScale >> 4);
-        // need to normalize the low nibble of each expanded component
-        // so we don't overflow the add with d32
-        c32 = SkCompact_4444(c32 >> 4);
-        unsigned invScale = 16 - SkAlpha15To16(SkGetPackedA4444(c32));
-        // now re-expand and replicate
-        c32 = SkExpand_4444_Replicate(c32);
-
-        while (--height >= 0) {
-            uint32_t d32 = SkExpand_4444(*device) * invScale;
-            *device = SkCompact_4444((c32 + d32) >> 4);
-            device = (SkPMColor16*)((char*)device + rb);
-        }
-    }
-}
-
-void SkARGB4444_Blitter::blitRect(int x, int y, int width, int height) {
-    SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width() &&
-             y + height <= fDevice.height());
-
-    if (0 == fScale16) {
-        return;
-    }
-
-    SkPMColor16* device = fDevice.getAddr16(x, y);
-    SkPMColor16  color = fPMColor16;
-    SkPMColor16  other = fPMColor16Other;
-
-    if ((x ^ y) & 1) {
-        SkTSwap<SkPMColor16>(color, other);
-    }
-
-    if (16 == fScale16) {
-        while (--height >= 0) {
-            sk_dither_memset16(device, color, other, width);
-            device = (SkPMColor16*)((char*)device + fDevice.rowBytes());
-            SkTSwap<SkPMColor16>(color, other);
-        }
-    } else {
-        unsigned invScale = 16 - fScale16;
-
-        uint32_t c32 = SkExpand_4444_Replicate(color);
-        uint32_t o32 = SkExpand_4444_Replicate(other);
-        while (--height >= 0) {
-            src_over_4444x(device, c32, o32, invScale, width);
-            device = (SkPMColor16*)((char*)device + fDevice.rowBytes());
-            SkTSwap<uint32_t>(c32, o32);
-        }
-    }
-}
-
-void SkARGB4444_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
-                                   const int16_t runs[]) {
-    if (0 == fScale16) {
-        return;
-    }
-
-    SkPMColor16* device = fDevice.getAddr16(x, y);
-    SkPMColor16  color = fPMColor16;
-    SkPMColor16  other = fPMColor16Other;
-
-    if ((x ^ y) & 1) {
-        SkTSwap<SkPMColor16>(color, other);
-    }
-
-    for (;;) {
-        int count = runs[0];
-        SkASSERT(count >= 0);
-        if (count <= 0) {
-            return;
-        }
-
-        unsigned aa = antialias[0];
-        if (aa) {
-            if (0xFF == aa) {
-                if (16 == fScale16) {
-                    sk_dither_memset16(device, color, other, count);
-                } else {
-                    src_over_4444(device, color, other, 16 - fScale16, count);
-                }
-            } else {
-                // todo: respect dithering
-                aa = SkAlpha255To256(aa);   // FIX
-                SkPMColor16 src = SkAlphaMulQ4(color, aa >> 4);
-                unsigned dst_scale = SkAlpha15To16(15 - SkGetPackedA4444(src)); // FIX
-                int n = count;
-                do {
-                    --n;
-                    device[n] = src + SkAlphaMulQ4(device[n], dst_scale);
-                } while (n > 0);
-            }
-        }
-
-        runs += count;
-        antialias += count;
-        device += count;
-
-        if (count & 1) {
-            SkTSwap<SkPMColor16>(color, other);
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-#define solid_8_pixels(mask, dst, color)    \
-    do {                                    \
-        if (mask & 0x80) dst[0] = color;    \
-        if (mask & 0x40) dst[1] = color;    \
-        if (mask & 0x20) dst[2] = color;    \
-        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                  SkARGB4444_BlitBW
-#define SK_BLITBWMASK_ARGS                  , SkPMColor16 color
-#define SK_BLITBWMASK_BLIT8(mask, dst)      solid_8_pixels(mask, dst, color)
-#define SK_BLITBWMASK_GETADDR               getAddr16
-#define SK_BLITBWMASK_DEVTYPE               uint16_t
-#include "SkBlitBWMaskTemplate.h"
-
-#define blend_8_pixels(mask, dst, sc, dst_scale)                             \
-    do {                                                                     \
-        if (mask & 0x80) { dst[0] = sc + SkAlphaMulQ4(dst[0], dst_scale); }  \
-        if (mask & 0x40) { dst[1] = sc + SkAlphaMulQ4(dst[1], dst_scale); }  \
-        if (mask & 0x20) { dst[2] = sc + SkAlphaMulQ4(dst[2], dst_scale); }  \
-        if (mask & 0x10) { dst[3] = sc + SkAlphaMulQ4(dst[3], dst_scale); }  \
-        if (mask & 0x08) { dst[4] = sc + SkAlphaMulQ4(dst[4], dst_scale); }  \
-        if (mask & 0x04) { dst[5] = sc + SkAlphaMulQ4(dst[5], dst_scale); }  \
-        if (mask & 0x02) { dst[6] = sc + SkAlphaMulQ4(dst[6], dst_scale); }  \
-        if (mask & 0x01) { dst[7] = sc + SkAlphaMulQ4(dst[7], dst_scale); }  \
-    } while (0)
-
-#define SK_BLITBWMASK_NAME                  SkARGB4444_BlendBW
-#define SK_BLITBWMASK_ARGS                  , uint16_t sc, unsigned dst_scale
-#define SK_BLITBWMASK_BLIT8(mask, dst)      blend_8_pixels(mask, dst, sc, dst_scale)
-#define SK_BLITBWMASK_GETADDR               getAddr16
-#define SK_BLITBWMASK_DEVTYPE               uint16_t
-#include "SkBlitBWMaskTemplate.h"
-
-void SkARGB4444_Blitter::blitMask(const SkMask& mask, const SkIRect& clip) {
-    SkASSERT(mask.fBounds.contains(clip));
-
-    if (0 == fScale16) {
-        return;
-    }
-
-    if (mask.fFormat == SkMask::kBW_Format) {
-        if (16 == fScale16) {
-            SkARGB4444_BlitBW(fDevice, mask, clip, fPMColor16);
-        } else {
-            SkARGB4444_BlendBW(fDevice, mask, clip, fPMColor16, 16 - fScale16);
-        }
-        return;
-    }
-
-    int x = clip.fLeft;
-    int y = clip.fTop;
-    int width = clip.width();
-    int height = clip.height();
-
-    SkPMColor16*    device = fDevice.getAddr16(x, y);
-    const uint8_t*  alpha = mask.getAddr8(x, y);
-    SkPMColor16     srcColor = fPMColor16;
-    size_t          devRB = fDevice.rowBytes() - (width << 1);
-    unsigned        maskRB = mask.fRowBytes - width;
-
-    do {
-        int w = width;
-        do {
-            unsigned aa = *alpha++;
-            *device = SkBlendARGB4444(srcColor, *device, aa);
-            device += 1;
-        } while (--w != 0);
-        device = (SkPMColor16*)((char*)device + devRB);
-        alpha += maskRB;
-    } while (--height != 0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-class SkARGB4444_Shader_Blitter : public SkShaderBlitter {
-    SkXfermode*     fXfermode;
-    SkBlitRow::Proc fOpaqueProc;
-    SkBlitRow::Proc fAlphaProc;
-    SkPMColor*      fBuffer;
-    uint8_t*        fAAExpand;
-public:
-
-SkARGB4444_Shader_Blitter(const SkBitmap& device, const SkPaint& paint)
-        : INHERITED(device, paint) {
-    const int width = device.width();
-    fBuffer = (SkPMColor*)sk_malloc_throw(width * sizeof(SkPMColor) + width);
-    fAAExpand = (uint8_t*)(fBuffer + width);
-
-    fXfermode = paint.getXfermode();
-    SkSafeRef(fXfermode);
-
-    unsigned flags = 0;
-    if (!(fShader->getFlags() & SkShader::kOpaqueAlpha_Flag)) {
-        flags |= SkBlitRow::kSrcPixelAlpha_Flag;
-    }
-    if (paint.isDither()) {
-        flags |= SkBlitRow::kDither_Flag;
-    }
-    fOpaqueProc = SkBlitRow::Factory(flags, SkBitmap::kARGB_4444_Config);
-    fAlphaProc = SkBlitRow::Factory(flags | SkBlitRow::kGlobalAlpha_Flag,
-                                    SkBitmap::kARGB_4444_Config);
-}
-
-virtual ~SkARGB4444_Shader_Blitter() {
-    SkSafeUnref(fXfermode);
-    sk_free(fBuffer);
-}
-
-virtual void blitH(int x, int y, int width) {
-    SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
-
-    SkPMColor16* device = fDevice.getAddr16(x, y);
-    SkPMColor*   span = fBuffer;
-
-    fShader->shadeSpan(x, y, span, width);
-    if (fXfermode) {
-        fXfermode->xfer4444(device, span, width, NULL);
-    } else {
-        fOpaqueProc(device, span, width, 0xFF, x, y);
-    }
-}
-
-virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
-                       const int16_t runs[]) {
-    SkPMColor* SK_RESTRICT span = fBuffer;
-    uint8_t* SK_RESTRICT aaExpand = fAAExpand;
-    SkPMColor16* device = fDevice.getAddr16(x, y);
-    SkShader*    shader = fShader;
-    SkXfermode*  xfer = fXfermode;
-
-    if (NULL != xfer) {
-        for (;;) {
-            int count = *runs;
-            if (count <= 0) {
-                break;
-            }
-            int aa = *antialias;
-            if (aa) {
-                shader->shadeSpan(x, y, span, count);
-                if (255 == aa) {
-                    xfer->xfer4444(device, span, count, NULL);
-                } else {
-                    const uint8_t* aaBuffer = antialias;
-                    if (count > 1) {
-                        memset(aaExpand, aa, count);
-                        aaBuffer = aaExpand;
-                    }
-                    xfer->xfer4444(device, span, count, aaBuffer);
-                }
-            }
-            device += count;
-            runs += count;
-            antialias += count;
-            x += count;
-        }
-    } else {    // no xfermode
-        for (;;) {
-            int count = *runs;
-            if (count <= 0) {
-                break;
-            }
-            int aa = *antialias;
-            if (aa) {
-                fShader->shadeSpan(x, y, span, count);
-                if (255 == aa) {
-                    fOpaqueProc(device, span, count, aa, x, y);
-                } else {
-                    fAlphaProc(device, span, count, aa, x, y);
-                }
-            }
-            device += count;
-            runs += count;
-            antialias += count;
-            x += count;
-        }
-    }
-}
-
-private:
-    typedef SkShaderBlitter INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-SkBlitter* SkBlitter_ChooseD4444(const SkBitmap& device,
-                                 const SkPaint& paint,
-                                 void* storage, size_t storageSize)
-{
-    SkBlitter* blitter;
-
-    if (paint.getShader()) {
-        SK_PLACEMENT_NEW_ARGS(blitter, SkARGB4444_Shader_Blitter, storage, storageSize, (device, paint));
-    } else {
-        SK_PLACEMENT_NEW_ARGS(blitter, SkARGB4444_Blitter, storage, storageSize, (device, paint));
-    }
-    return blitter;
-}
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 07b615ac45..36dd304c37 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -464,20 +464,7 @@ private:
 class AutoValidator {
 public:
     AutoValidator(SkDevice* device) : fDevice(device) {}
-    ~AutoValidator() {
-#ifdef SK_DEBUG
-        const SkBitmap& bm = fDevice->accessBitmap(false);
-        if (bm.config() == SkBitmap::kARGB_4444_Config) {
-            for (int y = 0; y < bm.height(); y++) {
-                const SkPMColor16* p = bm.getAddr16(0, y);
-                for (int x = 0; x < bm.width(); x++) {
-                    SkPMColor16 c = p[x];
-                    SkPMColor16Assert(c);
-                }
-            }
-        }
-#endif
-    }
+
 private:
     SkDevice* fDevice;
 };
diff --git a/src/core/SkCoreBlitters.h b/src/core/SkCoreBlitters.h
index 823cb41b0d..9455509c48 100644
--- a/src/core/SkCoreBlitters.h
+++ b/src/core/SkCoreBlitters.h
@@ -154,7 +154,7 @@ private:
 class SkA1_Blitter : public SkRasterBlitter {
 public:
     SkA1_Blitter(const SkBitmap& device, const SkPaint& paint);
-    virtual void blitH(int x, int y, int width);
+    virtual void blitH(int x, int y, int width) SK_OVERRIDE;
 
 private:
     uint8_t fSrcA;
@@ -180,10 +180,6 @@ private:
     SkBlitter::Choose(...)
  */
 
-extern SkBlitter* SkBlitter_ChooseD4444(const SkBitmap& device,
-                                        const SkPaint& paint,
-                                        void* storage, size_t storageSize);
-
 extern SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device,
                                        const SkPaint& paint,
                                        void* storage, size_t storageSize);
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index dee5bc76af..97d5748cdb 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -32,6 +32,8 @@ SkDevice::SkDevice(const SkBitmap& bitmap)
 {
     fOrigin.setZero();
     fMetaData = NULL;
+    
+    SkASSERT(SkBitmap::kARGB_4444_Config != bitmap.config());
 }
 
 SkDevice::SkDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties)
diff --git a/src/core/SkDraw.cpp b/src/core/SkDraw.cpp
index 30d5956ae8..1cfeaa34d6 100644
--- a/src/core/SkDraw.cpp
+++ b/src/core/SkDraw.cpp
@@ -222,12 +222,6 @@ static BitmapXferProc ChooseBitmapXferProc(const SkBitmap& bitmap,
                     }
 //                    SkDebugf("--- D32_Src_BitmapXferProc\n");
                     return D32_Src_BitmapXferProc;
-                case SkBitmap::kARGB_4444_Config:
-                    if (data) {
-                        *data = SkPixel32ToPixel4444(pmc);
-                    }
-//                    SkDebugf("--- D16_Src_BitmapXferProc\n");
-                    return D16_Src_BitmapXferProc;
                 case SkBitmap::kRGB_565_Config:
                     if (data) {
                         *data = SkPixel32ToPixel16(pmc);
@@ -258,7 +252,6 @@ static void CallBitmapXferProc(const SkBitmap& bitmap, const SkIRect& rect,
         case SkBitmap::kARGB_8888_Config:
             shiftPerPixel = 2;
             break;
-        case SkBitmap::kARGB_4444_Config:
         case SkBitmap::kRGB_565_Config:
             shiftPerPixel = 1;
             break;
diff --git a/src/core/SkXfermode.cpp b/src/core/SkXfermode.cpp
index 2da500a7d8..2cfdcfa4b3 100644
--- a/src/core/SkXfermode.cpp
+++ b/src/core/SkXfermode.cpp
@@ -751,31 +751,6 @@ void SkXfermode::xfer16(uint16_t* dst,
     }
 }
 
-void SkXfermode::xfer4444(SkPMColor16* SK_RESTRICT dst,
-                          const SkPMColor* SK_RESTRICT src, int count,
-                          const SkAlpha* SK_RESTRICT aa) const {
-    SkASSERT(dst && src && count >= 0);
-
-    if (NULL == aa) {
-        for (int i = count - 1; i >= 0; --i) {
-            SkPMColor dstC = SkPixel4444ToPixel32(dst[i]);
-            dst[i] = SkPixel32ToPixel4444(this->xferColor(src[i], dstC));
-        }
-    } else {
-        for (int i = count - 1; i >= 0; --i) {
-            unsigned a = aa[i];
-            if (0 != a) {
-                SkPMColor dstC = SkPixel4444ToPixel32(dst[i]);
-                SkPMColor C = this->xferColor(src[i], dstC);
-                if (0xFF != a) {
-                    C = SkFourByteInterp(C, dstC, a);
-                }
-                dst[i] = SkPixel32ToPixel4444(C);
-            }
-        }
-    }
-}
-
 void SkXfermode::xferA8(SkAlpha* SK_RESTRICT dst,
                         const SkPMColor src[], int count,
                         const SkAlpha* SK_RESTRICT aa) const {
@@ -861,35 +836,6 @@ void SkProcXfermode::xfer16(uint16_t* SK_RESTRICT dst,
     }
 }
 
-void SkProcXfermode::xfer4444(SkPMColor16* SK_RESTRICT dst,
-                              const SkPMColor* SK_RESTRICT src, int count,
-                              const SkAlpha* SK_RESTRICT aa) const {
-    SkASSERT(dst && src && count >= 0);
-
-    SkXfermodeProc proc = fProc;
-
-    if (NULL != proc) {
-        if (NULL == aa) {
-            for (int i = count - 1; i >= 0; --i) {
-                SkPMColor dstC = SkPixel4444ToPixel32(dst[i]);
-                dst[i] = SkPixel32ToPixel4444(proc(src[i], dstC));
-            }
-        } else {
-            for (int i = count - 1; i >= 0; --i) {
-                unsigned a = aa[i];
-                if (0 != a) {
-                    SkPMColor dstC = SkPixel4444ToPixel32(dst[i]);
-                    SkPMColor C = proc(src[i], dstC);
-                    if (0xFF != a) {
-                        C = SkFourByteInterp(C, dstC, a);
-                    }
-                    dst[i] = SkPixel32ToPixel4444(C);
-                }
-            }
-        }
-    }
-}
-
 void SkProcXfermode::xferA8(SkAlpha* SK_RESTRICT dst,
                             const SkPMColor* SK_RESTRICT src, int count,
                             const SkAlpha* SK_RESTRICT aa) const {