Add an option to create unpremultiplied bitmaps.

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 250 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) {
+void SkBitmap::setConfig(Config c, int width, int height, size_t rowBytes,
+                         bool premul) {
     this->freePixels();
 
     if ((width | height) < 0) {
         goto err;
     }
 
     if (rowBytes == 0) {
         rowBytes = SkBitmap::ComputeRowBytes(c, width);
         if (0 == rowBytes && kNo_Config != c) {
             goto err;
         }
     }
 
     fConfig     = SkToU8(c);
     fWidth      = width;
     fHeight     = height;
     fRowBytes   = SkToU32(rowBytes);
+    if (premul) {
+        fFlags &= ~kColorsAreNotPremultiplied_Flag;
+    } else {
+        if (c != kARGB_8888_Config) {
+            goto err;
+        }
+        fFlags |= kColorsAreNotPremultiplied_Flag;
+    }
 
     fBytesPerPixel = (uint8_t)ComputeBytesPerPixel(c);
 
     SkDEBUGCODE(this->validate();)
     return;
 
     // if we got here, we had an error, so we reset the bitmap to empty
 err:
     this->reset();
 }
@@ skipping 345 matching lines @@
         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]);
+            if (this->premultiplied()) {
+                uint32_t* addr = this->getAddr32(x, y);
+                return SkUnPreMultiply::PMColorToColor(addr[0]);
+            } else {
+                SkUnPMColor* addr = this->getAddr32(x, y);
+                SkUnPMColor c = *addr;
+                U8CPU a = SkGetPackedA32(c);
+                U8CPU r = SkGetPackedR32(c);
+                U8CPU g = SkGetPackedG32(c);
+                U8CPU b = SkGetPackedB32(c);
+                return SkColorSetARGB(a, r, g, b);
+            }
         }
         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:
         case kConfigCount:
@@ skipping 95 matching lines @@
     if (!this->readyToDraw()) {
         return;
     }
 
     int height = fHeight;
     const int width = fWidth;
     const int rowBytes = fRowBytes;
 
     // make rgb premultiplied
     if (255 != a) {
+        // Unpremultiplied exits above at readyToDraw.
+        SkASSERT(this->premultiplied());
         r = SkAlphaMul(r, a);
         g = SkAlphaMul(g, a);
         b = SkAlphaMul(b, a);
     }
 
     switch (fConfig) {
         case kA1_Config: {
             uint8_t* p = (uint8_t*)fPixels;
             const int count = (width + 7) >> 3;
             a = (a >> 7) ? 0xFF : 0;
@@ skipping 140 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->premultiplied());
             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;
 
+        // kRLE_Index8_Config is not compatible with unpremultiplied.
+        SkASSERT(this->premultiplied());
         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();
@@ skipping 10 matching lines @@
     // 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->premultiplied());
     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
@@ skipping 26 matching lines @@
             break;
         default:
             return false;
     }
 
     // do not copy src if srcConfig == kA1_Config while dstConfig != kA1_Config
     if (this->getConfig() == kA1_Config && !sameConfigs) {
         return false;
     }
 
+    if (!this->premultiplied()) {
+        // Cannot copy unpremultiplied, which returns false for readyToDraw.
+        SkASSERT(kARGB_8888_Config == this->config());
+        return false;
+    }
+
     return true;
 }
 
 bool SkBitmap::copyTo(SkBitmap* dst, Config dstConfig, Allocator* alloc) const {
     if (!this->canCopyTo(dstConfig)) {
         return false;
     }
+    // Cannot copy an unpremultiplied bitmap.
+    // canCopyTo should have returned false.
+    SkASSERT(this->premultiplied());
 
     // if we have a texture, first get those pixels
     SkBitmap tmpSrc;
     const SkBitmap* src = this;
 
     if (fPixelRef) {
         SkIRect subset;
         if (get_upper_left_from_offset(*this, &subset.fLeft, &subset.fTop)) {
             subset.fRight = subset.fLeft + fWidth;
             subset.fBottom = subset.fTop + fHeight;
@@ skipping 513 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);
+#ifdef BUMP_PICTURE_VERSION
+    // FIXME: Storing whether the colors are premultiplied
+    // should be written to the stream, but breaks picture
+    // serialization without changing PICTURE_VERSION
+    buffer.writeBool(this->premultiplied());
+#endif
     buffer.writeBool(this->isOpaque());
 
     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();
+#ifdef BUMP_PICTURE_VERSION
+    bool premul = buffer.readBool();
+#else
+    bool premul = true;
+#endif
 
-    this->setConfig((Config)config, width, height, rowBytes);
+    this->setConfig((Config)config, width, height, rowBytes, premul);
     this->setIsOpaque(buffer.readBool());
 
     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;
         }
@@ skipping 16 matching lines @@
 SkBitmap::RLEPixels::~RLEPixels() {
     sk_free(fYPtrs);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG
 void SkBitmap::validate() const {
     SkASSERT(fConfig < kConfigCount);
     SkASSERT(fRowBytes >= (unsigned)ComputeRowBytes((Config)fConfig, fWidth));
-    SkASSERT(fFlags <= (kImageIsOpaque_Flag | kImageIsVolatile_Flag | kImageIsImmutable_Flag));
+    int8_t allFlags = kImageIsOpaque_Flag | kImageIsVolatile_Flag | kImageIsImmutable_Flag
+                      | kColorsAreNotPremultiplied_Flag;
+#ifdef SK_BUILD_FOR_ANDROID
+    allFlags |= kHasHardwareMipMap_Flag;
+#endif
+    SkASSERT(fFlags <= allFlags);
     SkASSERT(fPixelLockCount >= 0);
     SkASSERT(NULL == fColorTable || (unsigned)fColorTable->getRefCnt() < 10000);
     SkASSERT((uint8_t)ComputeBytesPerPixel((Config)fConfig) == fBytesPerPixel);
 
 #if 0   // these asserts are not thread-correct, so disable for now
     if (fPixelRef) {
         if (fPixelLockCount > 0) {
             SkASSERT(fPixelRef->isLocked());
         } else {
             SkASSERT(NULL == fPixels);
@@ skipping 36 matching lines @@
         if (NULL != uri) {
             str->appendf(" uri:\"%s\"", uri);
         } else {
             str->appendf(" pixelref:%p", pr);
         }
     }
 
     str->append(")");
 }
 #endif