SkBitmap now really stores SkImageInfo -- config is just a ruse

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
 
@@ skipping 61 matching lines @@
 
     /** Copies the src bitmap into this bitmap. Ownership of the src bitmap's pixels remains
         with the src bitmap.
     */
     SkBitmap& operator=(const SkBitmap& src);
     /** Swap the fields of the two bitmaps. This routine is guaranteed to never fail or throw.
     */
     //  This method is not exported to java.
     void swap(SkBitmap& other);
 
+    ///////////////////////////////////////////////////////////////////////////
+
+    const SkImageInfo& info() const { return fInfo; }
+
+    int width() const { return fInfo.fWidth; }
+    int height() const { return fInfo.fHeight; }
+    SkColorType colorType() const { return fInfo.fColorType; }
+    SkAlphaType alphaType() const { return fInfo.fAlphaType; }
+    
+    /** Return the number of bytes per pixel based on the config. If the config
+     does not have at least 1 byte per (e.g. kA1_Config) then 0 is returned.
+     */
+    int bytesPerPixel() const { return fInfo.bytesPerPixel(); }
+    
+    /** 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 >> this->shiftPerPixel();
+    }
+
+    /** Return the shift amount per pixel (i.e. 0 for 1-byte per pixel, 1 for
+     2-bytes per pixel configs, 2 for 4-bytes per pixel configs). Return 0
+     for configs that are not at least 1-byte per pixel (e.g. kA1_Config
+     or kNo_Config)
+     */
+    int shiftPerPixel() const { return this->bytesPerPixel() >> 1; }
+
+    ///////////////////////////////////////////////////////////////////////////
+
     /** Return true iff the bitmap has empty dimensions.
      *  Hey!  Before you use this, see if you really want to know drawsNothing() instead.
      */
-    bool empty() const { return 0 == fWidth || 0 == fHeight; }
+    bool empty() const { return fInfo.isEmpty(); }
 
     /** Return true iff the bitmap has no pixelref. Note: this can return true even if the
      *  dimensions of the bitmap are > 0 (see empty()).
      *  Hey!  Before you use this, see if you really want to know drawsNothing() instead.
      */
     bool isNull() const { return NULL == fPixelRef; }
 
     /** Return true iff drawing this bitmap has no effect.
      */
     bool drawsNothing() const { return this->empty() || this->isNull(); }
 
     /** Return the config for the bitmap. */
-    Config  config() const { return (Config)fConfig; }
+    Config  config() const;
 
     SK_ATTR_DEPRECATED("use config()")
     Config  getConfig() const { return this->config(); }
 
-    /** 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; }
 
-    /** Return the shift amount per pixel (i.e. 0 for 1-byte per pixel, 1 for
-        2-bytes per pixel configs, 2 for 4-bytes per pixel configs). Return 0
-        for configs that are not at least 1-byte per pixel (e.g. kA1_Config
-        or kNo_Config)
-    */
-    int shiftPerPixel() const { return fBytesPerPixel >> 1; }
-
-    /** Return the number of bytes per pixel based on the config. If the config
-        does not have at least 1 byte per (e.g. kA1_Config) then 0 is returned.
-    */
-    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; }
-
     /**
      *  Set the bitmap's alphaType, returning true on success. If false is
      *  returned, then the specified new alphaType is incompatible with the
      *  Config, and the current alphaType is unchanged.
      *
      *  Note: this changes the alphatype for the underlying pixels, which means
      *  that all bitmaps that might be sharing (subsets of) the pixels will
      *  be affected.
      */
     bool 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; }
+    size_t getSize() const { return fInfo.fHeight * fRowBytes; }
 
     /** Return the number of bytes from the pointer returned by getPixels()
         to the end of the allocated space in the buffer. Required in
         cases where extractSubset has been called.
     */
-    size_t getSafeSize() const ;
+    size_t getSafeSize() const { return fInfo.getSafeSize(fRowBytes); }
 
     /**
      *  Return the full size of the bitmap, in bytes.
      */
     int64_t computeSize64() const {
-        return sk_64_mul(fHeight, fRowBytes);
+        return sk_64_mul(fInfo.fHeight, fRowBytes);
     }
 
     /**
      *  Return the number of bytes from the pointer returned by getPixels()
      *  to the end of the allocated space in the buffer. This may be smaller
      *  than computeSize64() if there is any rowbytes padding beyond the width.
      */
     int64_t computeSafeSize64() const {
-        return ComputeSafeSize64((Config)fConfig, fWidth, fHeight, fRowBytes);
+        return fInfo.getSafeSize64(fRowBytes);
     }
 
     /** Returns true if this bitmap is marked as immutable, meaning that the
         contents of its pixels will not change for the lifetime of the bitmap.
     */
     bool isImmutable() const;
 
     /** 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
@@ skipping 113 matching lines @@
      *  optional ReleaseProc and context. When the pixels are no longer
      *  referenced, if ReleaseProc is not null, it will be called with the
      *  pixels and context as parameters.
      *  On failure, the bitmap will be set to empty and return false.
      */
     bool installPixels(const SkImageInfo&, void* pixels, size_t rowBytes,
                        void (*ReleaseProc)(void* addr, void* context),
                        void* context);
 
     /**
-     *  If the bitmap's config can be represented as SkImageInfo, return true,
-     *  and if info is not-null, set it to the bitmap's info. If it cannot be
-     *  represented as SkImageInfo, return false and ignore the info parameter.
+     *  DEPRECATED: call info().
      */
-    bool asImageInfo(SkImageInfo* info) const;
+    bool asImageInfo(SkImageInfo* info) const {
+        // compatibility: return false for kUnknown
+        if (kUnknown_SkColorType == this->colorType()) {
+            return false;
+        }
+        if (info) {
+            *info = this->info();
+        }
+        return true;
+    }
 
     /** 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 121 matching lines @@
     */
     bool readyToDraw() const {
         return this->getPixels() != NULL &&
                (this->config() != kIndex8_Config || NULL != fColorTable);
     }
 
     /** Returns the pixelRef's texture, or NULL
      */
     GrTexture* getTexture() const;
 
-    /** Return the bitmap's colortable, if it uses one (i.e. fConfig is
-        kIndex8_Config) and the pixels are locked.
+    /** Return the bitmap's colortable, if it uses one (i.e. colorType is
+        Index_8) and the pixels are locked.
         Otherwise returns NULL. Does not affect the colortable's
         reference count.
     */
     SkColorTable* getColorTable() const { return fColorTable; }
 
     /** Returns a non-zero, unique value corresponding to the pixels in our
         pixelref. Each time the pixels are changed (and notifyPixelsChanged
         is called), a different generation ID will be returned. Finally, if
         their is no pixelRef then zero is returned.
     */
@@ skipping 270 matching lines @@
         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,
 #endif
     };
 
+    SkImageInfo fInfo;
+
     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 int64_t ComputeSafeSize64(Config   config,
                                      uint32_t width,
                                      uint32_t height,
                                      size_t   rowBytes);
     static size_t ComputeSafeSize(Config   config,
@@ skipping 91 matching lines @@
 private:
     SkColorTable*    fCTable;
     const SkPMColor* fColors;
 };
 #define SkAutoLockColors(...) SK_REQUIRE_LOCAL_VAR(SkAutoLockColors)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 inline uint32_t* SkBitmap::getAddr32(int x, int y) const {
     SkASSERT(fPixels);
-    SkASSERT(fConfig == kARGB_8888_Config);
-    SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
+    SkASSERT(this->config() == kARGB_8888_Config);
+    SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
     return (uint32_t*)((char*)fPixels + y * fRowBytes + (x << 2));
 }
 
 inline uint16_t* SkBitmap::getAddr16(int x, int y) const {
     SkASSERT(fPixels);
-    SkASSERT(fConfig == kRGB_565_Config || fConfig == kARGB_4444_Config);
-    SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
+    SkASSERT(this->config() == kRGB_565_Config || this->config() == kARGB_4444_Config);
+    SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
     return (uint16_t*)((char*)fPixels + y * fRowBytes + (x << 1));
 }
 
 inline uint8_t* SkBitmap::getAddr8(int x, int y) const {
     SkASSERT(fPixels);
-    SkASSERT(fConfig == kA8_Config || fConfig == kIndex8_Config);
-    SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
+    SkASSERT(this->config() == kA8_Config || this->config() == kIndex8_Config);
+    SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
     return (uint8_t*)fPixels + y * fRowBytes + x;
 }
 
 inline SkPMColor SkBitmap::getIndex8Color(int x, int y) const {
     SkASSERT(fPixels);
-    SkASSERT(fConfig == kIndex8_Config);
-    SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
+    SkASSERT(this->config() == kIndex8_Config);
+    SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
     SkASSERT(fColorTable);
     return (*fColorTable)[*((const uint8_t*)fPixels + y * fRowBytes + x)];
 }
 
 #endif