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 125 matching lines @@
     SkTSwap(fColorTable, other.fColorTable);
     SkTSwap(fPixelRef, other.fPixelRef);
     SkTSwap(fPixelRefOffset, other.fPixelRefOffset);
     SkTSwap(fPixelLockCount, other.fPixelLockCount);
     SkTSwap(fMipMap, other.fMipMap);
     SkTSwap(fPixels, other.fPixels);
     SkTSwap(fRowBytes, other.fRowBytes);
     SkTSwap(fWidth, other.fWidth);
     SkTSwap(fHeight, other.fHeight);
     SkTSwap(fConfig, other.fConfig);
+    SkTSwap(fAlphaType, other.fAlphaType);
     SkTSwap(fFlags, other.fFlags);
     SkTSwap(fBytesPerPixel, other.fBytesPerPixel);
 
     SkDEBUGCODE(this->validate();)
 }
 
 void SkBitmap::reset() {
     this->freePixels();
     sk_bzero(this, sizeof(*this));
 }
@@ skipping 103 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();
+static bool validate_alphaType(SkBitmap::Config config, SkAlphaType alphaType,
+                               SkAlphaType* canonical) {
+    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;

[scroggo, 2014/06/10 20:11:59]

Looking back at this as I write tests for Android. (I know the code has changed
since then, but it's essentially the same with s/Config/ColorType and -A1.)

Why is A8 forced to premul, but only if we asked for unpremul? It appears that
A8 can be any of:

premul
opaque
ignore

A8 is sort of a strange one to have an alphatype, since it is ONLY alpha, but it
seems like it would make sense for it to have one of them all the time.

+            }
+            // 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;
+    }
+    if (canonical) {
+        *canonical = alphaType;
+    }
+    return true;
+}
 
+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);
+    if (!validate_alphaType(config, alphaType, &alphaType)) {
+        goto ERROR;
+    }
+
+    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;
+}
+
+bool SkBitmap::setAlphaType(SkAlphaType alphaType) {
+    if (!validate_alphaType(this->config(), alphaType, &alphaType)) {
+        return false;
+    }
+    fAlphaType = SkToU8(alphaType);
+    return true;
 }
 
 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 211 matching lines @@
 }
 
 void SkBitmap::setImmutable() {
     if (fPixelRef) {
         fPixelRef->setImmutable();
     } else {
         fFlags |= kImageIsImmutable_Flag;
     }
 }
 
-bool SkBitmap::isOpaque() const {
-    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: {
-            bool isOpaque;
-
-            this->lockPixels();
-            isOpaque = fColorTable && fColorTable->isOpaque();
-            this->unlockPixels();
-            return isOpaque;
-        }
-
-        case kRGB_565_Config:
-            return true;
-
-        default:
-            SkDEBUGFAIL("unknown bitmap config pased to isOpaque");
-            return false;
-    }
-}
-
-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;
-    }
-}
-
 bool SkBitmap::isVolatile() const {
     return (fFlags & kImageIsVolatile_Flag) != 0;
 }
 
 void SkBitmap::setIsVolatile(bool isVolatile) {
     if (isVolatile) {
         fFlags |= kImageIsVolatile_Flag;
     } else {
         fFlags &= ~kImageIsVolatile_Flag;
     }
@@ skipping 374 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->alphaType());
             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->alphaType());
     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 68 matching lines @@
         }
     }
 
     // we lock this now, since we may need its colortable
     SkAutoLockPixels srclock(*src);
     if (!src->readyToDraw()) {
         return false;
     }
 
     SkBitmap tmpDst;
-    tmpDst.setConfig(dstConfig, src->width(), src->height());
+    tmpDst.setConfig(dstConfig, src->width(), src->height(), 0,
+                     src->alphaType());
 
     // allocate colortable if srcConfig == kIndex8_Config
     SkColorTable* ctable = (dstConfig == kIndex8_Config) ?
     new SkColorTable(*src->getColorTable()) : NULL;
     SkAutoUnref au(ctable);
     if (!tmpDst.allocPixels(alloc, ctable)) {
         return false;
     }
 
     if (!tmpDst.readyToDraw()) {
@@ skipping 39 matching lines @@
         // TODO: switch the allocation of tmpDst to call sk_calloc_throw
         tmpDst.eraseColor(SK_ColorTRANSPARENT);
 
         SkCanvas canvas(tmpDst);
         SkPaint  paint;
 
         paint.setDither(true);
         canvas.drawBitmap(*src, 0, 0, &paint);
     }
 
-    tmpDst.setIsOpaque(src->isOpaque());
-
     dst->swap(tmpDst);
     return true;
 }
 
 bool SkBitmap::deepCopyTo(SkBitmap* dst, Config dstConfig) const {
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
 
     // If we have a PixelRef, and it supports deep copy, use it.
@@ skipping 427 matching lines @@
 enum {
     SERIALIZE_PIXELTYPE_NONE,
     SERIALIZE_PIXELTYPE_REF_DATA
 };
 
 void SkBitmap::flatten(SkFlattenableWriteBuffer& buffer) const {
     buffer.writeInt(fWidth);
     buffer.writeInt(fHeight);
     buffer.writeInt(fRowBytes);
     buffer.writeInt(fConfig);
-    buffer.writeBool(this->isOpaque());
+    buffer.writeInt(fAlphaType);
 
     if (fPixelRef) {
         if (fPixelRef->getFactory()) {
             buffer.writeInt(SERIALIZE_PIXELTYPE_REF_DATA);
             buffer.writeUInt(SkToU32(fPixelRefOffset));
             buffer.writeFlattenable(fPixelRef);
             return;
         }
         // if we get here, we can't record the pixels
         buffer.writeInt(SERIALIZE_PIXELTYPE_NONE);
     } else {
         buffer.writeInt(SERIALIZE_PIXELTYPE_NONE);
     }
 }
 
 void SkBitmap::unflatten(SkFlattenableReadBuffer& buffer) {
     this->reset();
 
     int width = buffer.readInt();
     int height = buffer.readInt();
     int rowBytes = buffer.readInt();
     int config = buffer.readInt();
+    int alphaType = buffer.readInt();
 
-    this->setConfig((Config)config, width, height, rowBytes);
-    this->setIsOpaque(buffer.readBool());
+    this->setConfig((Config)config, width, height, rowBytes, (SkAlphaType)alphaType);
 
     int reftype = buffer.readInt();
     switch (reftype) {
         case SERIALIZE_PIXELTYPE_REF_DATA: {
             size_t offset = buffer.readUInt();
             SkPixelRef* pr = buffer.readPixelRef();
             SkSafeUnref(this->setPixelRef(pr, offset));
             break;
         }
         case SERIALIZE_PIXELTYPE_NONE:
@@ skipping 75 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif