Beginning work to refactor jpeg tile decoding.

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 12 matching lines @@
 extern "C" {
     #include "jpeglib.h"
     #include "jerror.h"
 }
 
 // These enable timing code that report milliseconds for an encoding/decoding
 //#define TIME_ENCODE
 //#define TIME_DECODE
 
 // this enables our rgb->yuv code, which is faster than libjpeg on ARM
-// disable for the moment, as we have some glitches when width != multiple of 4
 #define WE_CONVERT_TO_YUV
 
 // If ANDROID_RGB is defined by in the jpeg headers it indicates that jpeg offers
 // support for two additional formats (1) JCS_RGBA_8888 and (2) JCS_RGB_565.
 
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
-static void overwrite_mem_buffer_size(j_decompress_ptr cinfo) {
+static void overwrite_mem_buffer_size(jpeg_decompress_struct* cinfo) {
 #ifdef SK_BUILD_FOR_ANDROID
     /* Check if the device indicates that it has a large amount of system memory
      * if so, increase the memory allocation to 30MB instead of the default 5MB.
      */
 #ifdef ANDROID_LARGE_MEMORY_DEVICE
     cinfo->mem->max_memory_to_use = 30 * 1024 * 1024;
 #else
     cinfo->mem->max_memory_to_use = 5 * 1024 * 1024;
 #endif
 #endif // SK_BUILD_FOR_ANDROID
 }
 
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
+static void initialize_info(jpeg_decompress_struct* cinfo, skjpeg_source_mgr* src_mgr) {
+    SkASSERT(cinfo != NULL);
+    SkASSERT(src_mgr != NULL);
+    jpeg_create_decompress(cinfo);
+    overwrite_mem_buffer_size(cinfo);
+    cinfo->src = src_mgr;
+}
+
 #ifdef SK_BUILD_FOR_ANDROID
 class SkJPEGImageIndex {
 public:
     SkJPEGImageIndex(SkStream* stream, SkImageDecoder* decoder)
         : fSrcMgr(stream, decoder)
         , fInfoInitialized(false)
         , fHuffmanCreated(false)
         , fDecompressStarted(false)
         {
             SkDEBUGCODE(fReadHeaderSucceeded = false;)
         }
 
     ~SkJPEGImageIndex() {
         if (fHuffmanCreated) {
+            // Set to false before calling the libjpeg function, in case
+            // the libjpeg function calls longjmp. Our setjmp handler may
+            // attempt to delete this SkJPEGImageIndex, thus entering this
+            // destructor again. Setting fHuffmanCreated to false first
+            // prevents an infinite loop.
             fHuffmanCreated = false;
             jpeg_destroy_huffman_index(&fHuffmanIndex);
         }
         if (fDecompressStarted) {
+            // Like fHuffmanCreated, set to false before calling libjpeg
+            // function to prevent potential infinite loop.
             fDecompressStarted = false;
             jpeg_finish_decompress(&fCInfo);
         }
         if (fInfoInitialized) {
             this->destroyInfo();
         }
     }
 
     /**
      *  Destroy the cinfo struct.
      *  After this call, if a huffman index was already built, it
      *  can be used after calling initializeInfoAndReadHeader
      *  again. Must not be called after startTileDecompress except
      *  in the destructor.
      */
     void destroyInfo() {
         SkASSERT(fInfoInitialized);
         SkASSERT(!fDecompressStarted);
+        // Like fHuffmanCreated, set to false before calling libjpeg
+        // function to prevent potential infinite loop.
         fInfoInitialized = false;
         jpeg_destroy_decompress(&fCInfo);
         SkDEBUGCODE(fReadHeaderSucceeded = false;)
     }
 
     /**
      *  Initialize the cinfo struct.
      *  Calls jpeg_create_decompress, makes customizations, and
      *  finally calls jpeg_read_header. Returns true if jpeg_read_header
      *  returns JPEG_HEADER_OK.
      *  If cinfo was already initialized, destroyInfo must be called to
      *  destroy the old one. Must not be called after startTileDecompress.
      */
     bool initializeInfoAndReadHeader() {
         SkASSERT(!fInfoInitialized && !fDecompressStarted);
-        jpeg_create_decompress(&fCInfo);
-        overwrite_mem_buffer_size(&fCInfo);
-        fCInfo.src = &fSrcMgr;
+        initialize_info(&fCInfo, &fSrcMgr);
         fInfoInitialized = true;
         const bool success = (JPEG_HEADER_OK == jpeg_read_header(&fCInfo, true));
         SkDEBUGCODE(fReadHeaderSucceeded = success;)
         return success;
     }
 
     jpeg_decompress_struct* cinfo() { return &fCInfo; }
 
     huffman_index* huffmanIndex() { return &fHuffmanIndex; }
 
@@ skipping 64 matching lines @@
 #endif
     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
+     *  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*);
+
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
 /* Automatically clean up after throwing an exception */
 class JPEGAutoClean {
 public:
     JPEGAutoClean(): cinfo_ptr(NULL) {}
     ~JPEGAutoClean() {
@@ skipping 82 matching lines @@
     //    C = ( (1-C) * (1 - (1-K) + (1-K) ) -> C = 1 - C*K
     // The conversion from CMY->RGB remains the same
     for (unsigned int x = 0; x < width; ++x, scanline += 4) {
         scanline[0] = SkMulDiv255Round(scanline[0], scanline[3]);
         scanline[1] = SkMulDiv255Round(scanline[1], scanline[3]);
         scanline[2] = SkMulDiv255Round(scanline[2], scanline[3]);
         scanline[3] = 255;
     }
 }
 
+/**
+ *  Common code for setting the error manager.
+ */
+static void set_error_mgr(jpeg_decompress_struct* cinfo, skjpeg_error_mgr* errorManager) {
+    SkASSERT(cinfo != NULL);
+    SkASSERT(errorManager != NULL);
+    cinfo->err = jpeg_std_error(errorManager);
+    errorManager->error_exit = skjpeg_error_exit;
+}
+
+/**
+ *  Common code for turning off upsampling and smoothing. Turning these
+ *  off helps performance without showing noticable differences in the
+ *  resulting bitmap.
+ */
+static void turn_off_visual_optimizations(jpeg_decompress_struct* cinfo) {
+    SkASSERT(cinfo != NULL);
+    /* this gives about 30% performance improvement. In theory it may
+       reduce the visual quality, in practice I'm not seeing a difference
+     */
+    cinfo->do_fancy_upsampling = 0;
+
+    /* this gives another few percents */
+    cinfo->do_block_smoothing = 0;
+}
+
+/**
+ * Common code for setting the dct method.
+ */
+static void set_dct_method(const SkImageDecoder& decoder, jpeg_decompress_struct* cinfo) {
+    SkASSERT(cinfo != NULL);
+#ifdef DCT_IFAST_SUPPORTED
+    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) {
+    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,
+            // in which case we will treat the grayscale as alpha
+            // values.
+            if (cinfo->jpeg_color_space != JCS_GRAYSCALE) {
+                config = SkBitmap::kARGB_8888_Config;
+            }
+            break;
+        case SkBitmap::kARGB_8888_Config:
+            // Fall through.
+        case SkBitmap::kARGB_4444_Config:
+            // Fall through.
+        case SkBitmap::kRGB_565_Config:
+            // These are acceptable destination configs.
+            break;
+        default:
+            // Force all other configs to 8888.
+            config = SkBitmap::kARGB_8888_Config;
+            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) {
+                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.
+        default:
+            cinfo->out_color_space = JCS_RGB;
+            break;
+    }
+    return config;
+}
+
+#ifdef ANDROID_RGB
+/**
+ *  Based on the config and dither mode, adjust out_color_space and
+ *  dither_mode of cinfo.
+ */
+static void adjust_out_color_space_and_dither(jpeg_decompress_struct* cinfo,
+                                              SkBitmap::Config config,
+                                              const SkImageDecoder& decoder) {
+    SkASSERT(cinfo != NULL);
+    cinfo->dither_mode = JDITHER_NONE;
+    if (JCS_CMYK == cinfo->out_color_space) {
+        return;
+    }
+    switch(config) {
+        case SkBitmap::kARGB_8888_Config:
+            cinfo->out_color_space = JCS_RGBA_8888;
+            break;
+        case SkBitmap::kRGB_565_Config:
+            cinfo->out_color_space = JCS_RGB_565;
+            if (decoder.getDitherImage()) {
+                cinfo->dither_mode = JDITHER_ORDERED;
+            }
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
 bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
 #ifdef TIME_DECODE
     SkAutoTime atm("JPEG Decode");
 #endif
 
     JPEGAutoClean autoClean;
 
     jpeg_decompress_struct  cinfo;
-    skjpeg_error_mgr        errorManager;
     skjpeg_source_mgr       srcManager(stream, this);
 
-    cinfo.err = jpeg_std_error(&errorManager);
-    errorManager.error_exit = skjpeg_error_exit;
+    skjpeg_error_mgr errorManager;
+    set_error_mgr(&cinfo, &errorManager);
 
     // All objects need to be instantiated before this setjmp call so that
     // they will be cleaned up properly if an error occurs.
     if (setjmp(errorManager.fJmpBuf)) {
         return return_false(cinfo, *bm, "setjmp");
     }
 
-    jpeg_create_decompress(&cinfo);
+    initialize_info(&cinfo, &srcManager);
     autoClean.set(&cinfo);
 
-    overwrite_mem_buffer_size(&cinfo);
-
-    //jpeg_stdio_src(&cinfo, file);
-    cinfo.src = &srcManager;
-
     int status = jpeg_read_header(&cinfo, true);
     if (status != JPEG_HEADER_OK) {
         return return_false(cinfo, *bm, "read_header");
     }
 
     /*  Try to fulfill the requested sampleSize. Since jpeg can do it (when it
         can) much faster that we, just use their num/denom api to approximate
         the size.
     */
     int sampleSize = this->getSampleSize();
 
-#ifdef DCT_IFAST_SUPPORTED
-    if (this->getPreferQualityOverSpeed()) {
-        cinfo.dct_method = JDCT_ISLOW;
-    } else {
-        cinfo.dct_method = JDCT_IFAST;
-    }
-#else
-    cinfo.dct_method = JDCT_ISLOW;
-#endif
+    set_dct_method(*this, &cinfo);
 
-    cinfo.scale_num = 1;
+    SkASSERT(1 == cinfo.scale_num);
     cinfo.scale_denom = sampleSize;
 
-    /* this gives about 30% performance improvement. In theory it may
-       reduce the visual quality, in practice I'm not seeing a difference
-     */
-    cinfo.do_fancy_upsampling = 0;
+    turn_off_visual_optimizations(&cinfo);
 
-    /* this gives another few percents */
-    cinfo.do_block_smoothing = 0;
-
-    SrcDepth srcDepth = k32Bit_SrcDepth;
-    /* default format is RGB */
-    if (cinfo.jpeg_color_space == JCS_CMYK) {
-        // libjpeg cannot convert from CMYK 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;
-    } else if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
-        cinfo.out_color_space = JCS_GRAYSCALE;
-        srcDepth = k8BitGray_SrcDepth;
-    } else {
-        cinfo.out_color_space = JCS_RGB;
-    }
-
-    SkBitmap::Config config = this->getPrefConfig(srcDepth, false);
-    // only these make sense for jpegs
-    if (SkBitmap::kA8_Config == config) {
-        if (cinfo.jpeg_color_space != JCS_GRAYSCALE) {
-            // Converting from a non grayscale image to A8 is
-            // not currently supported.
-            config = SkBitmap::kARGB_8888_Config;
-            // Change the output from jpeg back to RGB.
-            cinfo.out_color_space = JCS_RGB;
-        }
-    } else if (config != SkBitmap::kARGB_8888_Config &&
-               config != SkBitmap::kARGB_4444_Config &&
-               config != SkBitmap::kRGB_565_Config) {
-        config = SkBitmap::kARGB_8888_Config;
-    }
+    const SkBitmap::Config config = this->getBitmapConfig(&cinfo);
 
 #ifdef ANDROID_RGB
-    cinfo.dither_mode = JDITHER_NONE;
-    if (SkBitmap::kARGB_8888_Config == config && JCS_CMYK != cinfo.out_color_space) {
-        cinfo.out_color_space = JCS_RGBA_8888;
-    } else if (SkBitmap::kRGB_565_Config == config && JCS_CMYK != cinfo.out_color_space) {
-        cinfo.out_color_space = JCS_RGB_565;
-        if (this->getDitherImage()) {
-            cinfo.dither_mode = JDITHER_ORDERED;
-        }
-    }
+    adjust_out_color_space_and_dither(&cinfo, config, *this);
 #endif
 
     if (1 == sampleSize && SkImageDecoder::kDecodeBounds_Mode == mode) {
         bm->setConfig(config, cinfo.image_width, cinfo.image_height);
         bm->setIsOpaque(config != SkBitmap::kA8_Config);
         return true;
     }
 
     /*  image_width and image_height are the original dimensions, available
         after jpeg_read_header(). To see the scaled dimensions, we have to call
@@ skipping 137 matching lines @@
     return true;
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 bool SkJPEGImageDecoder::onBuildTileIndex(SkStream* stream, int *width, int *height) {
 
     SkAutoTDelete<SkJPEGImageIndex> imageIndex(SkNEW_ARGS(SkJPEGImageIndex, (stream, this)));
     jpeg_decompress_struct* cinfo = imageIndex->cinfo();
 
     skjpeg_error_mgr sk_err;
-    cinfo->err = jpeg_std_error(&sk_err);
-    sk_err.error_exit = skjpeg_error_exit;
+    set_error_mgr(cinfo, &sk_err);
 
     // All objects need to be instantiated before this setjmp call so that
     // they will be cleaned up properly if an error occurs.
     if (setjmp(sk_err.fJmpBuf)) {
         return false;
     }
 
     // create the cinfo used to create/build the huffmanIndex
     if (!imageIndex->initializeInfoAndReadHeader()) {
         return false;
     }
 
     if (!imageIndex->buildHuffmanIndex()) {
         return false;
     }
 
     // destroy the cinfo used to create/build the huffman index
     imageIndex->destroyInfo();
 
     // Init decoder to image decode mode
     if (!imageIndex->initializeInfoAndReadHeader()) {
         return false;
     }
 
-    cinfo->out_color_space = JCS_RGBA_8888;
-    cinfo->do_fancy_upsampling = 0;
-    cinfo->do_block_smoothing = 0;
+    // 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);
+
+    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);
-    *height = cinfo->output_height;
-    *width = cinfo->output_width;
-    fImageWidth = *width;
-    fImageHeight = *height;
+    fImageWidth = cinfo->output_width;
+    fImageHeight = cinfo->output_height;
+
+    if (width) {
+        *width = fImageWidth;
+    }
+    if (height) {
+        *height = fImageHeight;
+    }
 
     SkDELETE(fImageIndex);
     fImageIndex = imageIndex.detach();
 
     return true;
 }
 
 bool SkJPEGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) {
     if (NULL == fImageIndex) {
         return false;
     }
     jpeg_decompress_struct* cinfo = fImageIndex->cinfo();
 
     SkIRect rect = SkIRect::MakeWH(fImageWidth, fImageHeight);
     if (!rect.intersect(region)) {
         // If the requested region is entirely outside the image return false
         return false;
     }
 
 
     skjpeg_error_mgr errorManager;
-    cinfo->err = jpeg_std_error(&errorManager);
-    errorManager.error_exit = skjpeg_error_exit;
+    set_error_mgr(cinfo, &errorManager);
+
     if (setjmp(errorManager.fJmpBuf)) {
         return false;
     }
 
     int requestedSampleSize = this->getSampleSize();
     cinfo->scale_denom = requestedSampleSize;
 
-    if (this->getPreferQualityOverSpeed()) {
-        cinfo->dct_method = JDCT_ISLOW;
-    } else {
-        cinfo->dct_method = JDCT_IFAST;
-    }
+    set_dct_method(*this, cinfo);
 
-    SkBitmap::Config config = this->getPrefConfig(k32Bit_SrcDepth, false);
-    if (config != SkBitmap::kARGB_8888_Config &&
-        config != SkBitmap::kARGB_4444_Config &&
-        config != SkBitmap::kRGB_565_Config) {
-        config = SkBitmap::kARGB_8888_Config;
-    }
-
-    /* default format is RGB */
-    cinfo->out_color_space = JCS_RGB;
-
+    const SkBitmap::Config config = this->getBitmapConfig(cinfo);
 #ifdef ANDROID_RGB
-    cinfo->dither_mode = JDITHER_NONE;
-    if (SkBitmap::kARGB_8888_Config == config) {
-        cinfo->out_color_space = JCS_RGBA_8888;
-    } else if (SkBitmap::kRGB_565_Config == config) {
-        cinfo->out_color_space = JCS_RGB_565;
-        if (this->getDitherImage()) {
-            cinfo->dither_mode = JDITHER_ORDERED;
-        }
-    }
+    adjust_out_color_space_and_dither(cinfo, config, *this);
 #endif
 
     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);
@@ skipping 414 matching lines @@
 }
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kJPEG_Type == t) ? SkNEW(SkJPEGImageEncoder) : NULL;
 }
 
 
 static SkTRegistry<SkImageDecoder*, SkStream*> gDReg(sk_libjpeg_dfactory);
 static SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_jpeg);
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_libjpeg_efactory);