diff --git a/src/images/SkImageDecoder_libjpeg.cpp b/src/images/SkImageDecoder_libjpeg.cpp
index 3b3ea88..7652249 100644
--- a/src/images/SkImageDecoder_libjpeg.cpp
+++ b/src/images/SkImageDecoder_libjpeg.cpp
@@ -19,6 +19,10 @@
 #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"
@@ -35,6 +39,12 @@
 // 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)
+
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
@@ -54,12 +64,27 @@
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
+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
@@ -443,6 +468,19 @@
 }
 #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) {
+    SkRect rect = SkRect::MakeLTRB(0, y, bitmap->width(), bitmap->height());
+    SkCanvas canvas(*bitmap);
+    canvas.clipRect(rect);
+    canvas.drawColor(SK_ColorWHITE);
+}
+
+
 bool SkJPEGImageDecoder::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
 #ifdef TIME_DECODE
     SkAutoTime atm("JPEG Decode");
@@ -553,10 +591,12 @@
 
         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");
+                // 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);
+                cinfo.output_scanline = cinfo.output_height;
+                break;  // Skip to jpeg_finish_decompress()
             }
             if (this->shouldCancelDecode()) {
                 return return_false(cinfo, *bm, "shouldCancelDecode");
@@ -606,7 +646,11 @@
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
         int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
         if (0 == row_count) {
-            return return_false(cinfo, *bm, "read_scanlines");
+            // if row_count == 0, then we didn't get a scanline,
+            // so return early.  We will return a partial image.
+            fill_below_level(y, bm);
+            cinfo.output_scanline = cinfo.output_height;
+            break;  // Skip to jpeg_finish_decompress()
         }
         if (this->shouldCancelDecode()) {
             return return_false(cinfo, *bm, "shouldCancelDecode");
@@ -785,8 +829,9 @@
             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 rowCount == 0, then we didn't get a scanline, so abort.
+            // onDecodeSubset() relies on onBuildTileIndex(), which
+            // needs a complete image to succeed.
             if (0 == rowCount) {
                 return return_false(*cinfo, bitmap, "read_scanlines");
             }
@@ -844,6 +889,9 @@
     for (int y = 0;; y++) {
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
         int row_count = jpeg_read_tile_scanline(cinfo, fImageIndex->huffmanIndex(), &rowptr);
+        // if row_count == 0, then we didn't get a scanline, so abort.
+        // onDecodeSubset() relies on onBuildTileIndex(), which
+        // needs a complete image to succeed.
         if (0 == row_count) {
             return return_false(*cinfo, bitmap, "read_scanlines");
         }
diff --git a/src/images/SkImageDecoder_libpng.cpp b/src/images/SkImageDecoder_libpng.cpp
index d3b45c3..4e4106a 100644
--- a/src/images/SkImageDecoder_libpng.cpp
+++ b/src/images/SkImageDecoder_libpng.cpp
@@ -19,6 +19,10 @@
 #include "SkUtils.h"
 #include "transform_scanline.h"
 
+#if defined(SK_DEBUG)
+#include "SkRTConf.h"  // SK_CONF_DECLARE
+#endif  // defined(SK_DEBUG)
+
 extern "C" {
 #include "png.h"
 }
@@ -40,6 +44,13 @@
 #define png_flush_ptr_NULL NULL
 #endif
 
+#if defined(SK_DEBUG)
+SK_CONF_DECLARE(bool, c_suppressPNGImageDecoderWarnings,
+    "images.png.suppressDecoderWarnings", false,
+    "Suppress most PNG warnings when calling image decode functions.");
+#endif  // defined(SK_DEBUG)
+
+
 class SkPNGImageIndex {
 public:
     SkPNGImageIndex(SkStreamRewindable* stream, png_structp png_ptr, png_infop info_ptr)
@@ -199,6 +210,10 @@
     return false;
 }
 
+void do_nothing_warning_fn(png_structp, png_const_charp) {
+    /* do nothing */
+}
+
 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
@@ -206,12 +221,27 @@
     * 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.  */
+
+#if defined(SK_DEBUG)
+    png_error_ptr user_warning_fn =
+        (c_suppressPNGImageDecoderWarnings) ? (&do_nothing_warning_fn) : NULL;
+    /* NULL means to leave as default library behavior. */
+    /* c_suppressPNGImageDecoderWarnings defaults to false. */
+    /* To suppress warnings with a SK_DEBUG binary, set the
+     * environment variable "skia_images_png_suppressDecoderWarnings"
+     * to "true".  Inside a program that links to skia:
+     * SK_CONF_SET("images.png.suppressDecoderWarnings", true); */
+#else  // Always suppress in release mode
+    png_error_ptr user_warning_fn = &do_nothing_warning_fn;
+#endif  // defined(SK_DEBUG)
+
     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
-        NULL, sk_error_fn, NULL);
+        NULL, sk_error_fn, user_warning_fn);
     //   png_voidp user_error_ptr, user_error_fn, user_warning_fn);
     if (png_ptr == NULL) {
         return false;
     }
+
     *png_ptrp = png_ptr;
 
     /* Allocate/initialize the memory for image information. */
@@ -498,9 +528,13 @@
                                                     transpColor->green >> 8,
                                                     transpColor->blue >> 8);
                 } else {
-                    *theTranspColorp = SkPackARGB32(0xFF, transpColor->red,
-                                                    transpColor->green,
-                                                    transpColor->blue);
+                    /* We apply the mask because in a very small
+                       number of corrupt PNGs, (transpColor->red > 255)
+                       and (bitDepth == 8), for certain versions of libpng. */
+                    *theTranspColorp = SkPackARGB32(0xFF,
+                                                    0xFF & (transpColor->red),
+                                                    0xFF & (transpColor->green),
+                                                    0xFF & (transpColor->blue));
                 }
             } else {    // gray
                 if (16 == bitDepth) {
@@ -508,9 +542,15 @@
                                                     transpColor->gray >> 8,
                                                     transpColor->gray >> 8);
                 } else {
-                    *theTranspColorp = SkPackARGB32(0xFF, transpColor->gray,
-                                                    transpColor->gray,
-                                                    transpColor->gray);
+                    /* We apply the mask because in a very small
+                       number of corrupt PNGs, (transpColor->red >
+                       255) and (bitDepth == 8), for certain versions
+                       of libpng.  For safety we assume the same could
+                       happen with a grayscale PNG.  */
+                    *theTranspColorp = SkPackARGB32(0xFF,
+                                                    0xFF & (transpColor->gray),
+                                                    0xFF & (transpColor->gray),
+                                                    0xFF & (transpColor->gray));
                 }
             }
         }