remove conditional build flag for mipmaps

remove obsolete SkBitmapShader.cpp file



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

6 files changed, 9 insertions, 871 deletions

diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index 5ee4c5614b..d87f001ed8 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -30,7 +30,6 @@ static bool isPos32Bits(const Sk64& value) {
     return !value.isNeg() && value.is32();
 }
 
-#ifdef SK_SUPPORT_MIPMAP
 struct MipLevel {
     void*       fPixels;
     uint32_t    fRowBytes;
@@ -78,7 +77,6 @@ struct SkBitmap::MipMap : SkNoncopyable {
         }
     }
 };
-#endif
 
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
@@ -105,10 +103,8 @@ SkBitmap& SkBitmap::operator=(const SkBitmap& src) {
         memcpy(this, &src, sizeof(src));
 
         // inc src reference counts
-        src.fPixelRef->safeRef();
-#ifdef SK_SUPPORT_MIPMAP
+        SkSafeRef(src.fPixelRef);
         SkSafeRef(src.fMipMap);
-#endif
 
         // we reset our locks if we get blown away
         fPixelLockCount = 0;
@@ -137,9 +133,7 @@ void SkBitmap::swap(SkBitmap& other) {
     SkTSwap<SkPixelRef*>(fPixelRef, other.fPixelRef);
     SkTSwap<size_t>(fPixelRefOffset, other.fPixelRefOffset);
     SkTSwap<int>(fPixelLockCount, other.fPixelLockCount);
-#ifdef SK_SUPPORT_MIPMAP
     SkTSwap<MipMap*>(fMipMap, other.fMipMap);
-#endif
     SkTSwap<void*>(fPixels, other.fPixels);
     SkTSwap<uint32_t>(fRowBytes, other.fRowBytes);
     SkTSwap<uint32_t>(fWidth, other.fWidth);
@@ -361,12 +355,10 @@ void SkBitmap::freePixels() {
 }
 
 void SkBitmap::freeMipMap() {
-#ifdef SK_SUPPORT_MIPMAP
     if (fMipMap) {
         fMipMap->unref();
         fMipMap = NULL;
     }
-#endif
 }
 
 uint32_t SkBitmap::getGenerationID() const {
@@ -909,7 +901,6 @@ static void downsampleby2_proc4444(SkBitmap* dst, int x, int y,
 }
 
 void SkBitmap::buildMipMap(bool forceRebuild) {
-#ifdef SK_SUPPORT_MIPMAP
     if (forceRebuild)
         this->freeMipMap();
     else if (fMipMap)
@@ -1006,21 +997,16 @@ void SkBitmap::buildMipMap(bool forceRebuild) {
     }
     SkASSERT(addr == (uint8_t*)mm->pixels() + size);
     fMipMap = mm;
-#endif
 }
 
 bool SkBitmap::hasMipMap() const {
-#ifdef SK_SUPPORT_MIPMAP
     return fMipMap != NULL;
-#else
-    return false;
-#endif
 }
 
 int SkBitmap::extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy) {
-#ifdef SK_SUPPORT_MIPMAP
-    if (NULL == fMipMap)
+    if (NULL == fMipMap) {
         return 0;
+    }
 
     int level = ComputeMipLevel(sx, sy) >> 16;
     SkASSERT(level >= 0);
@@ -1038,13 +1024,9 @@ int SkBitmap::extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy) {
         dst->setPixels(mip.fPixels);
     }
     return level;
-#else
-    return 0;
-#endif
 }
 
 SkFixed SkBitmap::ComputeMipLevel(SkFixed sx, SkFixed sy) {
-#ifdef SK_SUPPORT_MIPMAP
     sx = SkAbs32(sx);
     sy = SkAbs32(sy);
     if (sx < sy) {
@@ -1056,9 +1038,6 @@ SkFixed SkBitmap::ComputeMipLevel(SkFixed sx, SkFixed sy) {
     int clz = SkCLZ(sx);
     SkASSERT(clz >= 1 && clz <= 15);
     return SkIntToFixed(15 - clz) + ((unsigned)(sx << (clz + 1)) >> 16);
-#else
-    return 0;
-#endif
 }
 
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/src/core/SkBitmapProcState.cpp b/src/core/SkBitmapProcState.cpp
index 642bc0675f..dbdcc27400 100644
--- a/src/core/SkBitmapProcState.cpp
+++ b/src/core/SkBitmapProcState.cpp
@@ -329,7 +329,6 @@ bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
     }
     
     fBitmap = &fOrigBitmap;
-#ifdef SK_SUPPORT_MIPMAP
     if (fOrigBitmap.hasMipMap()) {
         int shift = fOrigBitmap.extractMipLevel(&fMipBitmap,
                                                 SkScalarToFixed(m->getScaleX()),
@@ -348,7 +347,6 @@ bool SkBitmapProcState::chooseProcs(const SkMatrix& inv, const SkPaint& paint) {
             fBitmap = &fMipBitmap;
         }
     }
-#endif
 
     fInvMatrix      = m;
     fInvProc        = m->getMapXYProc();
diff --git a/src/core/SkBitmapProcState.h b/src/core/SkBitmapProcState.h
index 553b952c46..e6f3e1a95d 100644
--- a/src/core/SkBitmapProcState.h
+++ b/src/core/SkBitmapProcState.h
@@ -64,9 +64,7 @@ struct SkBitmapProcState {
 
     const SkBitmap*     fBitmap;            // chooseProcs - orig or mip
     SkBitmap            fOrigBitmap;        // CONSTRUCTOR
-#ifdef SK_SUPPORT_MIPMAP
     SkBitmap            fMipBitmap;
-#endif
     SkPMColor           fPaintPMColor;      // chooseProcs - A8 config
     const SkMatrix*     fInvMatrix;         // chooseProcs
     SkMatrix::MapXYProc fInvProc;           // chooseProcs
diff --git a/src/core/SkBitmapShader.cpp b/src/core/SkBitmapShader.cpp
deleted file mode 100644
index 5d70dd38c2..0000000000
--- a/src/core/SkBitmapShader.cpp
+++ /dev/null
@@ -1,822 +0,0 @@
-/* Copyright 2006, The Android Open Source Project
-**
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
-**
-**     http://www.apache.org/licenses/LICENSE-2.0 
-**
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
-** limitations under the License.
-*/
-
-#if 0
-
-#include "SkBitmapShader.h"
-#include "SkBitmapSampler.h"
-
-#ifdef SK_SUPPORT_MIPMAP
-static SkFixed find_mip_level(SkFixed dx, SkFixed dy)
-{
-    dx = SkAbs32(dx);
-    dy = SkAbs32(dy);
-    if (dx < dy)
-        dx = dy;
-    
-    if (dx < SK_Fixed1)
-        return 0;
-    
-    int clz = SkCLZ(dx);
-    SkASSERT(clz >= 1 && clz <= 15);
-    return SkIntToFixed(15 - clz) + ((unsigned)(dx << (clz + 1)) >> 16);
-}
-#endif
-
-SkBitmapShader::SkBitmapShader(const SkBitmap& src, bool doFilter,
-                               TileMode tmx, TileMode tmy)
-    :
-#ifdef SK_SUPPORT_MIPMAP
-    fMipLevel(0), fMipSrcBitmap(src),
-#endif
-    fOrigSrcBitmap(src)
-    
-{
-    fFilterBitmap = doFilter;
-    fTileModeX = SkToU8(tmx);
-    fTileModeY = SkToU8(tmy);
-}
-
-SkBitmapShader::SkBitmapShader(SkFlattenableReadBuffer& buffer) :
-    INHERITED(buffer)
-{
-    Bitmap src;
-    buffer.readBitmap(&src); 
-#ifdef SK_SUPPORT_MIPMAP
-    fMipLevel = 0;
-    fMipSrcBitmap = src;
-#endif
-    fOrigSrcBitmap = src;
-    fFilterBitmap = buffer.readU8();
-    fTileModeX = buffer.readU8();
-    fTileModeY = buffer.readU8();
-}
-
-void SkBitmapShader::flatten(SkFlattenableWriteBuffer& buffer)
-{
-    this->INHERITED::flatten(buffer);
-    buffer.writeBitmap(&fOrigSrcBitmap);
-    buffer.write8(fFilterBitmap);
-    buffer.write8(fTileModeX);
-    buffer.write8(fTileModeY);
-}
-
-bool SkBitmapShader::setContext(const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix)
-{
-    // do this first, so we have a correct inverse matrix
-    if (!this->INHERITED::setContext(device, paint, matrix))
-        return false;
-
-    if (fOrigSrcBitmap.getConfig() == SkBitmap::kNo_Config ||
-        fOrigSrcBitmap.width() == 0 ||
-        fOrigSrcBitmap.height() == 0)
-        return false;
-
-    SkBitmap& bm = fOrigSrcBitmap;
-
-#ifdef SK_SUPPORT_MIPMAP
-    if (fOrigSrcBitmap.countMipLevels())
-    {
-        const SkMatrix& inv = this->getTotalInverse();
-
-        fMipLevel = SkMin32(find_mip_level( SkScalarToFixed(inv.getScaleX()),
-                                            SkScalarToFixed(inv.getSkewY())),
-                            SkIntToFixed(fOrigSrcBitmap.countMipLevels() - 1));
-
-//        SkDEBUGF(("BitmapShader miplevel=%x\n", fMipLevel));
-
-        const SkBitmap::MipLevel* mm = fOrigSrcBitmap.getMipLevel(fMipLevel >> 16);
-        
-        fMipSrcBitmap.setConfig(fOrigSrcBitmap.getConfig(),
-                                mm->fWidth,
-                                mm->fHeight,
-                                mm->fRowBytes);
-        fMipSrcBitmap.setPixels(mm->fPixels);
-        bm = fMipSrcBitmap;
-    }
-    else
-    {
-        fMipLevel = 0;
-        fMipSrcBitmap = fOrigSrcBitmap;
-    }
-#endif
-
-    fFlags = 0;
-    if (paint.getAlpha() == 255 && bm.isOpaque())
-        fFlags |= kOpaqueAlpha_Flag;
-
-    return true;
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-#include "SkColorPriv.h"
-#include "SkBitmapSampler.h"
-#include "SkPerspIter.h"
-
-class Sampler_BitmapShader : public SkBitmapShader {
-public:
-    Sampler_BitmapShader(const SkBitmap& src, bool doFilter,
-                         TileMode tmx, TileMode tmy)
-        : SkBitmapShader(src, doFilter, tmx, tmy)
-    {
-        // make sure to pass our copy of the src bitmap to the sampler, and not the
-        // original parameter (which might go away).
-        fSampler = NULL;
-    }
-
-    virtual ~Sampler_BitmapShader()
-    {
-        SkDELETE(fSampler);
-    }
-    
-    virtual bool setContext(const SkBitmap& device, const SkPaint& paint, const SkMatrix& matrix)
-    {
-        if (this->INHERITED::setContext(device, paint, matrix))
-        {
-            SkDELETE(fSampler);
-            fSampler = SkBitmapSampler::Create(this->getSrcBitmap(), this->getFilterBitmap(),
-                                               this->getTileModeX(), this->getTileModeY());
-            fSampler->setPaint(paint);
-            return true;
-        }
-        return false;
-    }
-    
-    enum {
-        kMaxPointStorageCount = 32
-    };
-
-    virtual void shadeSpan(int x, int y, SkPMColor dstC[], int count)
-    {
-        unsigned            scale = SkAlpha255To256(this->getPaintAlpha());
-        const SkMatrix&     inv = this->getTotalInverse();
-        SkMatrix::MapPtProc proc = this->getInverseMapPtProc();
-        SkBitmapSampler*     sampler = fSampler;
-        MatrixClass         mc = this->getInverseClass();
-
-        SkPoint srcPt;
-
-        if (mc != kPerspective_MatrixClass)
-        {
-            proc(inv, SkIntToScalar(x) + SK_ScalarHalf,
-                      SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
-
-            SkFixed fx = SkScalarToFixed(srcPt.fX);
-            SkFixed fy = SkScalarToFixed(srcPt.fY);
-            SkFixed dx, dy;
-
-            if (mc == kLinear_MatrixClass)
-            {
-                dx = SkScalarToFixed(inv.getScaleX());
-                dy = SkScalarToFixed(inv.getSkewY());
-            }
-            else
-                (void)inv.fixedStepInX(SkIntToScalar(y), &dx, &dy);
-
-#if defined(SK_SUPPORT_MIPMAP)
-            {   int level = this->getMipLevel() >> 16;
-                fx >>= level;
-                fy >>= level;
-                dx >>= level;
-                dy >>= level;
-            }
-#endif
-            if (scale == 256)
-            {
-                for (int i = 0; i < count; i++)
-                {
-                    dstC[i] = sampler->sample(fx, fy);
-                    fx += dx;
-                    fy += dy;
-                }
-            }
-            else
-            {
-                for (int i = 0; i < count; i++)
-                {
-                    uint32_t    c = sampler->sample(fx, fy);
-                    dstC[i] = SkAlphaMulQ(c, scale);
-                    fx += dx;
-                    fy += dy;
-                }
-            }
-        }
-        else
-        {
-            SkPerspIter   iter(inv, SkIntToScalar(x) + SK_ScalarHalf,
-                                    SkIntToScalar(y) + SK_ScalarHalf, count);
-            if (scale == 256)
-            {
-                while ((count = iter.next()) != 0)
-                {
-                    const SkFixed* src = iter.getXY();
-                    for (int i = 0; i < count; i++)
-                    {
-                        *dstC++ = sampler->sample(src[0], src[1]);
-                        src += 2;
-                    }
-                }
-            }
-            else
-            {
-                while ((count = iter.next()) != 0)
-                {
-                    const SkFixed* src = iter.getXY();
-                    for (int i = 0; i < count; i++)
-                    {
-                        uint32_t c = sampler->sample(src[0] - SK_FixedHalf, src[1] - SK_FixedHalf);
-                        *dstC++ = SkAlphaMulQ(c, scale);
-                        src += 2;
-                    }
-                }
-            }
-        }
-    }
-
-protected:
-
-    const SkMatrix& getUnitInverse() const { return fUnitInverse; }
-    SkMatrix::MapPtProc getUnitInverseProc() const { return fUnitInverseProc; }
-
-    /* takes computed inverse (from setContext) and computes fUnitInverse,
-        taking srcBitmap width/height into account, so that fUnitInverse
-        walks 0...1, allowing the tile modes to all operate in a fast 16bit
-        space (no need for mod). The resulting coords need to be scaled by
-        width/height to get back into src space (coord * width >> 16).
-    */
-    void computeUnitInverse()
-    {
-        const SkBitmap& src = getSrcBitmap();
-        fUnitInverse = this->getTotalInverse();
-        fUnitInverse.postIDiv(src.width(), src.height());
-        fUnitInverseProc = fUnitInverse.getMapPtProc();
-    }
-
-private:
-    SkBitmapSampler*    fSampler;
-    SkMatrix            fUnitInverse;
-    SkMatrix::MapPtProc fUnitInverseProc;
-    
-    typedef SkBitmapShader INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////
-
-class HasSpan16_Sampler_BitmapShader : public Sampler_BitmapShader {
-public:
-    HasSpan16_Sampler_BitmapShader(const SkBitmap& src, bool doFilter,
-                                   TileMode tmx, TileMode tmy)
-        : Sampler_BitmapShader(src, doFilter, tmx, tmy)
-    {
-    }
-
-    virtual uint32_t getFlags()
-    {
-        uint32_t flags = this->INHERITED::getFlags();
-        
-        switch (this->getSrcBitmap().getConfig()) {
-        case SkBitmap::kRGB_565_Config:
-            flags |= kHasSpan16_Flag;
-            break;
-        case SkBitmap::kIndex8_Config:
-        case SkBitmap::kARGB_8888_Config:
-            if (this->getSrcBitmap().isOpaque())
-                flags |= kHasSpan16_Flag;
-            break;
-        default:
-            break;
-        }
-        return flags;
-    }
-    
-    const SkBitmap& revealSrcBitmap() const { return this->getSrcBitmap(); }
-    uint8_t         revealPaintAlpha() const { return this->getPaintAlpha(); }
-    const SkMatrix& revealTotalInverse() const { return this->getTotalInverse(); }
-
-private:
-    typedef Sampler_BitmapShader INHERITED;
-};
-
-///////////////////////////////////////////////////////////////////////////
-
-static void Index8_RepeatTile_Sprite16(HasSpan16_Sampler_BitmapShader* shader,
-                                       int x, int y, uint16_t dstC[], int count)
-{
-    const SkMatrix& inv = shader->revealTotalInverse();
-    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
-    int             width = srcBitmap.width();
-    int             height = srcBitmap.height();
-
-    SkColorTable* ctable = srcBitmap.getColorTable();
-    const uint16_t* colors = ctable->lock16BitCache();
-
-    x += SkScalarRound(inv[SkMatrix::kMTransX]);
-    y += SkScalarRound(inv[SkMatrix::kMTransY]);
-    
-    x = do_repeat_mod(x, width - 1);
-    y = do_repeat_mod(y, height - 1);
-    const uint8_t* row = srcBitmap.getAddr8(0, y);
-    const uint8_t* src = row + x;
-
-    // do the first partial run
-    int n = width - x;
-    if (n > count) n = count;
-    count -= n;
-    SkASSERT(n > 0);
-    do {
-        *dstC++ = colors[*src++];
-    } while (--n > 0);
-
-    // do 1 complete run
-    if (count >= width)
-    {
-        uint16_t* baseDstC = dstC;  // remember the first complete run start
-        n = width;
-        count -= width;
-        src = row;
-        do {
-            *dstC++ = colors[*src++];
-        } while (--n > 0);
-
-        // do the rest of the complete runs
-        while (count >= width)
-        {
-            count -= width;
-            memcpy(dstC, baseDstC, width << 1);
-            dstC += width;
-        }
-        // do final partial run
-        if (count > 0)
-            memcpy(dstC, baseDstC, count << 1);
-    }
-    else // do final partial
-    {
-        if (count > 0)
-        {
-            src = row;
-            do {
-                *dstC++ = colors[*src++];
-            } while (--count > 0);
-        }
-    }
-    
-    ctable->unlock16BitCache();
-}
-
-static void Index8_RepeatTile_Sprite32(HasSpan16_Sampler_BitmapShader* shader,
-                                       int x, int y, SkPMColor dstC[], int count)
-{
-    const SkMatrix& inv = shader->revealTotalInverse();
-    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
-    int             width = srcBitmap.width();
-    int             height = srcBitmap.height();
-
-    SkColorTable* ctable = srcBitmap.getColorTable();
-    const SkPMColor* colors = ctable->lockColors();
-
-    x += SkScalarRound(inv[SkMatrix::kMTransX]);
-    y += SkScalarRound(inv[SkMatrix::kMTransY]);
-    
-    x = do_repeat_mod(x, width - 1);
-    y = do_repeat_mod(y, height - 1);
-
-    const uint8_t* row = srcBitmap.getAddr8(0, y);
-    const uint8_t* src = row + x;
-
-    // do the first partial run
-    int n = width - x;
-    if (n > count) n = count;
-    count -= n;
-    SkASSERT(n > 0);
-    do {
-        *dstC++ = colors[*src++];
-    } while (--n > 0);
-
-    // do 1 complete run
-    if (count >= width)
-    {
-        SkPMColor* baseDstC = dstC;  // remember the first complete run start
-        n = width;
-        count -= width;
-        src = row;
-        do {
-            *dstC++ = colors[*src++];
-        } while (--n > 0);
-
-        // do the rest of the complete runs
-        while (count >= width)
-        {
-            count -= width;
-            memcpy(dstC, baseDstC, width << 2);
-            dstC += width;
-        }
-        // do final partial run
-        if (count > 0)
-            memcpy(dstC, baseDstC, count << 2);
-    }
-    else // do final partial
-    {
-        if (count > 0)
-        {
-            src = row;
-            do {
-                *dstC++ = colors[*src++];
-            } while (--count > 0);
-        }
-    }
-    
-    ctable->unlockColors(false);
-}
-
-static void RGB16_RepeatTile_Sprite16(HasSpan16_Sampler_BitmapShader* shader,
-                                       int x, int y, uint16_t dstC[], int count)
-{
-    SkASSERT(count > 0);
-
-    const SkMatrix& inv = shader->revealTotalInverse();
-    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
-    int             width = srcBitmap.width();
-    int             height = srcBitmap.height();
-    
-    SkASSERT(width > 0 && height > 0);
-
-    x += SkScalarRound(inv[SkMatrix::kMTransX]);
-    y += SkScalarRound(inv[SkMatrix::kMTransY]);
-    
-    x = do_repeat_mod(x, width - 1);
-    y = do_repeat_mod(y, height - 1);
-
-    const uint16_t* row = srcBitmap.getAddr16(0, y);
-    const uint16_t* src = row + x;
-
-    int n = SkMin32(width - x, count);
-
-    for (;;)
-    {
-        SkASSERT(n > 0 && count >= n);
-        memcpy(dstC, src, n << 1);
-        count -= n;
-        if (count == 0)
-            break;
-        dstC += n;
-        src = row;
-        n = SkMin32(width, count);
-    }
-}
-
-static void RGB16_RepeatTile_Sprite32(HasSpan16_Sampler_BitmapShader* shader,
-                                       int x, int y, SkPMColor dstC[], int count)
-{
-    SkASSERT(count > 0);
-
-    const SkMatrix& inv = shader->revealTotalInverse();
-    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
-    int             width = srcBitmap.width();
-    int             height = srcBitmap.height();
-    
-    SkASSERT(width > 0 && height > 0);
-
-    x += SkScalarRound(inv[SkMatrix::kMTransX]);
-    y += SkScalarRound(inv[SkMatrix::kMTransY]);
-    
-    x = do_repeat_mod(x, width - 1);
-    y = do_repeat_mod(y, height - 1);
-
-    const uint16_t* row = srcBitmap.getAddr16(0, y);
-    const uint16_t* src = row + x;
-
-    int n = SkMin32(width - x, count);
-
-    // do the first partial run
-    count -= n;
-    SkASSERT(n > 0);
-    do {
-        *dstC++ = SkPixel16ToPixel32(*src++);
-    } while (--n > 0);
-
-    // do 1 complete run
-    if (count >= width)
-    {
-        SkPMColor* baseDstC = dstC;  // remember the first complete run start
-        n = width;
-        count -= width;
-        src = row;
-        do {
-            *dstC++ = SkPixel16ToPixel32(*src++);
-        } while (--n > 0);
-
-        // do the rest of the complete runs
-        while (count >= width)
-        {
-            count -= width;
-            memcpy(dstC, baseDstC, width << 2);
-            dstC += width;
-        }
-        // do final partial run
-        if (count > 0)
-            memcpy(dstC, baseDstC, count << 2);
-    }
-    else // do final partial
-    {
-        if (count > 0)
-        {
-            src = row;
-            do {
-                *dstC++ = SkPixel16ToPixel32(*src++);;
-            } while (--count > 0);
-        }
-    }
-}
-
-static void ARGB32_RepeatTile_Sprite16(HasSpan16_Sampler_BitmapShader* shader,
-                                       int x, int y, uint16_t dstC[], int count)
-{
-    SkASSERT(count > 0);
-
-    const SkMatrix& inv = shader->revealTotalInverse();
-    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
-    int             width = srcBitmap.width();
-    int             height = srcBitmap.height();
-    
-    SkASSERT(width > 0 && height > 0);
-
-    x += SkScalarRound(inv[SkMatrix::kMTransX]);
-    y += SkScalarRound(inv[SkMatrix::kMTransY]);
-    
-    x = do_repeat_mod(x, width - 1);
-    y = do_repeat_mod(y, height - 1);
-
-    const SkPMColor* row = srcBitmap.getAddr32(0, y);
-    const SkPMColor* src = row + x;
-
-    int n = SkMin32(width - x, count);
-
-    // do the first partial run
-    count -= n;
-    SkASSERT(n > 0);
-    do {
-        *dstC++ = SkPixel32ToPixel16(*src++);
-    } while (--n > 0);
-
-    // do 1 complete run
-    if (count >= width)
-    {
-        uint16_t* baseDstC = dstC;  // remember the first complete run start
-        n = width;
-        count -= width;
-        src = row;
-        do {
-            *dstC++ = SkPixel32ToPixel16(*src++);
-        } while (--n > 0);
-
-        // do the rest of the complete runs
-        while (count >= width)
-        {
-            count -= width;
-            memcpy(dstC, baseDstC, width << 1);
-            dstC += width;
-        }
-        // do final partial run
-        if (count > 0)
-            memcpy(dstC, baseDstC, count << 1);
-    }
-    else // do final partial
-    {
-        if (count > 0)
-        {
-            src = row;
-            do {
-                *dstC++ = SkPixel32ToPixel16(*src++);;
-            } while (--count > 0);
-        }
-    }
-}
-
-static void ARGB32_RepeatTile_Sprite32(HasSpan16_Sampler_BitmapShader* shader,
-                                       int x, int y, SkPMColor dstC[], int count)
-{
-    SkASSERT(count > 0);
-
-    const SkMatrix& inv = shader->revealTotalInverse();
-    const SkBitmap& srcBitmap = shader->revealSrcBitmap();
-    int             width = srcBitmap.width();
-    int             height = srcBitmap.height();
-    
-    SkASSERT(width > 0 && height > 0);
-
-    x += SkScalarRound(inv[SkMatrix::kMTransX]);
-    y += SkScalarRound(inv[SkMatrix::kMTransY]);
-    
-    x = do_repeat_mod(x, width - 1);
-    y = do_repeat_mod(y, height - 1);
-
-    const SkPMColor* row = srcBitmap.getAddr32(0, y);
-    const SkPMColor* src = row + x;
-
-    int n = SkMin32(width - x, count);
-
-    for (;;)
-    {
-        SkASSERT(n > 0 && count >= n);
-        memcpy(dstC, src, n << 2);
-        count -= n;
-        if (count == 0)
-            break;
-        dstC += n;
-        src = row;
-        n = SkMin32(width, count);
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////
-
-#define NOFILTER_BITMAP_SHADER_CLASS                    Index8_NoFilter_RepeatTile_BitmapShader
-#define NOFILTER_BITMAP_SHADER_TILEMODE                 SkShader::kRepeat_TileMode
-#define NOFILTER_BITMAP_SHADER_TILEPROC(x, max)         (fixed_repeat(x) * (max + 1) >> 16)
-#define NOFILTER_BITMAP_SHADER_TYPE                     uint8_t
-#define NOFILTER_BITMAP_SHADER_SAMPLE_X(p, x)           colors32[p[x]]
-#define NOFILTER_BITMAP_SHADER_SAMPLE_XY(p, x, y, rb)   colors32[p[x + y * rb]]
-#define NOFILTER_BITMAP_SHADER_PREAMBLE(bitmap, rb)     const SkPMColor* colors32 = bitmap.getColorTable()->lockColors()
-#define NOFILTER_BITMAP_SHADER_POSTAMBLE(bitmap)        bitmap.getColorTable()->unlockColors(false)
-#define NOFILTER_BITMAP_SHADER_SAMPLE_X16(p, x)         colors16[p[x]]
-#define NOFILTER_BITMAP_SHADER_SAMPLE_XY16(p, x, y, rb) colors16[p[x + y * rb]]
-#define NOFILTER_BITMAP_SHADER_PREAMBLE16(bitmap, rb)   const uint16_t* colors16 = bitmap.getColorTable()->lock16BitCache()
-#define NOFILTER_BITMAP_SHADER_POSTAMBLE16(bitmap)      bitmap.getColorTable()->unlock16BitCache()
-#define NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
-#define NOFILTER_BITMAP_SHADER_SPRITEPROC16             Index8_RepeatTile_Sprite16
-#define NOFILTER_BITMAP_SHADER_SPRITEPROC32             Index8_RepeatTile_Sprite32
-#include "SkBitmapShaderTemplate.h"
-
-#define NOFILTER_BITMAP_SHADER_CLASS                    U16_NoFilter_RepeatTile_BitmapShader
-#define NOFILTER_BITMAP_SHADER_TILEMODE                 SkShader::kRepeat_TileMode
-#define NOFILTER_BITMAP_SHADER_TILEPROC(x, max)         (fixed_repeat(x) * (max + 1) >> 16)
-#define NOFILTER_BITMAP_SHADER_TYPE                     uint16_t
-#define NOFILTER_BITMAP_SHADER_SAMPLE_X(p, x)           SkPixel16ToPixel32(p[x])
-#define NOFILTER_BITMAP_SHADER_SAMPLE_XY(p, x, y, rb)   SkPixel16ToPixel32(*(const uint16_t*)((const char*)p + y * rb + (x << 1)))
-#define NOFILTER_BITMAP_SHADER_SAMPLE_X16(p, x)         p[x]
-#define NOFILTER_BITMAP_SHADER_SAMPLE_XY16(p, x, y, rb) *(const uint16_t*)((const char*)p + y * rb + (x << 1))
-#define NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
-#define NOFILTER_BITMAP_SHADER_SPRITEPROC16             RGB16_RepeatTile_Sprite16
-#define NOFILTER_BITMAP_SHADER_SPRITEPROC32             RGB16_RepeatTile_Sprite32
-#include "SkBitmapShaderTemplate.h"
-
-#define NOFILTER_BITMAP_SHADER_CLASS                    U32_NoFilter_RepeatTile_BitmapShader
-#define NOFILTER_BITMAP_SHADER_TILEMODE                 SkShader::kRepeat_TileMode
-#define NOFILTER_BITMAP_SHADER_TILEPROC(x, max)         (fixed_repeat(x) * (max + 1) >> 16)
-#define NOFILTER_BITMAP_SHADER_TYPE                     uint32_t
-#define NOFILTER_BITMAP_SHADER_SAMPLE_X(p, x)           p[x]
-#define NOFILTER_BITMAP_SHADER_SAMPLE_XY(p, x, y, rb)   *(const uint32_t*)((const char*)p + y * rb + (x << 2))
-#define NOFILTER_BITMAP_SHADER_SAMPLE_X16(p, x)         SkPixel32ToPixel16_ToU16(p[x])
-#define NOFILTER_BITMAP_SHADER_SAMPLE_XY16(p, x, y, rb) SkPixel32ToPixel16_ToU16(*(const uint32_t*)((const char*)p + y * rb + (x << 2)))
-#define NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
-#define NOFILTER_BITMAP_SHADER_SPRITEPROC16             ARGB32_RepeatTile_Sprite16
-#define NOFILTER_BITMAP_SHADER_SPRITEPROC32             ARGB32_RepeatTile_Sprite32
-#include "SkBitmapShaderTemplate.h"
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-
-static inline SkPMColor expanded_rgb16_to_8888(uint32_t c, U8CPU alpha)
-{
-//    GGGG Gggg gggR RRRR rrrr r|BB BBBb bbbb
-    SkASSERT(alpha <= 255);
-
-#if 1
-    int scale = SkAlpha255To256(alpha);
-    int r = (c & 0xF800) * scale >> 16;
-    int g = ((c >> 21) & 0x3F) * scale >> 6;
-    int b = (c & 0x1F) * scale >> 5;
-    return SkPackARGB32(alpha, r, g, b);
-#else
-    int scale = SkAlpha255To256(alpha) >> 3;
-    c &= 0x07E0F81F;
-    c = c * scale;
-    int r = (c >> 13) & 0xFF;
-    int g = (c >> 24) & 0xFF;
-    int b = (c >> 2) & 0xFF;
-    return SkPackARGB32(alpha, r, g, b);
-#endif
-}
-
-#define BILERP_BITMAP16_SHADER_CLASS            U16_Bilerp_BitmapShader
-#define BILERP_BITMAP16_SHADER_TYPE             uint16_t
-#define BILERP_BITMAP16_SHADER_PREAMBLE(bm)
-#define BILERP_BITMAP16_SHADER_PIXEL(c)         (c)
-#define BILERP_BITMAP16_SHADER_POSTAMBLE(bm)
-#include "SkBitmapShader16BilerpTemplate.h"
-
-#define BILERP_BITMAP16_SHADER_CLASS            Index8_Bilerp_BitmapShader
-#define BILERP_BITMAP16_SHADER_TYPE             uint8_t
-#define BILERP_BITMAP16_SHADER_PREAMBLE(bm)     SkColorTable* ctable = (bm).getColorTable(); const uint16_t* colors16 = ctable->lock16BitCache()
-#define BILERP_BITMAP16_SHADER_PIXEL(c)         colors16[c]
-#define BILERP_BITMAP16_SHADER_POSTAMBLE(bm)    ctable->unlock16BitCache()
-#include "SkBitmapShader16BilerpTemplate.h"
-
-#include "ARGB32_Clamp_Bilinear_BitmapShader.h"
-
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-
-#include "SkBitmapProcShader.h"
-
-///////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////
-
-#include "SkTemplatesPriv.h"
-
-SkShader* SkShader::CreateBitmapShader(const SkBitmap& src,
-                                       bool doFilter,
-                                       TileMode tmx, TileMode tmy,
-                                       void* storage, size_t storageSize)
-{
-#if 1
-    
-    SkShader* shader;
-    SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
-                          storageSize, (src, doFilter, tmx, tmy));
-    return shader;
-#else
-
-    if (!doFilter)
-    {
-        if (kClamp_TileMode == tmx && kClamp_TileMode == tmy)
-        {
-            SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
-                                  storageSize, (src, doFilter, tmx, tmy));
-        }
-        else if (kRepeat_TileMode == tmx && kRepeat_TileMode == tmy)
-        {
-    #if 1
-            SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
-                                  storageSize, (src, doFilter, tmx, tmy));
-    #else
-            switch (src.getConfig()) {
-            case SkBitmap::kIndex8_Config:
-                SK_PLACEMENT_NEW_ARGS(shader, Index8_NoFilter_RepeatTile_BitmapShader, storage, storageSize, (src));
-                break;
-            case SkBitmap::kRGB_565_Config:
-                SK_PLACEMENT_NEW_ARGS(shader, U16_NoFilter_RepeatTile_BitmapShader, storage, storageSize, (src));
-                break;
-            case SkBitmap::kARGB_8888_Config:
-                SK_PLACEMENT_NEW_ARGS(shader, U32_NoFilter_RepeatTile_BitmapShader, storage, storageSize, (src));
-                break;
-            default:
-                break;
-            }
-    #endif
-        }
-    }
-    else if (kClamp_TileMode == tmx && kClamp_TileMode == tmy)
-    {
-#if 1
-        if (SkBitmapProcShader::CanDo(src, tmx, tmy))
-        {
-            SK_PLACEMENT_NEW_ARGS(shader, SkBitmapProcShader, storage,
-                                  storageSize, (src, doFilter, tmx, tmy));
-        }
-#else
-        switch (src.getConfig()) {
-        case SkBitmap::kIndex8_Config:
-            if (src.isOpaque())
-                SK_PLACEMENT_NEW_ARGS(shader, Index8_Bilerp_BitmapShader, storage, storageSize, (src));
-            break;
-        case SkBitmap::kRGB_565_Config:
-            SK_PLACEMENT_NEW_ARGS(shader, U16_Bilerp_BitmapShader, storage, storageSize, (src));
-            break;
-        case SkBitmap::kARGB_8888_Config:
-            SK_PLACEMENT_NEW_ARGS(shader, ARGB32_Clamp_Bilinear_BitmapShader, storage, storageSize, (src));
-            break;
-        default:
-            break;
-        }
-#endif
-    }
-    
-    // if shader is null, then none of the special cases could handle the request
-    // so fall through to our slow-general case
-    if (shader == NULL)
-        SK_PLACEMENT_NEW_ARGS(shader, Sampler_BitmapShader, storage, storageSize,
-                              (src, doFilter, tmx, tmy));
-    return shader;
-#endif
-}
-
-SkShader* SkShader::CreateBitmapShader(const SkBitmap& src, bool doFilter,
-                                       TileMode tmx, TileMode tmy)
-{
-    return SkShader::CreateBitmapShader(src, doFilter, tmx, tmy, NULL, 0);
-}
-
-#endif
diff --git a/src/core/SkBitmapShader.h b/src/core/SkBitmapShader.h
index 8d40a4b041..0e326b1e8a 100644
--- a/src/core/SkBitmapShader.h
+++ b/src/core/SkBitmapShader.h
@@ -34,33 +34,18 @@ protected:
     SkBitmapShader(SkFlattenableReadBuffer& );
     virtual void flatten(SkFlattenableWriteBuffer& );
     virtual Factory getFactory() { return CreateProc; }
-    const SkBitmap&     getSrcBitmap() const
-    {
-#ifdef SK_SUPPORT_MIPMAP
-        return fMipSrcBitmap;
-#else
-        return fOrigSrcBitmap;
-#endif
-    }
+    const SkBitmap& getSrcBitmap() const { return fMipSrcBitmap; }
     bool        getFilterBitmap() const { return fFilterBitmap != 0; }
     TileMode    getTileModeX() const { return (TileMode)fTileModeX; }
     TileMode    getTileModeY() const { return (TileMode)fTileModeY; }
-    SkFixed     getMipLevel() const 
-    {
-#ifdef SK_SUPPORT_MIPMAP
-        return fMipLevel;
-#else
-        return 0;
-#endif
-    }
+    SkFixed     getMipLevel() const { return fMipLevel; }
 
 private:
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) { 
-        return SkNEW_ARGS(SkBitmapShader, (buffer)); }
-#ifdef SK_SUPPORT_MIPMAP
+        return SkNEW_ARGS(SkBitmapShader, (buffer));
+    }
     SkFixed     fMipLevel;
     SkBitmap    fMipSrcBitmap; // the chosen level (in setContext)
-#endif
     SkBitmap    fOrigSrcBitmap;
     uint8_t     fFilterBitmap;
     uint8_t     fTileModeX;
diff --git a/src/core/SkBitmapShaderTemplate.h b/src/core/SkBitmapShaderTemplate.h
index 01741386f5..7254aa50b9 100644
--- a/src/core/SkBitmapShaderTemplate.h
+++ b/src/core/SkBitmapShaderTemplate.h
@@ -137,7 +137,7 @@ public:
             }
         }
 
-#if defined(SK_SUPPORT_MIPMAP) && !defined(NOFILTER_BITMAP_SHADER_USE_UNITINVERSE)
+#ifndef NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
         {   int level = this->getMipLevel() >> 16;
             fx >>= level;
             fy >>= level;
@@ -260,7 +260,7 @@ public:
             }
         }
 
-#if defined(SK_SUPPORT_MIPMAP) && !defined(NOFILTER_BITMAP_SHADER_USE_UNITINVERSE)
+#ifndef NOFILTER_BITMAP_SHADER_USE_UNITINVERSE
         {   int level = this->getMipLevel() >> 16;
             fx >>= level;
             fy >>= level;