Add an option to create unpremultiplied bitmaps.

include/core/SkBitmap.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkBitmap_DEFINED
@@ skipping 86 matching lines @@
         dimensions of the bitmap are > 0 (see empty()).
     */
     bool isNull() const { return NULL == fPixelRef; }
 
     /** Return the config for the bitmap.
     */
     Config  config() const { return (Config)fConfig; }
     /** DEPRECATED, use config()
     */
     Config  getConfig() const { return this->config(); }
+
+    /** Whether the colors are stored premultiplied. If the bitmap is opaque,
+        the return value is undefined.
+    */
+    bool premultiplied() const { return 0 == (fFlags & kColorsAreNotPremultiplied_Flag); }

[reed1, 2013/06/12 20:20:00]

isPremultiplied() ?
isUnpremultiplied() ?

+
     /** Return the bitmap's width, in pixels.
     */
     int width() const { return fWidth; }
     /** Return the bitmap's height, in pixels.
     */
     int height() const { return fHeight; }
     /** Return the number of bytes between subsequent rows of the bitmap.
     */
     size_t rowBytes() const { return fRowBytes; }
 
@@ skipping 126 matching lines @@
 
     /**
      *  Return the bitmap's bounds [0, 0, width, height] as an SkRect
      */
     void getBounds(SkRect* bounds) const;
     void getBounds(SkIRect* bounds) const;
 
     /** Set the bitmap's config and dimensions. If rowBytes is 0, then
         ComputeRowBytes() is called to compute the optimal value. This resets
         any pixel/colortable ownership, just like reset().
+        @param premul Whether the color values are premultiplied. A value of
+            false will only be respected if Config supports unpremultiplied
+            colors, which is currently only true for kARGB_8888.
+            A bitmap with unpremultiplied pixels cannot be drawn to or from
+            by Skia, but may be used by other libraries.
     */
-    void setConfig(Config, int width, int height, size_t rowBytes = 0);
+    void setConfig(Config, int width, int height, size_t rowBytes = 0,
+                   bool premul = true);

[djsollen, 2013/06/12 17:59:21]

why not just add a new config for unpremultiplied 8888?

[scroggo, 2013/06/12 18:24:42]

That was my first approach, but it was brought up that ultimately we may want
independent choices, more like SkImage. Adding this new config would tie
unpremultiplied to the native color ordering and 8888.

Maybe that's okay though? 

     /** Use this to assign a new pixel address for an existing bitmap. This
         will automatically release any pixelref previously installed. Only call
         this if you are handling ownership/lifetime of the pixel memory.
 
         If the bitmap retains a reference to the colortable (assuming it is
         not null) it will take care of incrementing the reference count.
 
         @param pixels   Address for the pixels, managed by the caller.
         @param ctable   ColorTable (or null) that matches the specified pixels
     */
@@ skipping 92 matching lines @@
     bool lockPixelsAreWritable() const;
 
     /** Call this to be sure that the bitmap is valid enough to be drawn (i.e.
         it has non-null pixels, and if required by its config, it has a
         non-null colortable. Returns true if all of the above are met.
     */
     bool readyToDraw() const {
         return this->getPixels() != NULL &&
                ((this->config() != kIndex8_Config &&
                  this->config() != kRLE_Index8_Config) ||
-                       fColorTable != NULL);
+                       fColorTable != NULL) && this->premultiplied();
     }
 
     /** Returns the pixelRef's texture, or NULL
      */
     SkGpuTexture* getTexture() const;
 
     /** Return the bitmap's colortable, if it uses one (i.e. fConfig is
         kIndex8_Config or kRLE_Index8_Config) and the pixels are locked.
         Otherwise returns NULL. Does not affect the colortable's
         reference count.
@@ skipping 271 matching lines @@
 
     mutable SkPixelRef* fPixelRef;
     mutable size_t      fPixelRefOffset;
     mutable int         fPixelLockCount;
     // either user-specified (in which case it is not treated as mutable)
     // or a cache of the returned value from fPixelRef->lockPixels()
     mutable void*       fPixels;
     mutable SkColorTable* fColorTable;    // only meaningful for kIndex8
 
     enum Flags {
-        kImageIsOpaque_Flag     = 0x01,
-        kImageIsVolatile_Flag   = 0x02,
-        kImageIsImmutable_Flag  = 0x04,
+        kImageIsOpaque_Flag             = 0x01,
+        kImageIsVolatile_Flag           = 0x02,
+        kImageIsImmutable_Flag          = 0x04,
 #ifdef SK_BUILD_FOR_ANDROID
         /* A hint for the renderer responsible for drawing this bitmap
          * indicating that it should attempt to use mipmaps when this bitmap
          * is drawn scaled down.
          */
-        kHasHardwareMipMap_Flag = 0x08,
+        kHasHardwareMipMap_Flag         = 0x08,
 #endif
+        kColorsAreNotPremultiplied_Flag = 0x10,
     };
 
     uint32_t    fRowBytes;
     uint32_t    fWidth;
     uint32_t    fHeight;
     uint8_t     fConfig;
     uint8_t     fFlags;
     uint8_t     fBytesPerPixel; // based on config
 
     /* Internal computations for safe size.
@@ skipping 120 matching lines @@
 
 // returns the address of the byte that contains the x coordinate
 inline uint8_t* SkBitmap::getAddr1(int x, int y) const {
     SkASSERT(fPixels);
     SkASSERT(fConfig == kA1_Config);
     SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
     return (uint8_t*)fPixels + y * fRowBytes + (x >> 3);
 }
 
 #endif