replace config() with colorType()

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 630 matching lines @@
                 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::kA8_Config: {
+    switch (this->colorType()) {
+        case kAlpha_8_SkColorType: {
             uint8_t* addr = this->getAddr8(x, y);
             return SkColorSetA(0, addr[0]);
         }
-        case SkBitmap::kIndex8_Config: {
+        case kIndex_8_SkColorType: {
             SkPMColor c = this->getIndex8Color(x, y);
             return SkUnPreMultiply::PMColorToColor(c);
         }
-        case SkBitmap::kRGB_565_Config: {
+        case kRGB_565_SkColorType: {
             uint16_t* addr = this->getAddr16(x, y);
             return SkPixel16ToColor(addr[0]);
         }
-        case SkBitmap::kARGB_4444_Config: {
+        case kARGB_4444_SkColorType: {
             uint16_t* addr = this->getAddr16(x, y);
             SkPMColor c = SkPixel4444ToPixel32(addr[0]);
             return SkUnPreMultiply::PMColorToColor(c);
         }
-        case SkBitmap::kARGB_8888_Config: {
+        case kBGRA_8888_SkColorType:
+        case kRGBA_8888_SkColorType: {
             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::kA8_Config: {
+    switch (bm.colorType()) {
+        case kAlpha_8_SkColorType: {
             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;
                 }
             }
             return true;
         } break;
-        case SkBitmap::kIndex8_Config: {
+        case kIndex_8_SkColorType: {
             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];
             }
             return 0xFF == SkGetPackedA32(c);
         } break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             return true;
             break;
-        case SkBitmap::kARGB_4444_Config: {
+        case kARGB_4444_SkColorType: {
             unsigned c = 0xFFFF;
             for (int y = 0; y < height; ++y) {
                 const SkPMColor16* row = bm.getAddr16(0, y);
                 for (int x = 0; x < width; ++x) {
                     c &= row[x];
                 }
                 if (0xF != SkGetPackedA4444(c)) {
                     return false;
                 }
             }
             return true;
         } break;
-        case SkBitmap::kARGB_8888_Config: {
+        case kBGRA_8888_SkColorType:
+        case kRGBA_8888_SkColorType: {
             SkPMColor c = (SkPMColor)~0;
             for (int y = 0; y < height; ++y) {
                 const SkPMColor* row = bm.getAddr32(0, y);
                 for (int x = 0; x < width; ++x) {
                     c &= row[x];
                 }
                 if (0xFF != SkGetPackedA32(c)) {
                     return false;
                 }
             }
@@ skipping 134 matching lines @@
     srcRect.set(0, 0, this->width(), this->height());
     if (!r.intersect(srcRect, subset)) {
         return false;   // r is empty (i.e. no intersection)
     }
 
     if (fPixelRef->getTexture() != NULL) {
         // Do a deep copy
         SkPixelRef* pixelRef = fPixelRef->deepCopy(this->config(), &subset);
         if (pixelRef != NULL) {
             SkBitmap dst;
-            dst.setConfig(this->config(), subset.width(), subset.height(), 0,
-                          this->alphaType());
+            dst.setConfig(SkImageInfo::Make(subset.width(), subset.height(),
+                                            this->colorType(), this->alphaType()));
             dst.setIsVolatile(this->isVolatile());
             dst.setPixelRef(pixelRef)->unref();
             SkDEBUGCODE(dst.validate());
             result->swap(dst);
             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()));
 
     SkBitmap dst;
-    dst.setConfig(this->config(), r.width(), r.height(), this->rowBytes(),
-                  this->alphaType());
+    dst.setConfig(SkImageInfo::Make(r.width(), r.height(), this->colorType(), this->alphaType()),
+                  this->rowBytes());
     dst.setIsVolatile(this->isVolatile());
 
     if (fPixelRef) {
         SkIPoint origin = fPixelRefOrigin;
         origin.fX += r.fLeft;
         origin.fY += r.fTop;
         // share the pixelref with a custom offset
         dst.setPixelRef(fPixelRef, origin);
     }
     SkDEBUGCODE(dst.validate();)
@@ skipping 208 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 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();
+    SkColorType colorType = src.colorType();
+    int         w = src.width();
+    int         h = src.height();
+    size_t      rb = src.rowBytes();
 
     SkAutoLockPixels alp(src);
     if (!src.readyToDraw()) {
         // zero out the alpha buffer and return
         while (--h >= 0) {
             memset(alpha, 0, w);
             alpha += alphaRowBytes;
         }
         return false;
     }
 
-    if (SkBitmap::kA8_Config == config && !src.isOpaque()) {
+    if (kAlpha_8_SkColorType == colorType && !src.isOpaque()) {
         const uint8_t* s = src.getAddr8(0, 0);
         while (--h >= 0) {
             memcpy(alpha, s, w);
             s += rb;
             alpha += alphaRowBytes;
         }
-    } else if (SkBitmap::kARGB_8888_Config == config && !src.isOpaque()) {
+    } else if (kN32_SkColorType == colorType && !src.isOpaque()) {
         const SkPMColor* SK_RESTRICT s = src.getAddr32(0, 0);
         while (--h >= 0) {
             for (int x = 0; x < w; x++) {
                 alpha[x] = SkGetPackedA32(s[x]);
             }
             s = (const SkPMColor*)((const char*)s + rb);
             alpha += alphaRowBytes;
         }
-    } else if (SkBitmap::kARGB_4444_Config == config && !src.isOpaque()) {
+    } else if (kARGB_4444_SkColorType == colorType && !src.isOpaque()) {
         const SkPMColor16* SK_RESTRICT s = src.getAddr16(0, 0);
         while (--h >= 0) {
             for (int x = 0; x < w; x++) {
                 alpha[x] = SkPacked4444ToA32(s[x]);
             }
             s = (const SkPMColor16*)((const char*)s + rb);
             alpha += alphaRowBytes;
         }
-    } else if (SkBitmap::kIndex8_Config == config && !src.isOpaque()) {
+    } else if (kIndex_8_SkColorType == colorType && !src.isOpaque()) {
         SkColorTable* ct = src.getColorTable();
         if (ct) {
             const SkPMColor* SK_RESTRICT table = ct->lockColors();
             const uint8_t* SK_RESTRICT s = src.getAddr8(0, 0);
             while (--h >= 0) {
                 for (int x = 0; x < w; x++) {
                     alpha[x] = SkGetPackedA32(table[s[x]]);
                 }
                 s += rb;
                 alpha += alphaRowBytes;
@@ skipping 27 matching lines @@
     // compute our (larger?) dst bounds if we have a filter
     if (NULL != filter) {
         identity.reset();
         srcM.fImage = NULL;
         if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
             goto NO_FILTER_CASE;
         }
         dstM.fRowBytes = SkAlign4(dstM.fBounds.width());
     } else {
     NO_FILTER_CASE:
-        tmpBitmap.setConfig(SkBitmap::kA8_Config, this->width(), this->height(),
-                       srcM.fRowBytes);
+        tmpBitmap.setConfig(SkImageInfo::MakeA8(this->width(), this->height()), srcM.fRowBytes);
         if (!tmpBitmap.allocPixels(allocator, NULL)) {
             // Allocation of pixels for alpha bitmap failed.
             SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                     tmpBitmap.width(), tmpBitmap.height());
             return false;
         }
         GetBitmapAlpha(*this, tmpBitmap.getAddr8(0, 0), srcM.fRowBytes);
         if (offset) {
             offset->set(0, 0);
         }
         tmpBitmap.swap(*dst);
         return true;
     }
     srcM.fImage = SkMask::AllocImage(srcM.computeImageSize());
     SkAutoMaskFreeImage srcCleanup(srcM.fImage);
 
     GetBitmapAlpha(*this, srcM.fImage, srcM.fRowBytes);
     if (!filter->filterMask(&dstM, srcM, identity, NULL)) {
         goto NO_FILTER_CASE;
     }
     SkAutoMaskFreeImage dstCleanup(dstM.fImage);
 
-    tmpBitmap.setConfig(SkBitmap::kA8_Config, dstM.fBounds.width(),
-                   dstM.fBounds.height(), dstM.fRowBytes);
+    tmpBitmap.setConfig(SkImageInfo::MakeA8(dstM.fBounds.width(), dstM.fBounds.height()),
+                        dstM.fRowBytes);
     if (!tmpBitmap.allocPixels(allocator, NULL)) {
         // Allocation of pixels for alpha bitmap failed.
         SkDebugf("extractAlpha failed to allocate (%d,%d) alpha bitmap\n",
                 tmpBitmap.width(), tmpBitmap.height());
         return false;
     }
     memcpy(tmpBitmap.getPixels(), dstM.fImage, dstM.computeImageSize());
     if (offset) {
         offset->set(dstM.fBounds.fLeft, dstM.fBounds.fTop);
     }
@@ skipping 172 matching lines @@
         SkASSERT(fPixelRef->rowBytes() >= fInfo.minRowBytes());
     } else {
         SkASSERT(NULL == fColorTable);
     }
 }
 #endif
 
 #ifndef SK_IGNORE_TO_STRING
 void SkBitmap::toString(SkString* str) const {
 
-    static const char* gConfigNames[kConfigCount] = {
-        "NONE", "A8", "INDEX8", "565", "4444", "8888"
+    static const char* gColorTypeNames[kLastEnum_SkColorType + 1] = {
+        "UNKNOWN", "A8", "565", "4444", "RGBA", "BGRA", "INDEX8",
     };
 
     str->appendf("bitmap: ((%d, %d) %s", this->width(), this->height(),
-                 gConfigNames[this->config()]);
+                 gColorTypeNames[this->colorType()]);
 
     str->append(" (");
     if (this->isOpaque()) {
         str->append("opaque");
     } else {
         str->append("transparent");
     }
     if (this->isImmutable()) {
         str->append(", immutable");
     } else {
@@ skipping 21 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkImageInfo::validate() const {
     SkASSERT(fWidth >= 0);
     SkASSERT(fHeight >= 0);
     SkASSERT(SkColorTypeIsValid(fColorType));
     SkASSERT(SkAlphaTypeIsValid(fAlphaType));
 }
 #endif