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 *reallyHasAlphap, SkColorTable **colorTablep);
+    bool decodePalette(png_structp png_ptr, png_infop info_ptr,
+                       bool * SK_RESTRICT 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)
 #endif
@@ skipping 209 matching lines @@
     bool reuseBitmap = (rowptr != NULL);
     decodedBitmap->unlockPixels();
     if (reuseBitmap && (sampler.scaledWidth() != decodedBitmap->width() ||
                         sampler.scaledHeight() != decodedBitmap->height())) {
         // Dimensions must match
         return false;
     }
 
     if (!reuseBitmap) {
         decodedBitmap->setConfig(config, sampler.scaledWidth(),
-                                 sampler.scaledHeight(), 0);
+                                 sampler.scaledHeight());
     }
     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
@@ skipping 103 matching lines @@
             skip_src_rows(png_ptr, srcRow, origHeight - read);
         }
     }
 
     /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
     png_read_end(png_ptr, info_ptr);
 
     if (0 != theTranspColor) {
         reallyHasAlpha |= substituteTranspColor(decodedBitmap, theTranspColor);
     }
+    if (reallyHasAlpha && this->getRequireUnpremultipliedColors() &&
+        SkBitmap::kARGB_8888_Config != decodedBitmap->config()) {
+        // If the caller wants an unpremultiplied bitmap, and we let them get
+        // away with a config other than 8888, and it has alpha after all,
+        // return false, since the result will have premultiplied colors.
+        return false;
+    }
     decodedBitmap->setIsOpaque(!reallyHasAlpha);
     if (reuseBitmap) {
         decodedBitmap->notifyPixelsChanged();
     }
     return true;
 }
 
 
 
 bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
-                                        SkBitmap::Config *configp, bool *hasAlphap,
+                                        SkBitmap::Config *configp, bool * SK_RESTRICT hasAlphap,
                                         bool *doDitherp, SkPMColor *theTranspColorp) {
     png_uint_32 origWidth, origHeight;
     int bitDepth, colorType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
                  &colorType, int_p_NULL, int_p_NULL, int_p_NULL);
 
     // check for sBIT chunk data, in case we should disable dithering because
     // our data is not truely 8bits per component
     png_color_8p sig_bit;
     if (*doDitherp && png_get_sBIT(png_ptr, info_ptr, &sig_bit)) {
@@ skipping 80 matching lines @@
         size.setMul(origWidth, origHeight);
         if (size.isNeg() || !size.is32()) {
             return false;
         }
         // 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);
+    if (!this->chooseFromOneChoice(*configp, origWidth, origHeight)) {
+        return false;
+    }
+
+    // If the image has alpha and the decoder wants unpremultiplied
+    // colors, the only supported config is 8888.
+    if (this->getRequireUnpremultipliedColors() && *hasAlphap) {
+        *configp = SkBitmap::kARGB_8888_Config;
+    }
+    return true;
 }
 
+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) {
     int numPalette;
     png_colorp palette;
     png_bytep trans;
     int numTrans;
     bool reallyHasAlpha = false;
     SkColorTable* colorTable = NULL;
 
@@ skipping 18 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 (this->getRequireUnpremultipliedColors()) {
+        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);

[reed1, 2013/06/13 13:51:39]

Is there a measurable perf-hit with this change (from an inlineable function to
a function-ptr? 

[scroggo, 2013/06/13 19:04:49]

We don't actually use an inlineable function (though SkPreMultiplyARGB calls an
inlineable function).

I added a benchmark in the next patch. It did not show a consistently
substantial difference among what's checked in, this change, or inlining:

old: what's checked in; new: this CL:
scroggo@scroggo-linux2:/usr/local/google/skia/trunk$ python
bench/bench_compare.py -o master.txt -n unpremul.txt 
     image_decode_hal_163x90.png 8888    c        234.07     257.81     -23.74  
-10.1% 
     image_decode_hal_163x90.png GPU     c        229.48     229.75      -0.27  
 -0.1% 
image_decode_box_19_top-left.png GPU     g          0.02       0.02      +0.00  
 +0.0% 
     image_decode_hal_163x90.png GPU     g          0.02       0.02      +0.00  
 +0.0% 
     image_decode_hal_163x90.png 565     c        230.64     230.11      +0.53  
 +0.2% 
     image_decode_hal_163x90.png NULLGPU c        231.38     230.36      +1.02  
 +0.4% 
image_decode_box_19_top-left.png GPU     c          7.74       7.68      +0.06  
 +0.8% 
image_decode_box_19_top-left.png NULLGPU c          7.86       7.77      +0.09  
 +1.1% 
image_decode_box_19_top-left.png 8888    c          7.85       7.64      +0.21  
 +2.7% 
image_decode_box_19_top-left.png 565     c          7.80       7.57      +0.23  
 +2.9% 

old: inline; new: this CL:
scroggo@scroggo-linux2:/usr/local/google/skia/trunk$ python
bench/bench_compare.py -o withInline.txt -n unpremul.txt 
     image_decode_hal_163x90.png 8888    c        240.63     257.81     -17.18  
 -7.1% 
image_decode_box_19_top-left.png NULLGPU c          7.73       7.77      -0.04  
 -0.5% 
image_decode_box_19_top-left.png 8888    c          7.62       7.64      -0.02  
 -0.3% 
image_decode_box_19_top-left.png GPU     g          0.02       0.02      +0.00  
 +0.0% 
     image_decode_hal_163x90.png GPU     g          0.02       0.02      +0.00  
 +0.0% 
     image_decode_hal_163x90.png GPU     c        230.31     229.75      +0.56  
 +0.2% 
image_decode_box_19_top-left.png 565     c          7.60       7.57      +0.03  
 +0.4% 
     image_decode_hal_163x90.png 565     c        234.79     230.11      +4.68  
 +2.0% 
image_decode_box_19_top-left.png GPU     c          7.92       7.68      +0.24  
 +3.0% 
     image_decode_hal_163x90.png NULLGPU c        244.67     230.36     +14.31  
 +5.8% 


I ran the benchmark on the only files I have locally that follow this path, but
I could try more. Note that all the configs should be the same since the test
does not do any drawing (the following patch sets fIsRendering to false), so the
variance in configs is just showing noise.

         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);
+    decodedBitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
 
     // 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);