remove kRLE_Index8_Config 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 143 matching lines @@
     sk_bzero(this, sizeof(*this));
 }
 
 int SkBitmap::ComputeBytesPerPixel(SkBitmap::Config config) {
     int bpp;
     switch (config) {
         case kNo_Config:
         case kA1_Config:
             bpp = 0;   // not applicable
             break;
-        case kRLE_Index8_Config:
         case kA8_Config:
         case kIndex8_Config:
             bpp = 1;
             break;
         case kRGB_565_Config:
         case kARGB_4444_Config:
             bpp = 2;
             break;
         case kARGB_8888_Config:
             bpp = 4;
             break;
         default:
             SkDEBUGFAIL("unknown config");
             bpp = 0;   // error
             break;
     }
     return bpp;
 }
 
 size_t SkBitmap::ComputeRowBytes(Config c, int width) {
     if (width < 0) {
         return 0;
     }
 
     Sk64 rowBytes;
     rowBytes.setZero();
 
     switch (c) {
         case kNo_Config:
-        case kRLE_Index8_Config:
             break;
         case kA1_Config:
             rowBytes.set(width);
             rowBytes.add(7);
             rowBytes.shiftRight(3);
             break;
         case kA8_Config:
         case kIndex8_Config:
             rowBytes.set(width);
             break;
@@ skipping 261 matching lines @@
     return ComputeSafeSize64(getConfig(), fWidth, fHeight, fRowBytes);
 }
 
 bool SkBitmap::copyPixelsTo(void* const dst, size_t dstSize,
                             size_t dstRowBytes, bool preserveDstPad) const {
 
     if (0 == dstRowBytes) {
         dstRowBytes = fRowBytes;
     }
 
-    if (getConfig() == kRLE_Index8_Config ||
-        dstRowBytes < ComputeRowBytes(getConfig(), fWidth) ||
+    if (dstRowBytes < ComputeRowBytes(getConfig(), fWidth) ||
         dst == NULL || (getPixels() == NULL && pixelRef() == NULL))
         return false;
 
     if (!preserveDstPad && static_cast<uint32_t>(dstRowBytes) == fRowBytes) {
         size_t safeSize = getSafeSize();
         if (safeSize > dstSize || safeSize == 0)
             return false;
         else {
             SkAutoLockPixels lock(*this);
             // This implementation will write bytes beyond the end of each row,
@@ skipping 43 matching lines @@
     switch (fConfig) {
         case kNo_Config:
             return true;
 
         case kA1_Config:
         case kA8_Config:
         case kARGB_4444_Config:
         case kARGB_8888_Config:
             return (fFlags & kImageIsOpaque_Flag) != 0;
 
-        case kIndex8_Config:
-        case kRLE_Index8_Config: {
-                uint32_t flags = 0;
+        case kIndex8_Config: {
+            uint32_t flags = 0;
 
-                this->lockPixels();
-                // if lockPixels failed, we may not have a ctable ptr
-                if (fColorTable) {
-                    flags = fColorTable->getFlags();
-                }
-                this->unlockPixels();
+            this->lockPixels();
+            // if lockPixels failed, we may not have a ctable ptr
+            if (fColorTable) {
+                flags = fColorTable->getFlags();
+            }
+            this->unlockPixels();
 
-                return (flags & SkColorTable::kColorsAreOpaque_Flag) != 0;
-            }
+            return (flags & SkColorTable::kColorsAreOpaque_Flag) != 0;
+        }
 
         case kRGB_565_Config:
             return true;
 
         default:
             SkDEBUGFAIL("unknown bitmap config pased to isOpaque");
             return false;
     }
 }
 
@@ skipping 35 matching lines @@
             case SkBitmap::kRGB_565_Config:
                 base += x << 1;
                 break;
             case SkBitmap::kA8_Config:
             case SkBitmap::kIndex8_Config:
                 base += x;
                 break;
             case SkBitmap::kA1_Config:
                 base += x >> 3;
                 break;
-            case kRLE_Index8_Config:
-                SkDEBUGFAIL("Can't return addr for kRLE_Index8_Config");
-                base = NULL;
-                break;
             default:
                 SkDEBUGFAIL("Can't return addr for config");
                 base = NULL;
                 break;
         }
     }
     return base;
 }
 
 SkColor SkBitmap::getColor(int x, int y) const {
@@ skipping 24 matching lines @@
         }
         case SkBitmap::kARGB_4444_Config: {
             uint16_t* addr = this->getAddr16(x, y);
             SkPMColor c = SkPixel4444ToPixel32(addr[0]);
             return SkUnPreMultiply::PMColorToColor(c);
         }
         case SkBitmap::kARGB_8888_Config: {
             uint32_t* addr = this->getAddr32(x, y);
             return SkUnPreMultiply::PMColorToColor(addr[0]);
         }
-        case kRLE_Index8_Config: {
-            uint8_t dst;
-            const SkBitmap::RLEPixels* rle =
-                (const SkBitmap::RLEPixels*)this->getPixels();
-            SkPackBits::Unpack8(&dst, x, 1, rle->packedAtY(y));
-            return SkUnPreMultiply::PMColorToColor((*fColorTable)[dst]);
-        }
         case kNo_Config:
             SkASSERT(false);
             return 0;
     }
     SkASSERT(false);  // Not reached.
     return 0;
 }
 
 bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
     SkAutoLockPixels alp(bm);
@@ skipping 14 matching lines @@
                 const uint8_t* row = bm.getAddr8(0, y);
                 for (int x = 0; x < width; ++x) {
                     a &= row[x];
                 }
                 if (0xFF != a) {
                     return false;
                 }
             }
             return true;
         } break;
-        case kRLE_Index8_Config:
         case SkBitmap::kIndex8_Config: {
             SkAutoLockColors alc(bm);
             const SkPMColor* table = alc.colors();
             if (!table) {
                 return false;
             }
             SkPMColor c = (SkPMColor)~0;
             for (int i = bm.getColorTable()->count() - 1; i >= 0; --i) {
                 c &= table[i];
             }
@@ skipping 230 matching lines @@
             dst.setConfig(this->config(), subset.width(), subset.height());
             dst.setIsVolatile(this->isVolatile());
             dst.setIsOpaque(this->isOpaque());
             dst.setPixelRef(pixelRef)->unref();
             SkDEBUGCODE(dst.validate());
             result->swap(dst);
             return true;
         }
     }
 
-    if (kRLE_Index8_Config == fConfig) {
-        SkAutoLockPixels alp(*this);
-        // don't call readyToDraw(), since we can operate w/o a colortable
-        // at this stage
-        if (this->getPixels() == NULL) {
-            return false;
-        }
-        SkBitmap bm;
-
-        bm.setConfig(kIndex8_Config, r.width(), r.height());
-        bm.allocPixels(this->getColorTable());
-        if (NULL == bm.getPixels()) {
-            return false;
-        }
-
-        const RLEPixels* rle = (const RLEPixels*)this->getPixels();
-        uint8_t* dst = bm.getAddr8(0, 0);
-        const int width = bm.width();
-        const size_t rowBytes = bm.rowBytes();
-
-        for (int y = r.fTop; y < r.fBottom; y++) {
-            SkPackBits::Unpack8(dst, r.fLeft, width, rle->packedAtY(y));
-            dst += rowBytes;
-        }
-        result->swap(bm);
-        return true;
-    }
-
     // If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
     // exited above.
     SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
     SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
 
     size_t offset = get_sub_offset(*this, r.fLeft, r.fTop);
     if (SUB_OFFSET_FAILURE == offset) {
         return false;   // config not supported
     }
 
@@ skipping 700 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif