remove kA1_Config, as it is no longer supported

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 @@
 
 void SkBitmap::reset() {
     this->freePixels();
     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 kA8_Config:
         case kIndex8_Config:
             bpp = 1;
             break;
         case kRGB_565_Config:
         case kARGB_4444_Config:
             bpp = 2;
             break;
@@ skipping 12 matching lines @@
     if (width < 0) {
         return 0;
     }
 
     Sk64 rowBytes;
     rowBytes.setZero();
 
     switch (c) {
         case kNo_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;
         case kRGB_565_Config:
         case kARGB_4444_Config:
             rowBytes.set(width);
             rowBytes.shiftLeft(1);
             break;
         case kARGB_8888_Config:
@@ skipping 56 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool validate_alphaType(SkBitmap::Config config, SkAlphaType alphaType,
                                SkAlphaType* canonical = NULL) {
     switch (config) {
         case SkBitmap::kNo_Config:
             alphaType = kIgnore_SkAlphaType;
             break;
-        case SkBitmap::kA1_Config:
         case SkBitmap::kA8_Config:
             if (kUnpremul_SkAlphaType == alphaType) {
                 alphaType = kPremul_SkAlphaType;
             }
             // fall-through
         case SkBitmap::kIndex8_Config:
         case SkBitmap::kARGB_4444_Config:
         case SkBitmap::kARGB_8888_Config:
             if (kIgnore_SkAlphaType == alphaType) {
                 return false;
             }
             break;
         case SkBitmap::kRGB_565_Config:
             alphaType = kOpaque_SkAlphaType;
             break;
+        default:
+            return false;
     }
     if (canonical) {
         *canonical = alphaType;
     }
     return true;
 }
 
 bool SkBitmap::setConfig(Config config, int width, int height, size_t rowBytes,
                          SkAlphaType alphaType) {
     if ((width | height) < 0) {
@@ skipping 295 matching lines @@
                 base += x << 2;
                 break;
             case SkBitmap::kARGB_4444_Config:
             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;
             default:
                 SkDEBUGFAIL("Can't return addr for config");
                 base = NULL;
                 break;
         }
     }
     return base;
 }
 
 SkColor SkBitmap::getColor(int x, int y) const {
     SkASSERT((unsigned)x < (unsigned)this->width());
     SkASSERT((unsigned)y < (unsigned)this->height());
 
     switch (this->config()) {
-        case SkBitmap::kA1_Config: {
-            uint8_t* addr = this->getAddr1(x, y);
-            uint8_t mask = 1 << (7  - (x % 8));
-            if (addr[0] & mask) {
-                return SK_ColorBLACK;
-            } else {
-                return 0;
-            }
-        }
         case SkBitmap::kA8_Config: {
             uint8_t* addr = this->getAddr8(x, y);
             return SkColorSetA(0, addr[0]);
         }
         case SkBitmap::kIndex8_Config: {
             SkPMColor c = this->getIndex8Color(x, y);
             return SkUnPreMultiply::PMColorToColor(c);
         }
         case SkBitmap::kRGB_565_Config: {
             uint16_t* addr = this->getAddr16(x, y);
             return SkPixel16ToColor(addr[0]);
         }
         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 kNo_Config:
+        default:
             SkASSERT(false);
             return 0;
     }
     SkASSERT(false);  // Not reached.
     return 0;
 }
 
 bool SkBitmap::ComputeIsOpaque(const SkBitmap& bm) {
     SkAutoLockPixels alp(bm);
     if (!bm.getPixels()) {
         return false;
     }
 
     const int height = bm.height();
     const int width = bm.width();
 
     switch (bm.config()) {
-        case SkBitmap::kA1_Config: {
-            // TODO
-        } break;
         case SkBitmap::kA8_Config: {
             unsigned a = 0xFF;
             for (int y = 0; y < height; ++y) {
                 const uint8_t* row = bm.getAddr8(0, y);
                 for (int x = 0; x < width; ++x) {
                     a &= row[x];
                 }
                 if (0xFF != a) {
                     return false;
                 }
@@ skipping 85 matching lines @@
     const int rowBytes = fRowBytes;
 
     // make rgb premultiplied
     if (255 != a) {
         r = SkAlphaMul(r, a);
         g = SkAlphaMul(g, a);
         b = SkAlphaMul(b, a);
     }
 
     switch (fConfig) {
-        case kA1_Config: {
-            uint8_t* p = this->getAddr1(area.fLeft, area.fTop);
-            const int left = area.fLeft >> 3;
-            const int right = area.fRight >> 3;
-
-            int middle = right - left - 1;
-
-            uint8_t leftMask = 0xFF >> (area.fLeft & 7);
-            uint8_t rightMask = ~(0xFF >> (area.fRight & 7));
-            if (left == right) {
-                leftMask &= rightMask;
-                rightMask = 0;
-            }
-
-            a = (a >> 7) ? 0xFF : 0;
-            while (--height >= 0) {
-                uint8_t* startP = p;
-
-                *p = (*p & ~leftMask) | (a & leftMask);
-                p++;
-                if (middle > 0) {
-                    memset(p, a, middle);
-                    p += middle;
-                }
-                if (rightMask) {
-                    *p = (*p & ~rightMask) | (a & rightMask);
-                }
-
-                p = startP + rowBytes;
-            }
-            break;
-        }
         case kA8_Config: {
             uint8_t* p = this->getAddr8(area.fLeft, area.fTop);
             while (--height >= 0) {
                 memset(p, a, width);
                 p += rowBytes;
             }
             break;
         }
         case kARGB_4444_Config:
         case kRGB_565_Config: {
@@ skipping 65 matching lines @@
         case SkBitmap::kRGB_565_Config:
         case SkBitmap::kARGB_4444_Config:
             x <<= 1;
             break;
 
         case SkBitmap::kARGB_8888_Config:
             x <<= 2;
             break;
 
         case SkBitmap::kNo_Config:
-        case SkBitmap::kA1_Config:
         default:
             return SUB_OFFSET_FAILURE;
     }
     return y * bm.rowBytes() + x;
 }
 
 /**
  *  Using the pixelRefOffset(), rowBytes(), and Config of bm, determine the (x, y) coordinate of the
  *  upper left corner of bm relative to its SkPixelRef.
  *  x and y must be non-NULL.
@@ skipping 22 matching lines @@
         case SkBitmap::kARGB_4444_Config:
             *x >>= 1;
             break;
 
         case SkBitmap::kARGB_8888_Config:
             *x >>= 2;
             break;
 
         case SkBitmap::kNo_Config:
             // Fall through.
-        case SkBitmap::kA1_Config:
-            // Fall through.
         default:
             return false;
     }
     return true;
 }
 
 static bool get_upper_left_from_offset(const SkBitmap& bm, int32_t* x, int32_t* y) {
     return get_upper_left_from_offset(bm.config(), bm.pixelRefOffset(), bm.rowBytes(), x, y);
 }
 
@@ skipping 60 matching lines @@
     if (this->config() == kNo_Config) {
         return false;
     }
 
     bool sameConfigs = (this->config() == dstConfig);
     switch (dstConfig) {
         case kA8_Config:
         case kRGB_565_Config:
         case kARGB_8888_Config:
             break;
-        case kA1_Config:
         case kIndex8_Config:
             if (!sameConfigs) {
                 return false;
             }
             break;
         case kARGB_4444_Config:
             return sameConfigs || kARGB_8888_Config == this->config();
         default:
             return false;
     }
-
-    // do not copy src if srcConfig == kA1_Config while dstConfig != kA1_Config
-    if (this->config() == kA1_Config && !sameConfigs) {
-        return false;
-    }
-
     return true;
 }
 
 bool SkBitmap::copyTo(SkBitmap* dst, Config dstConfig, Allocator* alloc) const {
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
 
     // if we have a texture, first get those pixels
     SkBitmap tmpSrc;
@@ skipping 623 matching lines @@
         }
     }
 #endif
 }
 #endif
 
 #ifdef SK_DEVELOPER
 void SkBitmap::toString(SkString* str) const {
 
     static const char* gConfigNames[kConfigCount] = {
-        "NONE", "A1", "A8", "INDEX8", "565", "4444", "8888"
+        "NONE", "A8", "INDEX8", "565", "4444", "8888"
     };
 
     str->appendf("bitmap: ((%d, %d) %s", this->width(), this->height(),
                  gConfigNames[this->config()]);
 
     str->append(" (");
     if (this->isOpaque()) {
         str->append("opaque");
     } else {
         str->append("transparent");
@@ skipping 14 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif