Make Jpeg decoding more fault resistant.

src/images/SkImageDecoder_libpng.cpp

 
 /*
  * Copyright 2006 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"
@@ skipping 181 matching lines @@
     png_bytep trans;
     int num_trans;
 
     if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
         png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL);
         return num_trans > 0;
     }
     return false;
 }
 
+void do_nothing(png_structp, png_const_charp) { /* do nothing */ }

[scroggo, 2013/10/01 22:04:14]

More specific name?

+
+
 bool SkPNGImageDecoder::onDecodeInit(SkStream* sk_stream, png_structp *png_ptrp,
                                      png_infop *info_ptrp) {
     /* Create and initialize the png_struct with the desired error handler
     * functions.  If you want to use the default stderr and longjump method,
     * you can supply NULL for the last three parameters.  We also supply the
     * the compiler header file version, so that we know if the application
     * was compiled with a compatible version of the library.  */
     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
         NULL, sk_error_fn, NULL);
     //   png_voidp user_error_ptr, user_error_fn, user_warning_fn);
     if (png_ptr == NULL) {
         return false;
     }
+
+    png_error_ptr warning_fn = &do_nothing;

[scroggo, 2013/10/01 22:04:14]

Again, this stuff should only be done

#if !defined(SK_DEBUG)

so that we can still see errors in debug mode (unless you think these are never
errors?).

Also, these statements overwrite the functions set by png_create_read_struct,
above.

+    png_voidp error_ptr = png_get_error_ptr(png_ptr);
+    png_error_ptr error_fn = NULL;  // leave as default
+    png_set_error_fn(png_ptr, error_ptr, error_fn, warning_fn);
+
     *png_ptrp = png_ptr;
 
     /* Allocate/initialize the memory for image information. */
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (info_ptr == NULL) {
         png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
         return false;
     }
     *info_ptrp = info_ptr;
 
@@ skipping 263 matching lines @@
                 which means we will find more matches than we should. The real
                 fix seems to be to see the actual 16bit components, do the
                 compare, and then knock it down to 8bits ourselves.
             */
             if (colorType & PNG_COLOR_MASK_COLOR) {
                 if (16 == bitDepth) {
                     *theTranspColorp = SkPackARGB32(0xFF, transpColor->red >> 8,
                                                     transpColor->green >> 8,
                                                     transpColor->blue >> 8);
                 } else {
-                    *theTranspColorp = SkPackARGB32(0xFF, transpColor->red,
-                                                    transpColor->green,
-                                                    transpColor->blue);
+                    *theTranspColorp = SkPackARGB32(0xFF,
+                                                    0xFF & (transpColor->red),
+                                                    0xFF & (transpColor->green),
+                                                    0xFF & (transpColor->blue));
+                    /* We apply the mask because in a very small

[scroggo, 2013/10/01 22:04:14]

Shouldn't this go above the code it applies to?

+                       number of corrupt PNGs, (transpColor->red > 255)
+                       and (bitDepth == 8), for certain versions of libpng. */
                 }
             } else {    // gray
                 if (16 == bitDepth) {
                     *theTranspColorp = SkPackARGB32(0xFF, transpColor->gray >> 8,
                                                     transpColor->gray >> 8,
                                                     transpColor->gray >> 8);
                 } else {
-                    *theTranspColorp = SkPackARGB32(0xFF, transpColor->gray,
-                                                    transpColor->gray,
-                                                    transpColor->gray);
+                    *theTranspColorp = SkPackARGB32(0xFF,

[scroggo, 2013/10/01 22:04:14]

Similar comment explaining the mask?

+                                                    0xFF & (transpColor->gray),
+                                                    0xFF & (transpColor->gray),
+                                                    0xFF & (transpColor->gray));
                 }
             }
         }
 
         if (valid ||
             PNG_COLOR_TYPE_RGB_ALPHA == colorType ||
             PNG_COLOR_TYPE_GRAY_ALPHA == colorType) {
             *hasAlphap = true;
         }
 
@@ skipping 671 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kPNG_Type == t) ? SkNEW(SkPNGImageEncoder) : NULL;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libpng_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_png);
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);