Image decoder fixes (mostly) around A8.

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 477 matching lines @@
    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));
     canvas.drawColor(SK_ColorWHITE);
 }
 
+/**
+ *  Get the config and bytes per pixel of the source data. Return
+ *  whether the data is supported.
+ */
+static bool get_src_config(const jpeg_decompress_struct& cinfo,
+                           SkScaledBitmapSampler::SrcConfig* sc,
+                           int* srcBytesPerPixel) {
+    SkASSERT(sc != NULL && srcBytesPerPixel != NULL);
+    if (JCS_CMYK == cinfo.out_color_space) {
+        // In this case we will manually convert the CMYK values to RGB
+        *sc = SkScaledBitmapSampler::kRGBX;
+        // The CMYK work-around relies on 4 components per pixel here
+        *srcBytesPerPixel = 4;
+    } else if (3 == cinfo.out_color_components && JCS_RGB == cinfo.out_color_space) {
+        *sc = SkScaledBitmapSampler::kRGB;
+        *srcBytesPerPixel = 3;
+#ifdef ANDROID_RGB
+    } else if (JCS_RGBA_8888 == cinfo.out_color_space) {
+        *sc = SkScaledBitmapSampler::kRGBX;
+        *srcBytesPerPixel = 4;
+    } else if (JCS_RGB_565 == cinfo.out_color_space) {
+        *sc = SkScaledBitmapSampler::kRGB_565;
+        *srcBytesPerPixel = 2;
+#endif
+    } else if (1 == cinfo.out_color_components &&
+               JCS_GRAYSCALE == cinfo.out_color_space) {
+        *sc = SkScaledBitmapSampler::kGray;
+        *srcBytesPerPixel = 1;
+    } else {
+        return false;
+    }
+    return true;
+}
 
 bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
 #ifdef TIME_DECODE
     SkAutoTime atm("JPEG Decode");
 #endif
 
     JPEGAutoClean autoClean;
 
     jpeg_decompress_struct  cinfo;
     skjpeg_source_mgr       srcManager(stream, this);
@@ skipping 28 matching lines @@
 
     turn_off_visual_optimizations(&cinfo);
 
     const SkBitmap::Config config = this->getBitmapConfig(&cinfo);
 
 #ifdef ANDROID_RGB
     adjust_out_color_space_and_dither(&cinfo, config, *this);
 #endif
 
     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);
     }
 
     /*  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);
         } 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)) {
         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);
     if (SkImageDecoder::kDecodeBounds_Mode == mode) {
         return true;
     }
     if (!this->allocPixelRef(bm, NULL)) {
         return return_false(cinfo, *bm, "allocPixelRef");
     }
 
     SkAutoLockPixels alp(*bm);
@@ skipping 25 matching lines @@
             }
             rowptr += bpr;
         }
         jpeg_finish_decompress(&cinfo);
         return true;
     }
 #endif
 
     // check for supported formats
     SkScaledBitmapSampler::SrcConfig sc;
-    if (JCS_CMYK == cinfo.out_color_space) {
-        // In this case we will manually convert the CMYK values to RGB
-        sc = SkScaledBitmapSampler::kRGBX;
-    } else if (3 == cinfo.out_color_components && JCS_RGB == cinfo.out_color_space) {
-        sc = SkScaledBitmapSampler::kRGB;
-#ifdef ANDROID_RGB
-    } else if (JCS_RGBA_8888 == cinfo.out_color_space) {
-        sc = SkScaledBitmapSampler::kRGBX;
-    } else if (JCS_RGB_565 == cinfo.out_color_space) {
-        sc = SkScaledBitmapSampler::kRGB_565;
-#endif
-    } else if (1 == cinfo.out_color_components &&
-               JCS_GRAYSCALE == cinfo.out_color_space) {
-        sc = SkScaledBitmapSampler::kGray;
-    } else {
+    int srcBytesPerPixel;
+
+    if (!get_src_config(cinfo, &sc, &srcBytesPerPixel)) {
         return return_false(cinfo, *bm, "jpeg colorspace");
     }
 
     if (!sampler.begin(bm, sc, *this)) {
         return return_false(cinfo, *bm, "sampler.begin");
     }
 
-    // The CMYK work-around relies on 4 components per pixel here
-    SkAutoMalloc srcStorage(cinfo.output_width * 4);
+    SkAutoMalloc srcStorage(cinfo.output_width * srcBytesPerPixel);
     uint8_t* srcRow = (uint8_t*)srcStorage.get();
 
     //  Possibly skip initial rows [sampler.srcY0]
     if (!skip_src_rows(&cinfo, srcRow, sampler.srcY0())) {
         return return_false(cinfo, *bm, "skip rows");
     }
 
     // now loop through scanlines until y == bm->height() - 1
     for (int y = 0;; y++) {
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
@@ skipping 132 matching lines @@
     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);
 
     // 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()) &&
@@ skipping 47 matching lines @@
         } else {
             cropBitmap(bm, &bitmap, actualSampleSize, region.x(), region.y(),
                        region.width(), region.height(), startX, startY);
         }
         return true;
     }
 #endif
 
     // check for supported formats
     SkScaledBitmapSampler::SrcConfig sc;
-    if (JCS_CMYK == cinfo->out_color_space) {
-        // In this case we will manually convert the CMYK values to RGB
-        sc = SkScaledBitmapSampler::kRGBX;
-    } else if (3 == cinfo->out_color_components && JCS_RGB == cinfo->out_color_space) {
-        sc = SkScaledBitmapSampler::kRGB;
-#ifdef ANDROID_RGB
-    } else if (JCS_RGBA_8888 == cinfo->out_color_space) {
-        sc = SkScaledBitmapSampler::kRGBX;
-    } else if (JCS_RGB_565 == cinfo->out_color_space) {
-        sc = SkScaledBitmapSampler::kRGB_565;
-#endif
-    } else if (1 == cinfo->out_color_components &&
-               JCS_GRAYSCALE == cinfo->out_color_space) {
-        sc = SkScaledBitmapSampler::kGray;
-    } else {
+    int srcBytesPerPixel;
+
+    if (!get_src_config(*cinfo, &sc, &srcBytesPerPixel)) {
         return return_false(*cinfo, *bm, "jpeg colorspace");
     }
 
     if (!sampler.begin(&bitmap, sc, *this)) {
         return return_false(*cinfo, bitmap, "sampler.begin");
     }
 
-    // The CMYK work-around relies on 4 components per pixel here
-    SkAutoMalloc  srcStorage(width * 4);
+    SkAutoMalloc  srcStorage(width * srcBytesPerPixel);
     uint8_t* srcRow = (uint8_t*)srcStorage.get();
 
     //  Possibly skip initial rows [sampler.srcY0]
     if (!skip_src_rows_tile(cinfo, fImageIndex->huffmanIndex(), srcRow, sampler.srcY0())) {
         return return_false(*cinfo, bitmap, "skip rows");
     }
 
     // now loop through scanlines until y == bitmap->height() - 1
     for (int y = 0;; y++) {
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
@@ skipping 309 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);