Add an option to create unpremultiplied bitmaps.

src/images/SkImageDecoder_libpng.cpp

 
 /*
  * Copyright 2006 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 "SkImageDecoder.h"
@@ skipping 62 matching lines @@
 #ifdef SK_BUILD_FOR_ANDROID
     virtual bool onBuildTileIndex(SkStream *stream, int *width, int *height) SK_OVERRIDE;
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& region) SK_OVERRIDE;
 #endif
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
     SkPNGImageIndex* fImageIndex;
 
     bool onDecodeInit(SkStream* stream, png_structp *png_ptrp, png_infop *info_ptrp);
-    bool decodePalette(png_structp png_ptr, png_infop info_ptr, bool *hasAlphap,
+    bool decodePalette(png_structp png_ptr, png_infop info_ptr,
+                       SkBitmap::Config finalConfig, bool *hasAlphap,
                        bool *reallyHasAlphap, SkColorTable **colorTablep);
     bool getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
                          SkBitmap::Config *config, bool *hasAlpha,
                          bool *doDither, SkPMColor *theTranspColor);
 
     typedef SkImageDecoder INHERITED;
 };
 
 #ifndef png_jmpbuf
 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
@@ skipping 209 matching lines @@
     void* rowptr = (void*) decodedBitmap->getPixels();
     bool reuseBitmap = (rowptr != NULL);
     decodedBitmap->unlockPixels();
     if (reuseBitmap && (sampler.scaledWidth() != decodedBitmap->width() ||
                         sampler.scaledHeight() != decodedBitmap->height())) {
         // Dimensions must match
         return false;
     }
 
     if (!reuseBitmap) {
+        bool premul = true;
+        if (SkBitmap::kARGB_8888_Config == config && this->getRequestUnpremultipliedColors()) {
+            premul = false;
+        }
         decodedBitmap->setConfig(config, sampler.scaledWidth(),
-                                 sampler.scaledHeight(), 0);
+                                 sampler.scaledHeight(), 0, premul);
     }
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
 
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
     // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we
     // draw lots faster if we can flag the bitmap has being opaque
     bool reallyHasAlpha = false;
     SkColorTable* colorTable = NULL;
 
     if (colorType == PNG_COLOR_TYPE_PALETTE) {
-        decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable);
+        decodePalette(png_ptr, info_ptr, config, &hasAlpha, &reallyHasAlpha, &colorTable);
     }
 
     SkAutoUnref aur(colorTable);
 
     if (!reuseBitmap) {
         if (!this->allocPixelRef(decodedBitmap,
                                  SkBitmap::kIndex8_Config == config ? colorTable : NULL)) {
             return false;
         }
     }
@@ skipping 202 matching lines @@
         }
         // now check that if we are 4-bytes per pixel, we also don't overflow
         if (size.get32() > (0x7FFFFFFF >> 2)) {
             return false;
         }
     }
 
     return this->chooseFromOneChoice(*configp, origWidth, origHeight);
 }
 
+typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
+
 bool SkPNGImageDecoder::decodePalette(png_structp png_ptr, png_infop info_ptr,
-                                      bool *hasAlphap, bool *reallyHasAlphap,
-                                      SkColorTable **colorTablep) {
+                                      SkBitmap::Config finalConfig, bool *hasAlphap,
+                                      bool *reallyHasAlphap, SkColorTable **colorTablep) {
     int numPalette;
     png_colorp palette;
     png_bytep trans;
     int numTrans;
     bool reallyHasAlpha = false;
     SkColorTable* colorTable = NULL;
 
     png_get_PLTE(png_ptr, info_ptr, &palette, &numPalette);
 
     /*  BUGGY IMAGE WORKAROUND
@@ skipping 15 matching lines @@
         colorTable->setFlags(colorTable->getFlags() | SkColorTable::kColorsAreOpaque_Flag);
     }
     // check for bad images that might make us crash
     if (numTrans > numPalette) {
         numTrans = numPalette;
     }
 
     int index = 0;
     int transLessThanFF = 0;
 
+    // Choose which function to use to create the color table. If the final destination's
+    // config is unpremultiplied, the color table will store unpremultiplied colors.
+    PackColorProc proc;
+    if (SkBitmap::kARGB_8888_Config == finalConfig && this->getRequestUnpremultipliedColors()) {
+        proc = &SkPackARGB32NoCheck;
+    } else {
+        proc = &SkPreMultiplyARGB;
+    }
     for (; index < numTrans; index++) {
         transLessThanFF |= (int)*trans - 0xFF;
-        *colorPtr++ = SkPreMultiplyARGB(*trans++, palette->red, palette->green, palette->blue);
+        *colorPtr++ = proc(*trans++, palette->red, palette->green, palette->blue);
         palette++;
     }
     reallyHasAlpha |= (transLessThanFF < 0);
 
     for (; index < numPalette; index++) {
         *colorPtr++ = SkPackARGB32(0xFF, palette->red, palette->green, palette->blue);
         palette++;
     }
 
     // see BUGGY IMAGE WORKAROUND comment above
@@ skipping 69 matching lines @@
     SkPMColor           theTranspColor = 0; // 0 tells us not to try to match
 
     if (!getBitmapConfig(png_ptr, info_ptr, &config, &hasAlpha, &doDither, &theTranspColor)) {
         return false;
     }
 
     const int sampleSize = this->getSampleSize();
     SkScaledBitmapSampler sampler(origWidth, rect.height(), sampleSize);
 
     SkBitmap decodedBitmap;
-    decodedBitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0);
+    bool premul = true;
+    if (SkBitmap::kARGB_8888_Config == config && this->getRequestUnpremultipliedColors()) {
+        premul = false;
+    }
+    decodedBitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0, premul);
 
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
     // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we
     // draw lots faster if we can flag the bitmap has being opaque
     bool reallyHasAlpha = false;
     SkColorTable* colorTable = NULL;
 
     if (colorType == PNG_COLOR_TYPE_PALETTE) {
-        decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable);
+        decodePalette(png_ptr, info_ptr, config, &hasAlpha, &reallyHasAlpha, &colorTable);
     }
 
     SkAutoUnref aur(colorTable);
 
     // Check ahead of time if the swap(dest, src) is possible.
     // If yes, then we will stick to AllocPixelRef since it's cheaper with the swap happening.
     // If no, then we will use alloc to allocate pixels to prevent garbage collection.
     int w = rect.width() / sampleSize;
     int h = rect.height() / sampleSize;
     const bool swapOnly = (rect == region) && (w == decodedBitmap.width()) &&
@@ skipping 433 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? SkNEW(SkPNGImageEncoder) : NULL;
 }
 
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_libpng_efactory);
 static SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_png);
 static SkTRegistry<SkImageDecoder*, SkStream*> gDReg(sk_libpng_dfactory);