store SkAlphaType inside SkBitmap, on road to support unpremul

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
 #define SkBitmap_DEFINED
 
 #include "Sk64.h"
+#include "SkAlpha.h"
 #include "SkColor.h"
 #include "SkColorTable.h"
 #include "SkPoint.h"
 #include "SkRefCnt.h"
 
 struct SkIRect;
 struct SkRect;
 class SkPaint;
 class SkPixelRef;
 class SkRegion;
@@ skipping 99 matching lines @@
     */
     int bytesPerPixel() const { return fBytesPerPixel; }
 
     /** Return the rowbytes expressed as a number of pixels (like width and
         height). Note, for 1-byte per pixel configs like kA8_Config, this will
         return the same as rowBytes(). Is undefined for configs that are less
         than 1-byte per pixel (e.g. kA1_Config)
     */
     int rowBytesAsPixels() const { return fRowBytes >> (fBytesPerPixel >> 1); }
 
+    SkAlphaType alphaType() const { return (SkAlphaType)fAlphaType; }
+    void setAlphaType(SkAlphaType);
+
     /** Return the address of the pixels for this SkBitmap.
     */
     void* getPixels() const { return fPixels; }
 
     /** Return the byte size of the pixels, based on the height and rowBytes.
         Note this truncates the result to 32bits. Call getSize64() to detect
         if the real size exceeds 32bits.
     */
     size_t getSize() const { return fHeight * fRowBytes; }
 
@@ skipping 27 matching lines @@
         underlying pixelref. This state can be set, but it cannot be
         cleared once it is set. This state propagates to all other bitmaps
         that share the same pixelref.
     */
     void setImmutable();
 
     /** Returns true if the bitmap is opaque (has no translucent/transparent pixels).
     */
     bool isOpaque() const;
 
-    /** Specify if this bitmap's pixels are all opaque or not. Is only meaningful for configs
-        that support per-pixel alpha (RGB32, A1, A8).
-    */
-    void setIsOpaque(bool);
+    /**
+     *  DEPRECATED: use setAlpahType() instead.
+     */
+    void setIsOpaque(bool opaque) {
+        this->setAlphaType(opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
+    }
 
     /** Returns true if the bitmap is volatile (i.e. should not be cached by devices.)
     */
     bool isVolatile() const;
 
     /** Specify whether this bitmap is volatile. Bitmaps are not volatile by
         default. Temporary bitmaps that are discarded after use should be
         marked as volatile. This provides a hint to the device that the bitmap
         should not be cached. Providing this hint when appropriate can
         improve performance by avoiding unnecessary overhead and resource
@@ skipping 31 matching lines @@
      *  are opaque. If it fails to read the pixels, or encounters an error,
      *  it will return false.
      *
      *  Since this can be an expensive operation, the bitmap stores a flag for
      *  this (isOpaque, setIsOpaque). Only call this if you need to compute this
      *  value from "unknown" pixels.
      */
     static bool ComputeIsOpaque(const SkBitmap&);
 
     /**
-     *  Calls ComputeIsOpaque, and passes its result to setIsOpaque().
-     */
-    void computeAndSetOpaquePredicate() {
-        this->setIsOpaque(ComputeIsOpaque(*this));
-    }
-
-    /**
      *  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().
     */
-    void setConfig(Config, int width, int height, size_t rowBytes = 0);
+    bool setConfig(Config, int width, int height, size_t rowBytes, SkAlphaType);
+
+    bool setConfig(Config config, int width, int height, size_t rowBytes = 0) {
+        return this->setConfig(config, width, height, rowBytes,
+                               kPremul_SkAlphaType);
+    }
+
+
     /** 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 403 matching lines @@
          * is drawn scaled down.
          */
         kHasHardwareMipMap_Flag = 0x08,
 #endif
     };
 
     uint32_t    fRowBytes;
     uint32_t    fWidth;
     uint32_t    fHeight;
     uint8_t     fConfig;
+    uint8_t     fAlphaType;
     uint8_t     fFlags;
     uint8_t     fBytesPerPixel; // based on config
 
     void internalErase(const SkIRect&, U8CPU a, U8CPU r, U8CPU g, U8CPU b)const;
 
     /* Internal computations for safe size.
     */
     static Sk64 ComputeSafeSize64(Config   config,
                                   uint32_t width,
                                   uint32_t height,
@@ skipping 126 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