hide SkBitmap::setConfig

src/images/SkImageDecoder_libpng.cpp

-
 /*
  * 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.
  */
 
-
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkMath.h"
 #include "SkRTConf.h"
 #include "SkScaledBitmapSampler.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
@@ skipping 32 matching lines @@
                 "functions.");
 
 
 
 class SkPNGImageIndex {
 public:
     SkPNGImageIndex(SkStreamRewindable* stream, png_structp png_ptr, png_infop info_ptr)
         : fStream(stream)
         , fPng_ptr(png_ptr)
         , fInfo_ptr(info_ptr)
-        , fConfig(SkBitmap::kNo_Config) {
+        , fColorType(kUnknown_SkColorType) {
         SkASSERT(stream != NULL);
         stream->ref();
     }
     ~SkPNGImageIndex() {
         if (NULL != fPng_ptr) {
             png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
         }
     }
 
     SkAutoTUnref<SkStreamRewindable>    fStream;
     png_structp                         fPng_ptr;
     png_infop                           fInfo_ptr;
-    SkBitmap::Config                    fConfig;
+    SkColorType                         fColorType;
 };
 
 class SkPNGImageDecoder : public SkImageDecoder {
 public:
     SkPNGImageDecoder() {
         fImageIndex = NULL;
     }
     virtual Format getFormat() const SK_OVERRIDE {
         return kPNG_Format;
     }
 
     virtual ~SkPNGImageDecoder() {
         SkDELETE(fImageIndex);
     }
 
 protected:
 #ifdef SK_BUILD_FOR_ANDROID
     virtual bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) SK_OVERRIDE;
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& region) SK_OVERRIDE;
 #endif
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
     SkPNGImageIndex* fImageIndex;
 
     bool onDecodeInit(SkStream* stream, png_structp *png_ptrp, png_infop *info_ptrp);
     bool decodePalette(png_structp png_ptr, png_infop info_ptr,
                        bool * SK_RESTRICT hasAlphap, bool *reallyHasAlphap,
                        SkColorTable **colorTablep);
-    bool getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
-                         SkBitmap::Config *config, bool *hasAlpha,
-                         SkPMColor *theTranspColor);
+    bool getBitmapConfig(png_structp, png_infop, SkColorType*, bool* hasAlpha,
+                         SkPMColor* theTranspColor);
 
     typedef SkImageDecoder INHERITED;
 };
 
 #ifndef png_jmpbuf
 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
 #endif
 
 #define PNG_BYTES_TO_CHECK 4
 
@@ skipping 61 matching lines @@
             if (match == *p) {
                 *p = 0;
                 reallyHasAlpha = true;
             }
             p += 1;
         }
     }
     return reallyHasAlpha;
 }
 
-static bool canUpscalePaletteToConfig(SkBitmap::Config dstConfig,
-                                      bool srcHasAlpha) {
-    switch (dstConfig) {
-        case SkBitmap::kARGB_8888_Config:
-        case SkBitmap::kARGB_4444_Config:
+static bool canUpscalePaletteToConfig(SkColorType dstColorType, bool srcHasAlpha) {
+    switch (dstColorType) {
+        case kN32_SkColorType:
+        case kARGB_4444_SkColorType:
             return true;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             // only return true if the src is opaque (since 565 is opaque)
             return !srcHasAlpha;
         default:
             return false;
     }
 }
 
 // call only if color_type is PALETTE. Returns true if the ctable has alpha
 static bool hasTransparencyInPalette(png_structp png_ptr, png_infop info_ptr) {
     png_bytep trans;
@@ skipping 104 matching lines @@
         return false;
     }
 
     PNGAutoClean autoClean(png_ptr, info_ptr);
 
     if (setjmp(png_jmpbuf(png_ptr))) {
         return false;
     }
 
     png_uint_32 origWidth, origHeight;
-    int bitDepth, colorType, interlaceType;
+    int bitDepth, pngColorType, interlaceType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
-                 &colorType, &interlaceType, int_p_NULL, int_p_NULL);
+                 &pngColorType, &interlaceType, int_p_NULL, int_p_NULL);
 
-    SkBitmap::Config    config;
+    SkColorType         colorType;
     bool                hasAlpha = false;
     SkPMColor           theTranspColor = 0; // 0 tells us not to try to match
 
-    if (!this->getBitmapConfig(png_ptr, info_ptr, &config, &hasAlpha, &theTranspColor)) {
+    if (!this->getBitmapConfig(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) {
         return false;
     }
 
+    SkAlphaType alphaType = this->getRequireUnpremultipliedColors() ?
+                                kUnpremul_SkAlphaType : kPremul_SkAlphaType;
     const int sampleSize = this->getSampleSize();
     SkScaledBitmapSampler sampler(origWidth, origHeight, sampleSize);
-    decodedBitmap->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
-
-    // we should communicate alphaType, even if we early-return in bounds-only-mode.
-    if (this->getRequireUnpremultipliedColors()) {
-        decodedBitmap->setAlphaType(kUnpremul_SkAlphaType);
-    }
+    decodedBitmap->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
+                                             colorType, alphaType));
 
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
 
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
     // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we
     // draw lots faster if we can flag the bitmap has being opaque
     bool reallyHasAlpha = false;
     SkColorTable* colorTable = NULL;
 
-    if (colorType == PNG_COLOR_TYPE_PALETTE) {
+    if (pngColorType == PNG_COLOR_TYPE_PALETTE) {
         decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable);
     }
 
     SkAutoUnref aur(colorTable);
 
     if (!this->allocPixelRef(decodedBitmap,
-                             SkBitmap::kIndex8_Config == config ? colorTable : NULL)) {
+                             kIndex_8_SkColorType == colorType ? colorTable : NULL)) {
         return false;
     }
 
     SkAutoLockPixels alp(*decodedBitmap);
 
     /* Turn on interlace handling.  REQUIRED if you are not using
     *  png_read_image().  To see how to handle interlacing passes,
     *  see the png_read_row() method below:
     */
     const int number_passes = (interlaceType != PNG_INTERLACE_NONE) ?
                               png_set_interlace_handling(png_ptr) : 1;
 
     /* Optional call to gamma correct and add the background to the palette
     *  and update info structure.  REQUIRED if you are expecting libpng to
     *  update the palette for you (ie you selected such a transform above).
     */
     png_read_update_info(png_ptr, info_ptr);
 
-    if ((SkBitmap::kA8_Config == config || SkBitmap::kIndex8_Config == config)
-        && 1 == sampleSize) {
-        if (SkBitmap::kA8_Config == config) {
+    if ((kAlpha_8_SkColorType == colorType || kIndex_8_SkColorType == colorType) &&
+            1 == sampleSize) {
+        if (kAlpha_8_SkColorType == colorType) {
             // For an A8 bitmap, we assume there is an alpha for speed. It is
             // possible the bitmap is opaque, but that is an unlikely use case
             // since it would not be very interesting.
             reallyHasAlpha = true;
             // A8 is only allowed if the original was GRAY.
-            SkASSERT(PNG_COLOR_TYPE_GRAY == colorType);
+            SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
         }
         for (int i = 0; i < number_passes; i++) {
             for (png_uint_32 y = 0; y < origHeight; y++) {
                 uint8_t* bmRow = decodedBitmap->getAddr8(0, y);
                 png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1);
             }
         }
     } else {
         SkScaledBitmapSampler::SrcConfig sc;
         int srcBytesPerPixel = 4;
 
         if (colorTable != NULL) {
             sc = SkScaledBitmapSampler::kIndex;
             srcBytesPerPixel = 1;
-        } else if (SkBitmap::kA8_Config == config) {
+        } else if (kAlpha_8_SkColorType == colorType) {
             // A8 is only allowed if the original was GRAY.
-            SkASSERT(PNG_COLOR_TYPE_GRAY == colorType);
+            SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
             sc = SkScaledBitmapSampler::kGray;
             srcBytesPerPixel = 1;
         } else if (hasAlpha) {
             sc = SkScaledBitmapSampler::kRGBA;
         } else {
             sc = SkScaledBitmapSampler::kRGBX;
         }
 
         /*  We have to pass the colortable explicitly, since we may have one
             even if our decodedBitmap doesn't, due to the request that we
@@ skipping 70 matching lines @@
 
     if (!reallyHasAlpha) {
         decodedBitmap->setAlphaType(kOpaque_SkAlphaType);
     }
     return true;
 }
 
 
 
 bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
-                                        SkBitmap::Config* SK_RESTRICT configp,
-                                        bool* SK_RESTRICT hasAlphap,
+                                        SkColorType* colorTypep,
+                                        bool* hasAlphap,
                                         SkPMColor* SK_RESTRICT theTranspColorp) {
     png_uint_32 origWidth, origHeight;
     int bitDepth, colorType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
                  &colorType, int_p_NULL, int_p_NULL, int_p_NULL);
 
     // check for sBIT chunk data, in case we should disable dithering because
     // our data is not truely 8bits per component
     png_color_8p sig_bit;
     if (this->getDitherImage() && png_get_sBIT(png_ptr, info_ptr, &sig_bit)) {
 #if 0
         SkDebugf("----- sBIT %d %d %d %d\n", sig_bit->red, sig_bit->green,
                  sig_bit->blue, sig_bit->alpha);
 #endif
         // 0 seems to indicate no information available
         if (pos_le(sig_bit->red, SK_R16_BITS) &&
             pos_le(sig_bit->green, SK_G16_BITS) &&
             pos_le(sig_bit->blue, SK_B16_BITS)) {
             this->setDitherImage(false);
         }
     }
 
     if (colorType == PNG_COLOR_TYPE_PALETTE) {
         bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr);
-        *configp = this->getPrefConfig(kIndex_SrcDepth, paletteHasAlpha);
+        *colorTypep = this->getPrefColorType(kIndex_SrcDepth, paletteHasAlpha);
         // now see if we can upscale to their requested config
-        if (!canUpscalePaletteToConfig(*configp, paletteHasAlpha)) {
-            *configp = SkBitmap::kIndex8_Config;
+        if (!canUpscalePaletteToConfig(*colorTypep, paletteHasAlpha)) {
+            *colorTypep = kIndex_8_SkColorType;
         }
     } else {
         png_color_16p transpColor = NULL;
         int numTransp = 0;
 
         png_get_tRNS(png_ptr, info_ptr, NULL, &numTransp, &transpColor);
 
         bool valid = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS);
 
         if (valid && numTransp == 1 && transpColor != NULL) {
@@ skipping 43 matching lines @@
             *hasAlphap = true;
         }
 
         SrcDepth srcDepth = k32Bit_SrcDepth;
         if (PNG_COLOR_TYPE_GRAY == colorType) {
             srcDepth = k8BitGray_SrcDepth;
             // Remove this assert, which fails on desk_pokemonwiki.skp
             //SkASSERT(!*hasAlphap);
         }
 
-        *configp = this->getPrefConfig(srcDepth, *hasAlphap);
+        *colorTypep = this->getPrefColorType(srcDepth, *hasAlphap);
         // now match the request against our capabilities
         if (*hasAlphap) {
-            if (*configp != SkBitmap::kARGB_4444_Config) {
-                *configp = SkBitmap::kARGB_8888_Config;
+            if (*colorTypep != kARGB_4444_SkColorType) {
+                *colorTypep = kN32_SkColorType;
             }
         } else {
-            if (SkBitmap::kA8_Config == *configp) {
+            if (kAlpha_8_SkColorType == *colorTypep) {
                 if (k8BitGray_SrcDepth != srcDepth) {
                     // Converting a non grayscale image to A8 is not currently supported.
-                    *configp = SkBitmap::kARGB_8888_Config;
+                    *colorTypep = kN32_SkColorType;
                 }
-            } else if (*configp != SkBitmap::kRGB_565_Config &&
-                       *configp != SkBitmap::kARGB_4444_Config) {
-                *configp = SkBitmap::kARGB_8888_Config;
+            } else if (*colorTypep != kRGB_565_SkColorType &&
+                       *colorTypep != kARGB_4444_SkColorType) {
+                *colorTypep = kN32_SkColorType;
             }
         }
     }
 
     // sanity check for size
     {
         int64_t size = sk_64_mul(origWidth, origHeight);
         // now check that if we are 4-bytes per pixel, we also don't overflow
         if (size < 0 || size > (0x7FFFFFFF >> 2)) {
             return false;
         }
     }
 
-    if (!this->chooseFromOneChoice(*configp, origWidth, origHeight)) {
+    if (!this->chooseFromOneChoice(*colorTypep, origWidth, origHeight)) {
         return false;
     }
 
     // If the image has alpha and the decoder wants unpremultiplied
     // colors, the only supported config is 8888.
     if (this->getRequireUnpremultipliedColors() && *hasAlphap) {
-        *configp = SkBitmap::kARGB_8888_Config;
+        *colorTypep = kN32_SkColorType;
     }
 
     if (fImageIndex != NULL) {
-        if (SkBitmap::kNo_Config == fImageIndex->fConfig) {
+        if (kUnknown_SkColorType == fImageIndex->fColorType) {
             // This is the first time for this subset decode. From now on,
             // all decodes must be in the same config.
-            fImageIndex->fConfig = *configp;
-        } else if (fImageIndex->fConfig != *configp) {
-            // Requesting a different config for a subsequent decode is not
+            fImageIndex->fColorType = *colorTypep;
+        } else if (fImageIndex->fColorType != *colorTypep) {
+            // Requesting a different colortype for a subsequent decode is not
             // supported. Report failure before we make changes to png_ptr.
             return false;
         }
     }
 
-    bool convertGrayToRGB = PNG_COLOR_TYPE_GRAY == colorType
-                            && *configp != SkBitmap::kA8_Config;
+    bool convertGrayToRGB = PNG_COLOR_TYPE_GRAY == colorType && *colorTypep != kAlpha_8_SkColorType;
 
     // Unless the user is requesting A8, convert a grayscale image into RGB.
     // GRAY_ALPHA will always be converted to RGB
     if (convertGrayToRGB || colorType == PNG_COLOR_TYPE_GRAY_ALPHA) {
         png_set_gray_to_rgb(png_ptr);
     }
 
     // Add filler (or alpha) byte (after each RGB triplet) if necessary.
     if (colorType == PNG_COLOR_TYPE_RGB || convertGrayToRGB) {
         png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
@@ skipping 117 matching lines @@
         return false;
     }
 
     png_structp png_ptr = fImageIndex->fPng_ptr;
     png_infop info_ptr = fImageIndex->fInfo_ptr;
     if (setjmp(png_jmpbuf(png_ptr))) {
         return false;
     }
 
     png_uint_32 origWidth, origHeight;
-    int bitDepth, colorType, interlaceType;
+    int bitDepth, pngColorType, interlaceType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
-                 &colorType, &interlaceType, int_p_NULL, int_p_NULL);
+                 &pngColorType, &interlaceType, int_p_NULL, int_p_NULL);
 
     SkIRect rect = SkIRect::MakeWH(origWidth, origHeight);
 
     if (!rect.intersect(region)) {
         // If the requested region is entirely outside the image, just
         // returns false
         return false;
     }
 
-    SkBitmap::Config    config;
+    SkColorType         colorType;
     bool                hasAlpha = false;
     SkPMColor           theTranspColor = 0; // 0 tells us not to try to match
 
-    if (!this->getBitmapConfig(png_ptr, info_ptr, &config, &hasAlpha, &theTranspColor)) {
+    if (!this->getBitmapConfig(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) {
         return false;
     }
 
     const int sampleSize = this->getSampleSize();
     SkScaledBitmapSampler sampler(origWidth, rect.height(), sampleSize);
 
     SkBitmap decodedBitmap;
-    decodedBitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
+    decodedBitmap.setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
+                                            colorType, kPremul_SkAlphaType));
 
     // from here down we are concerned with colortables and pixels
 
     // we track if we actually see a non-opaque pixels, since sometimes a PNG sets its colortype
     // to |= PNG_COLOR_MASK_ALPHA, but all of its pixels are in fact opaque. We care, since we
     // draw lots faster if we can flag the bitmap has being opaque
     bool reallyHasAlpha = false;
     SkColorTable* colorTable = NULL;
 
-    if (colorType == PNG_COLOR_TYPE_PALETTE) {
+    if (pngColorType == PNG_COLOR_TYPE_PALETTE) {
         decodePalette(png_ptr, info_ptr, &hasAlpha, &reallyHasAlpha, &colorTable);
     }
 
     SkAutoUnref aur(colorTable);
 
     // Check ahead of time if the swap(dest, src) is possible.
     // If yes, then we will stick to AllocPixelRef since it's cheaper with the swap happening.
     // If no, then we will use alloc to allocate pixels to prevent garbage collection.
     int w = rect.width() / sampleSize;
     int h = rect.height() / sampleSize;
     const bool swapOnly = (rect == region) && (w == decodedBitmap.width()) &&
                           (h == decodedBitmap.height()) && bm->isNull();
-    const bool needColorTable = SkBitmap::kIndex8_Config == config;
+    const bool needColorTable = kIndex_8_SkColorType == colorType;
     if (swapOnly) {
         if (!this->allocPixelRef(&decodedBitmap, needColorTable ? colorTable : NULL)) {
             return false;
         }
     } else {
         if (!decodedBitmap.allocPixels(NULL, needColorTable ? colorTable : NULL)) {
             return false;
         }
     }
     SkAutoLockPixels alp(decodedBitmap);
@@ skipping 14 matching lines @@
 #if defined(PNG_1_0_X) || defined (PNG_1_2_X)
     png_ptr->pass = 0;
 #else
     // FIXME: This sets pass as desired, but also sets iwidth. Is that ok?
     png_set_interlaced_pass(png_ptr, 0);
 #endif
     png_read_update_info(png_ptr, info_ptr);
 
     int actualTop = rect.fTop;
 
-    if ((SkBitmap::kA8_Config == config || SkBitmap::kIndex8_Config == config)
+    if ((kAlpha_8_SkColorType == colorType || kIndex_8_SkColorType == colorType)
         && 1 == sampleSize) {
-        if (SkBitmap::kA8_Config == config) {
+        if (kAlpha_8_SkColorType == colorType) {
             // For an A8 bitmap, we assume there is an alpha for speed. It is
             // possible the bitmap is opaque, but that is an unlikely use case
             // since it would not be very interesting.
             reallyHasAlpha = true;
             // A8 is only allowed if the original was GRAY.
-            SkASSERT(PNG_COLOR_TYPE_GRAY == colorType);
+            SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
         }
 
         for (int i = 0; i < number_passes; i++) {
             png_configure_decoder(png_ptr, &actualTop, i);
             for (int j = 0; j < rect.fTop - actualTop; j++) {
                 uint8_t* bmRow = decodedBitmap.getAddr8(0, 0);
                 png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1);
             }
             png_uint_32 bitmapHeight = (png_uint_32) decodedBitmap.height();
             for (png_uint_32 y = 0; y < bitmapHeight; y++) {
                 uint8_t* bmRow = decodedBitmap.getAddr8(0, y);
                 png_read_rows(png_ptr, &bmRow, png_bytepp_NULL, 1);
             }
         }
     } else {
         SkScaledBitmapSampler::SrcConfig sc;
         int srcBytesPerPixel = 4;
 
         if (colorTable != NULL) {
             sc = SkScaledBitmapSampler::kIndex;
             srcBytesPerPixel = 1;
-        } else if (SkBitmap::kA8_Config == config) {
+        } else if (kAlpha_8_SkColorType == colorType) {
             // A8 is only allowed if the original was GRAY.
-            SkASSERT(PNG_COLOR_TYPE_GRAY == colorType);
+            SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
             sc = SkScaledBitmapSampler::kGray;
             srcBytesPerPixel = 1;
         } else if (hasAlpha) {
             sc = SkScaledBitmapSampler::kRGBA;
         } else {
             sc = SkScaledBitmapSampler::kRGBX;
         }
 
         /*  We have to pass the colortable explicitly, since we may have one
             even if our decodedBitmap doesn't, due to the request that we
@@ skipping 48 matching lines @@
                     skip_src_rows(png_ptr, srcRow, sampler.srcDY() - 1);
                 }
             }
         }
     }
 
     if (0 != theTranspColor) {
         reallyHasAlpha |= substituteTranspColor(&decodedBitmap, theTranspColor);
     }
     if (reallyHasAlpha && this->getRequireUnpremultipliedColors()) {
-        switch (decodedBitmap.config()) {
-            case SkBitmap::kIndex8_Config:
+        switch (decodedBitmap.colorType()) {
+            case kIndex_8_SkColorType:
                 // Fall through.
-            case SkBitmap::kARGB_4444_Config:
-                // We have chosen not to support unpremul for these configs.
+            case kARGB_4444_SkColorType:
+                // We have chosen not to support unpremul for these colortypess.
                 return false;
             default: {
                 // Fall through to finish the decode. This config either
                 // supports unpremul or it is irrelevant because it has no
                 // alpha (or only alpha).
                 // These brackets prevent a warning.
             }
         }
     }
     SkAlphaType alphaType = kOpaque_SkAlphaType;
@@ skipping 312 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? SkNEW(SkPNGImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libpng_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_png);
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);