hide SkBitmap::setConfig

src/images/SkImageDecoder_libjpeg.cpp

 /*
  * Copyright 2007 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"
@@ skipping 230 matching lines @@
     virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
 #ifdef SK_BUILD_FOR_ANDROID
     SkJPEGImageIndex* fImageIndex;
     int fImageWidth;
     int fImageHeight;
 #endif
 
     /**
-     *  Determine the appropriate bitmap config and out_color_space based on
+     *  Determine the appropriate bitmap colortype and out_color_space based on
      *  both the preference of the caller and the jpeg_color_space on the
      *  jpeg_decompress_struct passed in.
      *  Must be called after jpeg_read_header.
      */
-    SkBitmap::Config getBitmapConfig(jpeg_decompress_struct*);
+    SkColorType getBitmapColorType(jpeg_decompress_struct*);
 
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
 /* Automatically clean up after throwing an exception */
 class JPEGAutoClean {
 public:
     JPEGAutoClean(): cinfo_ptr(NULL) {}
@@ skipping 126 matching lines @@
     if (decoder.getPreferQualityOverSpeed()) {
         cinfo->dct_method = JDCT_ISLOW;
     } else {
         cinfo->dct_method = JDCT_IFAST;
     }
 #else
     cinfo->dct_method = JDCT_ISLOW;
 #endif
 }
 
-SkBitmap::Config SkJPEGImageDecoder::getBitmapConfig(jpeg_decompress_struct* cinfo) {
+SkColorType SkJPEGImageDecoder::getBitmapColorType(jpeg_decompress_struct* cinfo) {
     SkASSERT(cinfo != NULL);
 
     SrcDepth srcDepth = k32Bit_SrcDepth;
     if (JCS_GRAYSCALE == cinfo->jpeg_color_space) {
         srcDepth = k8BitGray_SrcDepth;
     }
 
-    SkBitmap::Config config = this->getPrefConfig(srcDepth, /*hasAlpha*/ false);
-    switch (config) {
-        case SkBitmap::kA8_Config:
-            // Only respect A8 config if the original is grayscale,
+    SkColorType colorType = this->getPrefColorType(srcDepth, /*hasAlpha*/ false);
+    switch (colorType) {
+        case kAlpha_8_SkColorType:
+            // Only respect A8 colortype if the original is grayscale,
             // in which case we will treat the grayscale as alpha
             // values.
             if (cinfo->jpeg_color_space != JCS_GRAYSCALE) {
-                config = SkBitmap::kARGB_8888_Config;
+                colorType = kN32_SkColorType;
             }
             break;
-        case SkBitmap::kARGB_8888_Config:
+        case kN32_SkColorType:
             // Fall through.
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             // Fall through.
-        case SkBitmap::kRGB_565_Config:
-            // These are acceptable destination configs.
+        case kRGB_565_SkColorType:
+            // These are acceptable destination colortypes.
             break;
         default:
-            // Force all other configs to 8888.
-            config = SkBitmap::kARGB_8888_Config;
+            // Force all other colortypes to 8888.
+            colorType = kN32_SkColorType;
             break;
     }
 
     switch (cinfo->jpeg_color_space) {
         case JCS_CMYK:
             // Fall through.
         case JCS_YCCK:
             // libjpeg cannot convert from CMYK or YCCK to RGB - here we set up
             // so libjpeg will give us CMYK samples back and we will later
             // manually convert them to RGB
             cinfo->out_color_space = JCS_CMYK;
             break;
         case JCS_GRAYSCALE:
-            if (SkBitmap::kA8_Config == config) {
+            if (kAlpha_8_SkColorType == colorType) {
                 cinfo->out_color_space = JCS_GRAYSCALE;
                 break;
             }
             // The data is JCS_GRAYSCALE, but the caller wants some sort of RGB
-            // config. Fall through to set to the default.
+            // colortype. Fall through to set to the default.
         default:
             cinfo->out_color_space = JCS_RGB;
             break;
     }
-    return config;
+    return colorType;
 }
 
-#ifdef ANDROID_RGB
 /**
- *  Based on the config and dither mode, adjust out_color_space and
- *  dither_mode of cinfo.
+ *  Based on the colortype and dither mode, adjust out_color_space and
+ *  dither_mode of cinfo. Only does work in ANDROID_RGB
  */
 static void adjust_out_color_space_and_dither(jpeg_decompress_struct* cinfo,
-                                              SkBitmap::Config config,
+                                              SkColorType colorType,
                                               const SkImageDecoder& decoder) {
     SkASSERT(cinfo != NULL);
+#ifdef ANDROID_RGB
     cinfo->dither_mode = JDITHER_NONE;
     if (JCS_CMYK == cinfo->out_color_space) {
         return;
     }
-    switch(config) {
-        case SkBitmap::kARGB_8888_Config:
+    switch (colorType) {
+        case kN32_SkColorType:
             cinfo->out_color_space = JCS_RGBA_8888;
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             cinfo->out_color_space = JCS_RGB_565;
             if (decoder.getDitherImage()) {
                 cinfo->dither_mode = JDITHER_ORDERED;
             }
             break;
         default:
             break;
     }
+#endif
 }
-#endif
 
 
 /**
    Sets all pixels in given bitmap to SK_ColorWHITE for all rows >= y.
    Used when decoding fails partway through reading scanlines to fill
    remaining lines. */
 static void fill_below_level(int y, SkBitmap* bitmap) {
     SkIRect rect = SkIRect::MakeLTRB(0, y, bitmap->width(), bitmap->height());
     SkCanvas canvas(*bitmap);
     canvas.clipRect(SkRect::Make(rect));
@@ skipping 67 matching lines @@
     */
     int sampleSize = this->getSampleSize();
 
     set_dct_method(*this, &cinfo);
 
     SkASSERT(1 == cinfo.scale_num);
     cinfo.scale_denom = sampleSize;
 
     turn_off_visual_optimizations(&cinfo);
 
-    const SkBitmap::Config config = this->getBitmapConfig(&cinfo);
+    const SkColorType colorType = this->getBitmapColorType(&cinfo);
+    const SkAlphaType alphaType = kAlpha_8_SkColorType == colorType ?
+                                      kPremul_SkAlphaType : kOpaque_SkAlphaType;
 
-#ifdef ANDROID_RGB
-    adjust_out_color_space_and_dither(&cinfo, config, *this);
-#endif
+    adjust_out_color_space_and_dither(&cinfo, colorType, *this);
 
     if (1 == sampleSize && SkImageDecoder::kDecodeBounds_Mode == mode) {
         // Assume an A8 bitmap is not opaque to avoid the check of each
         // individual pixel. It is very unlikely to be opaque, since
         // an opaque A8 bitmap would not be very interesting.
         // Otherwise, a jpeg image is opaque.
-        return bm->setConfig(config, cinfo.image_width, cinfo.image_height, 0,
-                             SkBitmap::kA8_Config == config ?
-                                kPremul_SkAlphaType : kOpaque_SkAlphaType);
+        return bm->setInfo(SkImageInfo::Make(cinfo.image_width, cinfo.image_height,
+                                             colorType, alphaType));
     }
 
     /*  image_width and image_height are the original dimensions, available
         after jpeg_read_header(). To see the scaled dimensions, we have to call
         jpeg_start_decompress(), and then read output_width and output_height.
     */
     if (!jpeg_start_decompress(&cinfo)) {
         /*  If we failed here, we may still have enough information to return
             to the caller if they just wanted (subsampled bounds). If sampleSize
             was 1, then we would have already returned. Thus we just check if
             we're in kDecodeBounds_Mode, and that we have valid output sizes.
 
             One reason to fail here is that we have insufficient stream data
             to complete the setup. However, output dimensions seem to get
             computed very early, which is why this special check can pay off.
          */
         if (SkImageDecoder::kDecodeBounds_Mode == mode && valid_output_dimensions(cinfo)) {
             SkScaledBitmapSampler smpl(cinfo.output_width, cinfo.output_height,
                                        recompute_sampleSize(sampleSize, cinfo));
             // Assume an A8 bitmap is not opaque to avoid the check of each
             // individual pixel. It is very unlikely to be opaque, since
             // an opaque A8 bitmap would not be very interesting.
             // Otherwise, a jpeg image is opaque.
-            return bm->setConfig(config, smpl.scaledWidth(), smpl.scaledHeight(),
-                                 0, SkBitmap::kA8_Config == config ?
-                                    kPremul_SkAlphaType : kOpaque_SkAlphaType);
+            return bm->setInfo(SkImageInfo::Make(smpl.scaledWidth(), smpl.scaledHeight(),
+                                                 colorType, alphaType));
         } else {
             return return_false(cinfo, *bm, "start_decompress");
         }
     }
     sampleSize = recompute_sampleSize(sampleSize, cinfo);
 
-    // should we allow the Chooser (if present) to pick a config for us???
-    if (!this->chooseFromOneChoice(config, cinfo.output_width, cinfo.output_height)) {
+    // should we allow the Chooser (if present) to pick a colortype for us???
+    if (!this->chooseFromOneChoice(colorType, cinfo.output_width, cinfo.output_height)) {
         return return_false(cinfo, *bm, "chooseFromOneChoice");
     }
 
     SkScaledBitmapSampler sampler(cinfo.output_width, cinfo.output_height, sampleSize);
     // Assume an A8 bitmap is not opaque to avoid the check of each
     // individual pixel. It is very unlikely to be opaque, since
     // an opaque A8 bitmap would not be very interesting.
     // Otherwise, a jpeg image is opaque.
-    bm->setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0,
-                  SkBitmap::kA8_Config != config ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
+    bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
+                                  colorType, alphaType));
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
     if (!this->allocPixelRef(bm, NULL)) {
         return return_false(cinfo, *bm, "allocPixelRef");
     }
 
     SkAutoLockPixels alp(*bm);
 
 #ifdef ANDROID_RGB
     /* short-circuit the SkScaledBitmapSampler when possible, as this gives
        a significant performance boost.
     */
     if (sampleSize == 1 &&
-        ((config == SkBitmap::kARGB_8888_Config &&
-                cinfo.out_color_space == JCS_RGBA_8888) ||
-        (config == SkBitmap::kRGB_565_Config &&
-                cinfo.out_color_space == JCS_RGB_565)))
+        ((kN32_SkColorType == colorType && cinfo.out_color_space == JCS_RGBA_8888) ||
+         (kRGB_565_SkColorType == colorType && cinfo.out_color_space == JCS_RGB_565)))
     {
         JSAMPLE* rowptr = (JSAMPLE*)bm->getPixels();
         INT32 const bpr =  bm->rowBytes();
 
         while (cinfo.output_scanline < cinfo.output_height) {
             int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
             if (0 == row_count) {
                 // if row_count == 0, then we didn't get a scanline,
                 // so return early.  We will return a partial image.
                 fill_below_level(cinfo.output_scanline, bm);
@@ skipping 99 matching lines @@
 
     // Init decoder to image decode mode
     if (!imageIndex->initializeInfoAndReadHeader()) {
         return false;
     }
 
     // FIXME: This sets cinfo->out_color_space, which we may change later
     // based on the config in onDecodeSubset. This should be fine, since
     // jpeg_init_read_tile_scanline will check out_color_space again after
     // that change (when it calls jinit_color_deconverter).
-    (void) this->getBitmapConfig(cinfo);
+    (void) this->getBitmapColorType(cinfo);
 
     turn_off_visual_optimizations(cinfo);
 
     // instead of jpeg_start_decompress() we start a tiled decompress
     if (!imageIndex->startTileDecompress()) {
         return false;
     }
 
     SkASSERT(1 == cinfo->scale_num);
     fImageWidth = cinfo->output_width;
@@ skipping 30 matching lines @@
 
     if (setjmp(errorManager.fJmpBuf)) {
         return false;
     }
 
     int requestedSampleSize = this->getSampleSize();
     cinfo->scale_denom = requestedSampleSize;
 
     set_dct_method(*this, cinfo);
 
-    const SkBitmap::Config config = this->getBitmapConfig(cinfo);
-#ifdef ANDROID_RGB
-    adjust_out_color_space_and_dither(cinfo, config, *this);
-#endif
+    const SkColorType colorType = this->getBitmapColorType(cinfo);
+    adjust_out_color_space_and_dither(cinfo, colorType, *this);
 
     int startX = rect.fLeft;
     int startY = rect.fTop;
     int width = rect.width();
     int height = rect.height();
 
     jpeg_init_read_tile_scanline(cinfo, fImageIndex->huffmanIndex(),
                                  &startX, &startY, &width, &height);
     int skiaSampleSize = recompute_sampleSize(requestedSampleSize, *cinfo);
     int actualSampleSize = skiaSampleSize * (DCTSIZE / cinfo->min_DCT_scaled_size);
 
     SkScaledBitmapSampler sampler(width, height, skiaSampleSize);
 
     SkBitmap bitmap;
-    bitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight());
     // Assume an A8 bitmap is not opaque to avoid the check of each
     // individual pixel. It is very unlikely to be opaque, since
     // an opaque A8 bitmap would not be very interesting.
     // Otherwise, a jpeg image is opaque.
-    bitmap.setConfig(config, sampler.scaledWidth(), sampler.scaledHeight(), 0,
-                     config == SkBitmap::kA8_Config ? kPremul_SkAlphaType :
-                     kOpaque_SkAlphaType);
+    bitmap.setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(), colorType,
+                                     kAlpha_8_SkColorType == colorType ?
+                                         kPremul_SkAlphaType : kOpaque_SkAlphaType));
 
     // Check ahead of time if the swap(dest, src) is possible or not.
     // 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() / actualSampleSize;
     int h = rect.height() / actualSampleSize;
     bool swapOnly = (rect == region) && bm->isNull() &&
                     (w == bitmap.width()) && (h == bitmap.height()) &&
                     ((startX - rect.x()) / actualSampleSize == 0) &&
                     ((startY - rect.y()) / actualSampleSize == 0);
     if (swapOnly) {
         if (!this->allocPixelRef(&bitmap, NULL)) {
             return return_false(*cinfo, bitmap, "allocPixelRef");
         }
     } else {
         if (!bitmap.allocPixels()) {
             return return_false(*cinfo, bitmap, "allocPixels");
         }
     }
 
     SkAutoLockPixels alp(bitmap);
 
 #ifdef ANDROID_RGB
     /* short-circuit the SkScaledBitmapSampler when possible, as this gives
        a significant performance boost.
     */
     if (skiaSampleSize == 1 &&
-        ((config == SkBitmap::kARGB_8888_Config &&
-                cinfo->out_color_space == JCS_RGBA_8888) ||
-        (config == SkBitmap::kRGB_565_Config &&
-                cinfo->out_color_space == JCS_RGB_565)))
+        ((kN32_SkColorType == colorType && cinfo->out_color_space == JCS_RGBA_8888) ||
+         (kRGB_565_SkColorType == colorType && cinfo->out_color_space == JCS_RGB_565)))
     {
         JSAMPLE* rowptr = (JSAMPLE*)bitmap.getPixels();
         INT32 const bpr = bitmap.rowBytes();
         int rowTotalCount = 0;
 
         while (rowTotalCount < height) {
             int rowCount = jpeg_read_tile_scanline(cinfo,
                                                    fImageIndex->huffmanIndex(),
                                                    &rowptr);
             // if rowCount == 0, then we didn't get a scanline, so abort.
@@ skipping 223 matching lines @@
         uint32_t c = ctable[*src++];
         dst[0] = SkGetPackedR32(c);
         dst[1] = SkGetPackedG32(c);
         dst[2] = SkGetPackedB32(c);
 #endif
         dst += 3;
     }
 }
 
 static WriteScanline ChooseWriter(const SkBitmap& bm) {
-    switch (bm.config()) {
-        case SkBitmap::kARGB_8888_Config:
+    switch (bm.colorType()) {
+        case kN32_SkColorType:
             return Write_32_YUV;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             return Write_16_YUV;
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             return Write_4444_YUV;
-        case SkBitmap::kIndex8_Config:
+        case kIndex_8_SkColorType:
             return Write_Index_YUV;
         default:
             return NULL;
     }
 }
 
 class SkJPEGImageEncoder : public SkImageEncoder {
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) {
 #ifdef TIME_ENCODE
@@ skipping 103 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kJPEG_Type == t) ? SkNEW(SkJPEGImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libjpeg_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_jpeg);
 static SkImageEncoder_EncodeReg gEReg(sk_libjpeg_efactory);