Add an option to create unpremultiplied bitmaps.

src/images/SkImageDecoder_libwebp.cpp

 /*
  * Copyright 2010, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
@@ skipping 96 matching lines @@
     virtual Format getFormat() const SK_OVERRIDE {
         return kWEBP_Format;
     }
 
 protected:
     virtual bool onBuildTileIndex(SkStream *stream, int *width, int *height) SK_OVERRIDE;
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) SK_OVERRIDE;
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
+    /**
+     *  Called when determining the output config to request to webp.
+     *  If the image does not have alpha, there is no need to premultiply.
+     *  If the caller wants unpremultiplied colors, that is respected.
+     */
+    bool shouldPremultiply() const {
+        return SkToBool(fHasAlpha) && !this->getRequireUnpremultipliedColors();
+    }
+
     bool setDecodeConfig(SkBitmap* decodedBitmap, int width, int height);
+
     SkStream* fInputStream;
     int fOrigWidth;
     int fOrigHeight;
     int fHasAlpha;
 
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
@@ skipping 22 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // This guy exists just to aid in debugging, as it allows debuggers to just
 // set a break-point in one place to see all error exists.
 static bool return_false(const SkBitmap& bm, const char msg[]) {
     SkDEBUGF(("libwebp error %s [%d %d]", msg, bm.width(), bm.height()));
     return false; // must always return false
 }
 
-static WEBP_CSP_MODE webp_decode_mode(const SkBitmap* decodedBitmap, int hasAlpha) {
+static WEBP_CSP_MODE webp_decode_mode(const SkBitmap* decodedBitmap, bool premultiply) {
     WEBP_CSP_MODE mode = MODE_LAST;
     SkBitmap::Config config = decodedBitmap->config();
-    // For images that have alpha, choose appropriate color mode (MODE_rgbA,
-    // MODE_rgbA_4444) that pre-multiplies RGB pixel values with transparency
-    // factor (alpha).
+
     if (config == SkBitmap::kARGB_8888_Config) {
-      mode = hasAlpha ? MODE_rgbA : MODE_RGBA;
+        mode = premultiply ? MODE_rgbA : MODE_RGBA;
     } else if (config == SkBitmap::kARGB_4444_Config) {
-      mode = hasAlpha ? MODE_rgbA_4444 : MODE_RGBA_4444;
+        mode = premultiply ? MODE_rgbA_4444 : MODE_RGBA_4444;
     } else if (config == SkBitmap::kRGB_565_Config) {
-      mode = MODE_RGB_565;
+        mode = MODE_RGB_565;
     }
     SkASSERT(MODE_LAST != mode);
     return mode;
 }
 
 // Incremental WebP image decoding. Reads input buffer of 64K size iteratively
 // and decodes this block to appropriate color-space as per config object.
 static bool webp_idecode(SkStream* stream, WebPDecoderConfig* config) {
     WebPIDecoder* idec = WebPIDecode(NULL, 0, config);
     if (NULL == idec) {
@@ skipping 35 matching lines @@
 
     if (bytesRemaining > 0) {
         return false;
     } else {
         return true;
     }
 }
 
 static bool webp_get_config_resize(WebPDecoderConfig* config,
                                    SkBitmap* decodedBitmap,
-                                   int width, int height, int hasAlpha) {
-    WEBP_CSP_MODE mode = webp_decode_mode(decodedBitmap, hasAlpha);
+                                   int width, int height, bool premultiply) {
+    WEBP_CSP_MODE mode = webp_decode_mode(decodedBitmap, premultiply);
     if (MODE_LAST == mode) {
         return false;
     }
 
     if (0 == WebPInitDecoderConfig(config)) {
         return false;
     }
 
     config->output.colorspace = mode;
     config->output.u.RGBA.rgba = (uint8_t*)decodedBitmap->getPixels();
     config->output.u.RGBA.stride = decodedBitmap->rowBytes();
     config->output.u.RGBA.size = decodedBitmap->getSize();
     config->output.is_external_memory = 1;
 
     if (width != decodedBitmap->width() || height != decodedBitmap->height()) {
         config->options.use_scaling = 1;
         config->options.scaled_width = decodedBitmap->width();
         config->options.scaled_height = decodedBitmap->height();
     }
 
     return true;
 }
 
 static bool webp_get_config_resize_crop(WebPDecoderConfig* config,
                                         SkBitmap* decodedBitmap,
-                                        const SkIRect& region, int hasAlpha) {
+                                        const SkIRect& region, bool premultiply) {
 
     if (!webp_get_config_resize(config, decodedBitmap, region.width(),
-                                region.height(), hasAlpha)) {
+                                region.height(), premultiply)) {
       return false;
     }
 
     config->options.use_cropping = 1;
     config->options.crop_left = region.fLeft;
     config->options.crop_top = region.fTop;
     config->options.crop_width = region.width();
     config->options.crop_height = region.height();
 
     return true;
@@ skipping 97 matching lines @@
     } else {
         // This is also called in setDecodeConfig in above block.
         // i.e., when bitmap->isNull() is true.
         if (!chooseFromOneChoice(bitmap->config(), width, height)) {
             return false;
         }
     }
 
     SkAutoLockPixels alp(*bitmap);
     WebPDecoderConfig config;
-    if (!webp_get_config_resize_crop(&config, bitmap, rect, fHasAlpha)) {
+    if (!webp_get_config_resize_crop(&config, bitmap, rect,
+                                     this->shouldPremultiply())) {
         return false;
     }
 
     // Decode the WebP image data stream using WebP incremental decoding for
     // the specified cropped image-region.
     if (!webp_idecode(this->fInputStream, &config)) {
         return false;
     }
 
     if (!directDecode) {
@@ skipping 37 matching lines @@
     }
 
     if (!this->allocPixelRef(decodedBitmap, NULL)) {
         return return_false(*decodedBitmap, "allocPixelRef");
     }
 
     SkAutoLockPixels alp(*decodedBitmap);
 
     WebPDecoderConfig config;
     if (!webp_get_config_resize(&config, decodedBitmap, origWidth, origHeight,
-                                hasAlpha)) {
+                                this->shouldPremultiply())) {
         return false;
     }
 
     // Decode the WebP image data stream using WebP incremental decoding.
     return webp_idecode(stream, &config);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 typedef void (*ScanlineImporter)(const uint8_t* in, uint8_t* out, int width,
@@ skipping 149 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libwebp_efactory(SkImageEncoder::Type t) {
       return (SkImageEncoder::kWEBP_Type == t) ? SkNEW(SkWEBPImageEncoder) : NULL;
 }
 
 static SkTRegistry<SkImageDecoder*, SkStream*> gDReg(sk_libwebp_dfactory);
 static SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_webp);
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_libwebp_efactory);