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 25 matching lines @@
     /** Marks this bitmap as immutable, meaning that the contents of its
         pixels will not change for the lifetime of the bitmap and of the
         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;
+    bool isOpaque() const {
+        return SkAlphaTypeIsOpaque(this->alphaType());
+    }
 
-    /** 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