store SkAlphaType inside SkBitmap, on road to support unpremul

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 248 matching lines @@
                 SkIntToScalar(fWidth), SkIntToScalar(fHeight));
 }
 
 void SkBitmap::getBounds(SkIRect* bounds) const {
     SkASSERT(bounds);
     bounds->set(0, 0, fWidth, fHeight);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkBitmap::setConfig(Config c, int width, int height, size_t rowBytes) {
-    this->freePixels();
-
+bool SkBitmap::setConfig(Config config, int width, int height, size_t rowBytes,
+                         SkAlphaType alphaType) {
     if ((width | height) < 0) {
-        goto err;
+        goto ERROR;
     }
-
     if (rowBytes == 0) {
-        rowBytes = SkBitmap::ComputeRowBytes(c, width);
-        if (0 == rowBytes && kNo_Config != c) {
-            goto err;
+        rowBytes = SkBitmap::ComputeRowBytes(config, width);
+        if (0 == rowBytes && kNo_Config != config) {
+            goto ERROR;
         }
     }
 
-    fConfig     = SkToU8(c);
+    // check for legal/supported config+alphaType combinations
+    //
+    switch (config) {
+        case kNo_Config:
+            alphaType = kIgnore_SkAlphaType;    // canonicalize
+            break;
+        case kA1_Config:
+        case kA8_Config:
+            if (kUnpremul_SkAlphaType == alphaType) {
+                alphaType = kPremul_SkAlphaType;
+            }
+            // fall-through
+        case kIndex8_Config:
+        case kARGB_4444_Config:
+        case kARGB_8888_Config:
+            if (kIgnore_SkAlphaType == alphaType) {
+                goto ERROR;   // not supported yet
+            }
+            break;
+        case kRGB_565_Config:
+            alphaType = kOpaque_SkAlphaType;    // canonicalize
+            break;
+    }
+
+    this->freePixels();
+
+    fConfig     = SkToU8(config);
+    fAlphaType  = SkToU8(alphaType);
     fWidth      = width;
     fHeight     = height;
     fRowBytes   = SkToU32(rowBytes);
 
-    fBytesPerPixel = (uint8_t)ComputeBytesPerPixel(c);
+    fBytesPerPixel = (uint8_t)ComputeBytesPerPixel(config);
 
     SkDEBUGCODE(this->validate();)
-    return;
+    return true;
 
     // if we got here, we had an error, so we reset the bitmap to empty
-err:
+ERROR:
     this->reset();
+    return false;
+}
+
+void SkBitmap::setAlphaType(SkAlphaType alphaType) {
+    // check for legal/supported config+alphaType combinations
+    //
+    switch (this->config()) {
+        case kNo_Config:
+            alphaType = kIgnore_SkAlphaType;    // canonicalize
+            break;
+        case kA1_Config:
+        case kA8_Config:
+            if (kUnpremul_SkAlphaType == alphaType) {
+                alphaType = kPremul_SkAlphaType;
+            }
+            // fall-through
+        case kIndex8_Config:
+        case kARGB_4444_Config:
+        case kARGB_8888_Config:
+            if (kIgnore_SkAlphaType == alphaType) {
+                SkDEBUGFAIL("bad alphaType for existing config");
+                return;
+            }
+            break;
+        case kRGB_565_Config:
+            alphaType = kOpaque_SkAlphaType;    // canonicalize
+            break;
+    }
+    
+    fAlphaType = SkToU8(alphaType);
 }
 
 void SkBitmap::updatePixelsFromRef() const {
     if (NULL != fPixelRef) {
         if (fPixelLockCount > 0) {
             SkASSERT(fPixelRef->isLocked());
 
             void* p = fPixelRef->pixels();
             if (NULL != p) {
                 p = (char*)p + fPixelRefOffset;
@@ skipping 212 matching lines @@
 
 void SkBitmap::setImmutable() {
     if (fPixelRef) {
         fPixelRef->setImmutable();
     } else {
         fFlags |= kImageIsImmutable_Flag;
     }
 }
 
 bool SkBitmap::isOpaque() const {
+    return kOpaque_SkAlphaType == fAlphaType ||
+           kIgnore_SkAlphaType == fAlphaType;
+#if 0
     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;
 
@@ skipping 10 matching lines @@
             return (flags & SkColorTable::kColorsAreOpaque_Flag) != 0;
         }
 
         case kRGB_565_Config:
             return true;
 
         default:
             SkDEBUGFAIL("unknown bitmap config pased to isOpaque");
             return false;
     }
+#endif
 }
 
+#if 0
 void SkBitmap::setIsOpaque(bool isOpaque) {
     /*  we record this regardless of fConfig, though it is ignored in
         isOpaque() for configs that can't support per-pixel alpha.
     */
     if (isOpaque) {
         fFlags |= kImageIsOpaque_Flag;
     } else {
         fFlags &= ~kImageIsOpaque_Flag;
     }
 }
+#endif
 
 bool SkBitmap::isVolatile() const {
     return (fFlags & kImageIsVolatile_Flag) != 0;
 }
 
 void SkBitmap::setIsVolatile(bool isVolatile) {
     if (isVolatile) {
         fFlags |= kImageIsVolatile_Flag;
     } else {
         fFlags &= ~kImageIsVolatile_Flag;
@@ skipping 375 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());
+            dst.setConfig(this->config(), subset.width(), subset.height(), 0,
+                          this->isOpaque() ?
+                          kOpaque_SkAlphaType : kPremul_SkAlphaType);
             dst.setIsVolatile(this->isVolatile());
-            dst.setIsOpaque(this->isOpaque());
             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()));
 
     size_t offset = get_sub_offset(*this, r.fLeft, r.fTop);
     if (SUB_OFFSET_FAILURE == offset) {
         return false;   // config not supported
     }
 
     SkBitmap dst;
-    dst.setConfig(this->config(), r.width(), r.height(), this->rowBytes());
+    dst.setConfig(this->config(), r.width(), r.height(), this->rowBytes(),
+                  this->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
     dst.setIsVolatile(this->isVolatile());
-    dst.setIsOpaque(this->isOpaque());
 
     if (fPixelRef) {
         // share the pixelref with a custom offset
         dst.setPixelRef(fPixelRef, fPixelRefOffset + offset);
     }
     SkDEBUGCODE(dst.validate();)
 
     // we know we're good, so commit to result
     result->swap(dst);
     return true;
@@ skipping 129 matching lines @@
             tmpDst.eraseColor(SK_ColorTRANSPARENT);
         }
 
         SkCanvas canvas(tmpDst);
         SkPaint  paint;
 
         paint.setDither(true);
         canvas.drawBitmap(*src, 0, 0, &paint);
     }
 
-    tmpDst.setIsOpaque(src->isOpaque());
+    tmpDst.setAlphaType(src->isOpaque() ?
+                        kOpaque_SkAlphaType : kPremul_SkAlphaType);
 
     dst->swap(tmpDst);
     return true;
 }
 
 bool SkBitmap::deepCopyTo(SkBitmap* dst, Config dstConfig) const {
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
 
@@ skipping 452 matching lines @@
 }
 
 void SkBitmap::unflatten(SkFlattenableReadBuffer& buffer) {
     this->reset();
 
     int width = buffer.readInt();
     int height = buffer.readInt();
     int rowBytes = buffer.readInt();
     int config = buffer.readInt();
 
-    this->setConfig((Config)config, width, height, rowBytes);
-    this->setIsOpaque(buffer.readBool());
+    bool isOpaque = buffer.readBool();
+    this->setConfig((Config)config, width, height, rowBytes,
+                    isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 
     int reftype = buffer.readInt();
     switch (reftype) {
         case SERIALIZE_PIXELTYPE_REF_DATA: {
             size_t offset = buffer.readUInt();
             SkPixelRef* pr = buffer.readFlattenableT<SkPixelRef>();
             SkSafeUnref(this->setPixelRef(pr, offset));
             break;
         }
         case SERIALIZE_PIXELTYPE_NONE:
@@ skipping 76 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif