Make Jpeg decoding more fault resistant.

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"
 #include "SkJpegUtility.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
 #include "SkScaledBitmapSampler.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTime.h"
 #include "SkUtils.h"
 #include "SkRect.h"
 #include "SkCanvas.h"
 
+#if defined(SK_DEBUG)
+#include "SkRTConf.h"  // SK_CONF_DECLARE
+#endif  // defined(SK_DEBUG)
+
 #include <stdio.h>
 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
 #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.
 
+#if defined(SK_DEBUG)
+SK_CONF_DECLARE(bool, c_suppressJPEGImageDecoderWarnings,
+    "images.jpeg.suppressDecoderWarnings", false,
+    "Suppress most JPG warnings when calling decode functions.");
+#endif  // defined(SK_DEBUG)
+
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
 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 do_nothing_emit_message(jpeg_common_struct*, int) {
+    /* do nothing */
+}
+
 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;
+#if defined(SK_DEBUG)
+    /* To suppress warnings with a SK_DEBUG binary, set the
+     * environment variable "skia_images_jpeg_suppressDecoderWarnings"
+     * to "true".  Inside a program that links to skia:
+     * SK_CONF_SET("images.jpeg.suppressDecoderWarnings", true); */
+    if (c_suppressJPEGImageDecoderWarnings) {
+        cinfo->err->emit_message = &do_nothing_emit_message;
+    }
+#else  // Always suppress in release mode.
+    cinfo->err->emit_message = &do_nothing_emit_message;
+#endif  //defined(SK_DEBUG)
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 class SkJPEGImageIndex {
 public:
     SkJPEGImageIndex(SkStreamRewindable* stream, SkImageDecoder* decoder)
         : fSrcMgr(stream, decoder)
         , fInfoInitialized(false)
         , fHuffmanCreated(false)
         , fDecompressStarted(false)
@@ skipping 476 matching lines @@
                 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 row_count == 0, then we didn't get a scanline, so abort.
             // if we supported partial images, we might return true in this case
             if (0 == row_count) {
-                return return_false(cinfo, *bm, "read_scanlines");
+                return true;

[scroggo, 2013/10/02 17:05:04]

The remaining rows will still be uninitialized.

             }
             if (this->shouldCancelDecode()) {
                 return return_false(cinfo, *bm, "shouldCancelDecode");
             }
             rowptr += bpr;
         }
         jpeg_finish_decompress(&cinfo);
         return true;
     }
 #endif
@@ skipping 29 matching lines @@
     //  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;
         int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
         if (0 == row_count) {
-            return return_false(cinfo, *bm, "read_scanlines");
+            return true;

[scroggo, 2013/10/02 17:05:04]

Ditto

         }
         if (this->shouldCancelDecode()) {
             return return_false(cinfo, *bm, "shouldCancelDecode");
         }
 
         if (JCS_CMYK == cinfo.out_color_space) {
             convert_CMYK_to_RGB(srcRow, cinfo.output_width);
         }
 
         sampler.next(srcRow);
@@ skipping 161 matching lines @@
         INT32 const bpr = bitmap.rowBytes();
         int rowTotalCount = 0;
 
         while (rowTotalCount < height) {
             int rowCount = jpeg_read_tile_scanline(cinfo,
                                                    fImageIndex->huffmanIndex(),
                                                    &rowptr);
             // if row_count == 0, then we didn't get a scanline, so abort.
             // if we supported partial images, we might return true in this case
             if (0 == rowCount) {
-                return return_false(*cinfo, bitmap, "read_scanlines");
+                return true;

[scroggo, 2013/10/02 17:05:04]

Ditto

             }
             if (this->shouldCancelDecode()) {
                 return return_false(*cinfo, bitmap, "shouldCancelDecode");
             }
             rowTotalCount += rowCount;
             rowptr += bpr;
         }
 
         if (swapOnly) {
             bm->swap(bitmap);
@@ skipping 36 matching lines @@
     //  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;
         int row_count = jpeg_read_tile_scanline(cinfo, fImageIndex->huffmanIndex(), &rowptr);
         if (0 == row_count) {
-            return return_false(*cinfo, bitmap, "read_scanlines");
+            return true;

[scroggo, 2013/10/02 17:05:04]

Ditto

         }
         if (this->shouldCancelDecode()) {
             return return_false(*cinfo, bitmap, "shouldCancelDecode");
         }
 
         if (JCS_CMYK == cinfo->out_color_space) {
             convert_CMYK_to_RGB(srcRow, width);
         }
 
         sampler.next(srcRow);
@@ skipping 293 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);