remove dead mipmap code from SkBitmap

src/core/SkBitmap.cpp

 
 /*
  * Copyright 2008 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 "SkBitmap.h"
@@ skipping 11 matching lines @@
 #include "SkUtils.h"
 #include "SkValidationUtils.h"
 #include "SkPackBits.h"
 #include <new>
 
 static bool reset_return_false(SkBitmap* bm) {
     bm->reset();
     return false;
 }
 
-struct MipLevel {
-    void*       fPixels;
-    uint32_t    fRowBytes;
-    uint32_t    fWidth, fHeight;
-};
-
-struct SkBitmap::MipMap : SkNoncopyable {
-    int32_t fRefCnt;
-    int     fLevelCount;
-//  MipLevel    fLevel[fLevelCount];
-//  Pixels[]
-
-    static MipMap* Alloc(int levelCount, size_t pixelSize) {
-        if (levelCount < 0) {
-            return NULL;
-        }
-        int64_t size = (levelCount + 1) * sizeof(MipLevel);
-        size += sizeof(MipMap) + pixelSize;
-        if (!sk_64_isS32(size)) {
-            return NULL;
-        }
-        MipMap* mm = (MipMap*)sk_malloc_throw(sk_64_asS32(size));
-        mm->fRefCnt = 1;
-        mm->fLevelCount = levelCount;
-        return mm;
-    }
-
-    const MipLevel* levels() const { return (const MipLevel*)(this + 1); }
-    MipLevel* levels() { return (MipLevel*)(this + 1); }
-
-    const void* pixels() const { return levels() + fLevelCount; }
-    void* pixels() { return levels() + fLevelCount; }
-
-    void ref() {
-        if (SK_MaxS32 == sk_atomic_inc(&fRefCnt)) {
-            sk_throw();
-        }
-    }
-    void unref() {
-        SkASSERT(fRefCnt > 0);
-        if (sk_atomic_dec(&fRefCnt) == 1) {
-            sk_free(this);
-        }
-    }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
 SkBitmap::SkBitmap() {
     sk_bzero(this, sizeof(*this));
 }
 
 SkBitmap::SkBitmap(const SkBitmap& src) {
     SkDEBUGCODE(src.validate();)
     sk_bzero(this, sizeof(*this));
     *this = src;
     SkDEBUGCODE(this->validate();)
 }
 
 SkBitmap::~SkBitmap() {
     SkDEBUGCODE(this->validate();)
     this->freePixels();
 }
 
 SkBitmap& SkBitmap::operator=(const SkBitmap& src) {
     if (this != &src) {
         this->freePixels();
         memcpy(this, &src, sizeof(src));
 
         // inc src reference counts
         SkSafeRef(src.fPixelRef);
-        SkSafeRef(src.fMipMap);
 
         // we reset our locks if we get blown away
         fPixelLockCount = 0;
 
         if (fPixelRef) {
             // ignore the values from the memcpy
             fPixels = NULL;
             fColorTable = NULL;
             // Note that what to for genID is somewhat arbitrary. We have no
             // way to track changes to raw pixels across multiple SkBitmaps.
             // Would benefit from an SkRawPixelRef type created by
             // setPixels.
             // Just leave the memcpy'ed one but they'll get out of sync
             // as soon either is modified.
         }
     }
 
     SkDEBUGCODE(this->validate();)
     return *this;
 }
 
 void SkBitmap::swap(SkBitmap& other) {
     SkTSwap(fColorTable, other.fColorTable);
     SkTSwap(fPixelRef, other.fPixelRef);
     SkTSwap(fPixelRefOrigin, other.fPixelRefOrigin);
     SkTSwap(fPixelLockCount, other.fPixelLockCount);
-    SkTSwap(fMipMap, other.fMipMap);
     SkTSwap(fPixels, other.fPixels);
     SkTSwap(fInfo, other.fInfo);
     SkTSwap(fRowBytes, other.fRowBytes);
     SkTSwap(fFlags, other.fFlags);
 
     SkDEBUGCODE(this->validate();)
 }
 
 void SkBitmap::reset() {
     this->freePixels();
@@ skipping 393 matching lines @@
         return false;
     }
 
     SkAlphaType at = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
     return this->allocPixels(SkImageInfo::Make(width, height, ct, at));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkBitmap::freePixels() {
-    // if we're gonna free the pixels, we certainly need to free the mipmap
-    this->freeMipMap();
-
     if (NULL != fPixelRef) {
         if (fPixelLockCount > 0) {
             fPixelRef->unlockPixels();
         }
         fPixelRef->unref();
         fPixelRef = NULL;
         fPixelRefOrigin.setZero();
     }
     fPixelLockCount = 0;
     fPixels = NULL;
     fColorTable = NULL;
 }
 
-void SkBitmap::freeMipMap() {
-    if (fMipMap) {
-        fMipMap->unref();
-        fMipMap = NULL;
-    }
-}
-
 uint32_t SkBitmap::getGenerationID() const {
     return (fPixelRef) ? fPixelRef->getGenerationID() : 0;
 }
 
 void SkBitmap::notifyPixelsChanged() const {
     SkASSERT(!this->isImmutable());
     if (fPixelRef) {
         fPixelRef->notifyPixelsChanged();
     }
 }
@@ skipping 604 matching lines @@
     }
 
     if (this->getTexture()) {
         return false;
     } else {
         return this->copyTo(dst, dstCT, NULL);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-static void downsampleby2_proc32(SkBitmap* dst, int x, int y,
-                                 const SkBitmap& src) {
-    x <<= 1;
-    y <<= 1;
-    const SkPMColor* p = src.getAddr32(x, y);
-    const SkPMColor* baseP = p;
-    SkPMColor c, ag, rb;
-
-    c = *p; ag = (c >> 8) & 0xFF00FF; rb = c & 0xFF00FF;
-    if (x < src.width() - 1) {
-        p += 1;
-    }
-    c = *p; ag += (c >> 8) & 0xFF00FF; rb += c & 0xFF00FF;
-
-    p = baseP;
-    if (y < src.height() - 1) {
-        p += src.rowBytes() >> 2;
-    }
-    c = *p; ag += (c >> 8) & 0xFF00FF; rb += c & 0xFF00FF;
-    if (x < src.width() - 1) {
-        p += 1;
-    }
-    c = *p; ag += (c >> 8) & 0xFF00FF; rb += c & 0xFF00FF;
-
-    *dst->getAddr32(x >> 1, y >> 1) =
-        ((rb >> 2) & 0xFF00FF) | ((ag << 6) & 0xFF00FF00);
-}
-
-static inline uint32_t expand16(U16CPU c) {
-    return (c & ~SK_G16_MASK_IN_PLACE) | ((c & SK_G16_MASK_IN_PLACE) << 16);
-}
-
-// returns dirt in the top 16bits, but we don't care, since we only
-// store the low 16bits.
-static inline U16CPU pack16(uint32_t c) {
-    return (c & ~SK_G16_MASK_IN_PLACE) | ((c >> 16) & SK_G16_MASK_IN_PLACE);
-}
-
-static void downsampleby2_proc16(SkBitmap* dst, int x, int y,
-                                 const SkBitmap& src) {
-    x <<= 1;
-    y <<= 1;
-    const uint16_t* p = src.getAddr16(x, y);
-    const uint16_t* baseP = p;
-    SkPMColor       c;
-
-    c = expand16(*p);
-    if (x < src.width() - 1) {
-        p += 1;
-    }
-    c += expand16(*p);
-
-    p = baseP;
-    if (y < src.height() - 1) {
-        p += src.rowBytes() >> 1;
-    }
-    c += expand16(*p);
-    if (x < src.width() - 1) {
-        p += 1;
-    }
-    c += expand16(*p);
-
-    *dst->getAddr16(x >> 1, y >> 1) = (uint16_t)pack16(c >> 2);
-}
-
-static uint32_t expand4444(U16CPU c) {
-    return (c & 0xF0F) | ((c & ~0xF0F) << 12);
-}
-
-static U16CPU collaps4444(uint32_t c) {
-    return (c & 0xF0F) | ((c >> 12) & ~0xF0F);
-}
-
-static void downsampleby2_proc4444(SkBitmap* dst, int x, int y,
-                                   const SkBitmap& src) {
-    x <<= 1;
-    y <<= 1;
-    const uint16_t* p = src.getAddr16(x, y);
-    const uint16_t* baseP = p;
-    uint32_t        c;
-
-    c = expand4444(*p);
-    if (x < src.width() - 1) {
-        p += 1;
-    }
-    c += expand4444(*p);
-
-    p = baseP;
-    if (y < src.height() - 1) {
-        p += src.rowBytes() >> 1;
-    }
-    c += expand4444(*p);
-    if (x < src.width() - 1) {
-        p += 1;
-    }
-    c += expand4444(*p);
-
-    *dst->getAddr16(x >> 1, y >> 1) = (uint16_t)collaps4444(c >> 2);
-}
-
-void SkBitmap::buildMipMap(bool forceRebuild) {
-    if (forceRebuild)
-        this->freeMipMap();
-    else if (fMipMap)
-        return; // we're already built
-
-    SkASSERT(NULL == fMipMap);
-
-    void (*proc)(SkBitmap* dst, int x, int y, const SkBitmap& src);
-
-    const SkBitmap::Config config = this->config();
-
-    switch (config) {
-        case kARGB_8888_Config:
-            proc = downsampleby2_proc32;
-            break;
-        case kRGB_565_Config:
-            proc = downsampleby2_proc16;
-            break;
-        case kARGB_4444_Config:
-            proc = downsampleby2_proc4444;
-            break;
-        case kIndex8_Config:
-        case kA8_Config:
-        default:
-            return; // don't build mipmaps for these configs
-    }
-
-    SkAutoLockPixels alp(*this);
-    if (!this->readyToDraw()) {
-        return;
-    }
-
-    // whip through our loop to compute the exact size needed
-    size_t  size = 0;
-    int     maxLevels = 0;
-    {
-        int width = this->width();
-        int height = this->height();
-        for (;;) {
-            width >>= 1;
-            height >>= 1;
-            if (0 == width || 0 == height) {
-                break;
-            }
-            size += ComputeRowBytes(config, width) * height;
-            maxLevels += 1;
-        }
-    }
-
-    // nothing to build
-    if (0 == maxLevels) {
-        return;
-    }
-
-    SkBitmap srcBM(*this);
-    srcBM.lockPixels();
-    if (!srcBM.readyToDraw()) {
-        return;
-    }
-
-    MipMap* mm = MipMap::Alloc(maxLevels, size);
-    if (NULL == mm) {
-        return;
-    }
-
-    MipLevel*   level = mm->levels();
-    uint8_t*    addr = (uint8_t*)mm->pixels();
-    int         width = this->width();
-    int         height = this->height();
-    uint32_t    rowBytes;
-    SkBitmap    dstBM;
-
-    for (int i = 0; i < maxLevels; i++) {
-        width >>= 1;
-        height >>= 1;
-        rowBytes = SkToU32(ComputeRowBytes(config, width));
-
-        level[i].fPixels   = addr;
-        level[i].fWidth    = width;
-        level[i].fHeight   = height;
-        level[i].fRowBytes = rowBytes;
-
-        dstBM.setConfig(config, width, height, rowBytes);
-        dstBM.setPixels(addr);
-
-        srcBM.lockPixels();
-        for (int y = 0; y < height; y++) {
-            for (int x = 0; x < width; x++) {
-                proc(&dstBM, x, y, srcBM);
-            }
-        }
-        srcBM.unlockPixels();
-
-        srcBM = dstBM;
-        addr += height * rowBytes;
-    }
-    SkASSERT(addr == (uint8_t*)mm->pixels() + size);
-    fMipMap = mm;
-}
-
-bool SkBitmap::hasMipMap() const {
-    return fMipMap != NULL;
-}
-
-int SkBitmap::extractMipLevel(SkBitmap* dst, SkFixed sx, SkFixed sy) {
-    if (NULL == fMipMap) {
-        return 0;
-    }
-
-    int level = ComputeMipLevel(sx, sy) >> 16;
-    SkASSERT(level >= 0);
-    if (level <= 0) {
-        return 0;
-    }
-
-    if (level >= fMipMap->fLevelCount) {
-        level = fMipMap->fLevelCount - 1;
-    }
-    if (dst) {
-        const MipLevel& mip = fMipMap->levels()[level - 1];
-        dst->setConfig((SkBitmap::Config)this->config(),
-                       mip.fWidth, mip.fHeight, mip.fRowBytes);
-        dst->setPixels(mip.fPixels);
-    }
-    return level;
-}
-
-SkFixed SkBitmap::ComputeMipLevel(SkFixed sx, SkFixed sy) {
-    sx = SkAbs32(sx);
-    sy = SkAbs32(sy);
-    if (sx < sy) {
-        sx = sy;
-    }
-    if (sx < SK_Fixed1) {
-        return 0;
-    }
-    int clz = SkCLZ(sx);
-    SkASSERT(clz >= 1 && clz <= 15);
-    return SkIntToFixed(15 - clz) + ((unsigned)(sx << (clz + 1)) >> 16);
-}
-
-///////////////////////////////////////////////////////////////////////////////
 
 static bool GetBitmapAlpha(const SkBitmap& src, uint8_t* SK_RESTRICT alpha,
                            int alphaRowBytes) {
     SkASSERT(alpha != NULL);
     SkASSERT(alphaRowBytes >= src.width());
 
     SkBitmap::Config config = src.config();
     int              w = src.width();
     int              h = src.height();
     size_t           rb = src.rowBytes();
@@ skipping 282 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkImageInfo::validate() const {
     SkASSERT(fWidth >= 0);
     SkASSERT(fHeight >= 0);
     SkASSERT(SkColorTypeIsValid(fColorType));
     SkASSERT(SkAlphaTypeIsValid(fAlphaType));
 }
 #endif