use colortype instead of config

src/pdf/SkPDFImage.cpp

 /*
  * Copyright 2010 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 "SkPDFImage.h"
 
 #include "SkBitmap.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkFlate.h"
 #include "SkPDFCatalog.h"
 #include "SkRect.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkUnPreMultiply.h"
 
 static const int kNoColorTransform = 0;
 
 static bool skip_compression(SkPDFCatalog* catalog) {
     return SkToBool(catalog->getDocumentFlags() &
                     SkPDFDocument::kFavorSpeedOverSize_Flags);
 }
 
 static size_t get_uncompressed_size(const SkBitmap& bitmap,
                                     const SkIRect& srcRect) {
-    switch (bitmap.config()) {
-        case SkBitmap::kIndex8_Config:
+    switch (bitmap.colorType()) {
+        case kIndex_8_SkColorType:
             return srcRect.width() * srcRect.height();
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             return ((srcRect.width() * 3 + 1) / 2) * srcRect.height();
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             return srcRect.width() * 3 * srcRect.height();
-        case SkBitmap::kARGB_8888_Config:
+        case kRGBA_8888_SkColorType:
+        case kBGRA_8888_SkColorType:
             return srcRect.width() * 3 * srcRect.height();
-        case SkBitmap::kA8_Config:
+        case kAlpha_8_SkColorType:
             return 1;
         default:
             SkASSERT(false);
             return 0;
     }
 }
 
 static SkStream* extract_index8_image(const SkBitmap& bitmap,
                                       const SkIRect& srcRect) {
     const int rowBytes = srcRect.width();
@@ skipping 151 matching lines @@
  * @param isTransparent Pointer to a bool to output whether the alpha is
  *                      completely transparent. May be NULL. Only valid when
  *                      extractAlpha == true.
  * @return              Unencoded image data, or NULL if either data was not
  *                      available or alpha data was requested but the image was
  *                      entirely transparent or opaque.
  */
 static SkStream* extract_image_data(const SkBitmap& bitmap,
                                     const SkIRect& srcRect,
                                     bool extractAlpha, bool* isTransparent) {
-    SkBitmap::Config config = bitmap.config();
-    if (extractAlpha && (config == SkBitmap::kIndex8_Config ||
-            config == SkBitmap::kRGB_565_Config)) {
+    SkColorType colorType = bitmap.colorType();
+    if (extractAlpha && (kIndex_8_SkColorType == colorType ||
+                         kRGB_565_SkColorType == colorType)) {
         if (isTransparent != NULL) {
             *isTransparent = false;
         }
         return NULL;
     }
     bool isOpaque = true;
     bool transparent = extractAlpha;
     SkStream* stream = NULL;
 
     bitmap.lockPixels();
-    switch (config) {
-        case SkBitmap::kIndex8_Config:
+    switch (colorType) {
+        case kIndex_8_SkColorType:
             if (!extractAlpha) {
                 stream = extract_index8_image(bitmap, srcRect);
             }
             break;
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             stream = extract_argb4444_data(bitmap, srcRect, extractAlpha,
                                            &isOpaque, &transparent);
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             if (!extractAlpha) {
                 stream = extract_rgb565_image(bitmap, srcRect);
             }
             break;
-        case SkBitmap::kARGB_8888_Config:
+        case kN32_SkColorType:
             stream = extract_argb8888_data(bitmap, srcRect, extractAlpha,
                                            &isOpaque, &transparent);
             break;
-        case SkBitmap::kA8_Config:
+        case kAlpha_8_SkColorType:
             if (!extractAlpha) {
                 stream = create_black_image();
             } else {
                 stream = extract_a8_alpha(bitmap, srcRect,
                                           &isOpaque, &transparent);
             }
             break;
         default:
             SkASSERT(false);
     }
@@ skipping 112 matching lines @@
         return SkPackARGB4444(SK_AlphaOPAQUE & 0x0F, 0, 0, 0);
     } else {
         return SkPackARGB4444(SK_AlphaOPAQUE & 0x0F,
                                    r / count, g / count, b / count);
     }
 }
 
 static SkBitmap unpremultiply_bitmap(const SkBitmap& bitmap,
                                      const SkIRect& srcRect) {
     SkBitmap outBitmap;
-    outBitmap.setConfig(bitmap.config(), srcRect.width(), srcRect.height());
-    outBitmap.allocPixels();
+    outBitmap.allocPixels(bitmap.info().makeWH(srcRect.width(), srcRect.height()));
     int dstRow = 0;
 
     outBitmap.lockPixels();
     bitmap.lockPixels();
-    switch (bitmap.config()) {
-        case SkBitmap::kARGB_4444_Config: {
+    switch (bitmap.colorType()) {
+        case kARGB_4444_SkColorType: {
             for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
                 uint16_t* dst = outBitmap.getAddr16(0, dstRow);
                 uint16_t* src = bitmap.getAddr16(0, y);
                 for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
                     uint8_t a = SkGetPackedA4444(src[x]);
                     // It is necessary to average the color component of
                     // transparent pixels with their surrounding neighbors
                     // since the PDF renderer may separately re-sample the
                     // alpha and color channels when the image is not
                     // displayed at its native resolution. Since an alpha of
                     // zero gives no information about the color component,
                     // the pathological case is a white image with sharp
                     // transparency bounds - the color channel goes to black,
                     // and the should-be-transparent pixels are rendered
                     // as grey because of the separate soft mask and color
                     // resizing.
                     if (a == (SK_AlphaTRANSPARENT & 0x0F)) {
                         *dst = get_argb4444_neighbor_avg_color(bitmap, x, y);
                     } else {
                         *dst = remove_alpha_argb4444(src[x]);
                     }
                     dst++;
                 }
                 dstRow++;
             }
             break;
         }
-        case SkBitmap::kARGB_8888_Config: {
+        case kN32_SkColorType: {
             for (int y = srcRect.fTop; y < srcRect.fBottom; y++) {
                 uint32_t* dst = outBitmap.getAddr32(0, dstRow);
                 uint32_t* src = bitmap.getAddr32(0, y);
                 for (int x = srcRect.fLeft; x < srcRect.fRight; x++) {
                     uint8_t a = SkGetPackedA32(src[x]);
                     if (a == SK_AlphaTRANSPARENT) {
                         *dst = get_argb8888_neighbor_avg_color(bitmap, x, y);
                     } else {
                         *dst = remove_alpha_argb8888(src[x]);
                     }
@@ skipping 11 matching lines @@
 
     outBitmap.setImmutable();
 
     return outBitmap;
 }
 
 // static
 SkPDFImage* SkPDFImage::CreateImage(const SkBitmap& bitmap,
                                     const SkIRect& srcRect,
                                     SkPicture::EncodeBitmap encoder) {
-    if (bitmap.config() == SkBitmap::kNo_Config) {
+    if (bitmap.colorType() == kUnknown_SkColorType) {
         return NULL;
     }
 
     bool isTransparent = false;
     SkAutoTUnref<SkStream> alphaData;
     if (!bitmap.isOpaque()) {
         // Note that isOpaque is not guaranteed to return false for bitmaps
         // with alpha support but a completely opaque alpha channel,
         // so alphaData may still be NULL if we have a completely opaque
         // (or transparent) bitmap.
         alphaData.reset(
                 extract_image_data(bitmap, srcRect, true, &isTransparent));
     }
     if (isTransparent) {
         return NULL;
     }
 
     SkPDFImage* image;
-    SkBitmap::Config config = bitmap.config();
-    if (alphaData.get() != NULL && (config == SkBitmap::kARGB_8888_Config ||
-            config == SkBitmap::kARGB_4444_Config)) {
+    SkColorType colorType = bitmap.colorType();
+    if (alphaData.get() != NULL && (kN32_SkColorType == colorType ||
+                                    kARGB_4444_SkColorType == colorType)) {
         SkBitmap unpremulBitmap = unpremultiply_bitmap(bitmap, srcRect);
         image = SkNEW_ARGS(SkPDFImage, (NULL, unpremulBitmap, false,
                            SkIRect::MakeWH(srcRect.width(), srcRect.height()),
                            encoder));
     } else {
         image = SkNEW_ARGS(SkPDFImage, (NULL, bitmap, false, srcRect, encoder));
     }
     if (alphaData.get() != NULL) {
         SkAutoTUnref<SkPDFImage> mask(
                 SkNEW_ARGS(SkPDFImage, (alphaData.get(), bitmap,
@@ skipping 36 matching lines @@
         fBitmap.setImmutable();
     }
 
     if (stream != NULL) {
         setData(stream);
         fStreamValid = true;
     } else {
         fStreamValid = false;
     }
 
-    SkBitmap::Config config = fBitmap.config();
+    SkColorType colorType = fBitmap.colorType();
 
     insertName("Type", "XObject");
     insertName("Subtype", "Image");
 
-    bool alphaOnly = (config == SkBitmap::kA8_Config);
+    bool alphaOnly = (kAlpha_8_SkColorType == colorType);
 
     if (!isAlpha && alphaOnly) {
         // For alpha only images, we stretch a single pixel of black for
         // the color/shape part.
         SkAutoTUnref<SkPDFInt> one(new SkPDFInt(1));
         insert("Width", one.get());
         insert("Height", one.get());
     } else {
         insertInt("Width", fSrcRect.width());
         insertInt("Height", fSrcRect.height());
     }
 
     if (isAlpha || alphaOnly) {
         insertName("ColorSpace", "DeviceGray");
-    } else if (config == SkBitmap::kIndex8_Config) {
+    } else if (kIndex_8_SkColorType == colorType) {
         SkAutoLockPixels alp(fBitmap);
         insert("ColorSpace",
                make_indexed_color_space(fBitmap.getColorTable()))->unref();
     } else {
         insertName("ColorSpace", "DeviceRGB");
     }
 
     int bitsPerComp = 8;
-    if (config == SkBitmap::kARGB_4444_Config) {
+    if (kARGB_4444_SkColorType == colorType) {
         bitsPerComp = 4;
     }
     insertInt("BitsPerComponent", bitsPerComp);
 
-    if (config == SkBitmap::kRGB_565_Config) {
+    if (kRGB_565_SkColorType == colorType) {
         SkASSERT(!isAlpha);
         SkAutoTUnref<SkPDFInt> zeroVal(new SkPDFInt(0));
         SkAutoTUnref<SkPDFScalar> scale5Val(
                 new SkPDFScalar(8.2258f));  // 255/2^5-1
         SkAutoTUnref<SkPDFScalar> scale6Val(
                 new SkPDFScalar(4.0476f));  // 255/2^6-1
         SkAutoTUnref<SkPDFArray> decodeValue(new SkPDFArray());
         decodeValue->reserve(6);
         decodeValue->append(zeroVal.get());
         decodeValue->append(scale5Val.get());
@@ skipping 19 matching lines @@
 
 bool SkPDFImage::populate(SkPDFCatalog* catalog) {
     if (getState() == kUnused_State) {
         // Initializing image data for the first time.
         SkDynamicMemoryWStream dctCompressedWStream;
         if (!skip_compression(catalog) && fEncoder &&
                 get_uncompressed_size(fBitmap, fSrcRect) > 1) {
             SkBitmap subset;
             // Extract subset
             if (!fBitmap.extractSubset(&subset, fSrcRect)) {
-                // TODO(edisonn) It fails only for kA1_Config, if that is a
-                // major concern we will fix it later, so far it is NYI.
                 return false;
             }
             size_t pixelRefOffset = 0;
             SkAutoTUnref<SkData> data(fEncoder(&pixelRefOffset, subset));
             if (data.get() && data->size() < get_uncompressed_size(fBitmap,
                                                                    fSrcRect)) {
                 SkAutoTUnref<SkStream> stream(SkNEW_ARGS(SkMemoryStream,
                                                          (data)));
                 setData(stream.get());
 
@@ skipping 19 matching lines @@
         // but the new catalog wants it compressed.
         if (!getSubstitute()) {
             SkPDFStream* substitute = SkNEW_ARGS(SkPDFImage, (*this));
             setSubstitute(substitute);
             catalog->setSubstitute(this, substitute);
         }
         return false;
     }
     return true;
 }