Make SkPngCodec decode progressively.

dm/DMSrcSink.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMSrcSink.h"
 #include "SkAndroidCodec.h"
 #include "SkCodec.h"
@@ skipping 416 matching lines @@
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             premultiply_if_necessary(bitmap);
             swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
-            if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
-                                                                colorCountPtr)) {
-                return "Could not start scanline decoder";
-            }
-
-            void* dst = bitmap.getAddr(0, 0);
-            size_t rowBytes = bitmap.rowBytes();
-            uint32_t height = decodeInfo.height();
-            switch (codec->getScanlineOrder()) {
-                case SkCodec::kTopDown_SkScanlineOrder:
-                case SkCodec::kBottomUp_SkScanlineOrder:
-                case SkCodec::kNone_SkScanlineOrder:
-                    // We do not need to check the return value.  On an incomplete
-                    // image, memory will be filled with a default value.
-                    codec->getScanlines(dst, height, rowBytes);
-                    break;
-                case SkCodec::kOutOfOrder_SkScanlineOrder: {
-                    for (int y = 0; y < decodeInfo.height(); y++) {
-                        int dstY = codec->outputScanline(y);
-                        void* dstPtr = bitmap.getAddr(0, dstY);
-                        // We complete the loop, even if this call begins to fail
-                        // due to an incomplete image.  This ensures any uninitialized
-                        // memory will be filled with the proper value.
-                        codec->getScanlines(dstPtr, 1, bitmap.rowBytes());
+            const bool png = fPath.endsWith("png");
+            const bool ico = fPath.endsWith("ico");
+            bool useOldScanlineMethod = !png && !ico;
+            if (png || ico) {
+                if (SkCodec::kSuccess == codec->startIncrementalDecode(decodeInfo,
+                        bitmap.getPixels(), bitmap.rowBytes(), nullptr, colorPtr, colorCountPtr)) {
+                    int rowsDecoded;
+                    if (SkCodec::kIncompleteInput == codec->incrementalDecode(&rowsDecoded)) {
+                        codec->fillIncompleteImage(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(),
+                                                   SkCodec::kNo_ZeroInitialized, decodeInfo.height(),
+                                                   rowsDecoded);
                     }
-                    break;
+                } else {
+                    if (png) {
+                        // Error: PNG should support incremental decode.
+                        return "Could not start incremental decode";
+                    }
+                    // Otherwise, this is an ICO. Since incremental failed, it must contain a BMP,
+                    // which should work via startScanlineDecode
+                    useOldScanlineMethod = true;
                 }
             }
 
+            if (useOldScanlineMethod) {
+                if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
+                                                                    colorCountPtr)) {
+                    return "Could not start scanline decoder";
+                }
+
+                void* dst = bitmap.getAddr(0, 0);
+                size_t rowBytes = bitmap.rowBytes();
+                uint32_t height = decodeInfo.height();
+                switch (codec->getScanlineOrder()) {
+                    case SkCodec::kTopDown_SkScanlineOrder:
+                    case SkCodec::kBottomUp_SkScanlineOrder:
+                        // We do not need to check the return value.  On an incomplete
+                        // image, memory will be filled with a default value.
+                        codec->getScanlines(dst, height, rowBytes);
+                        break;
+                    case SkCodec::kOutOfOrder_SkScanlineOrder: {
+                        for (int y = 0; y < decodeInfo.height(); y++) {
+                            int dstY = codec->outputScanline(y);
+                            void* dstPtr = bitmap.getAddr(0, dstY);
+                            // We complete the loop, even if this call begins to fail
+                            // due to an incomplete image.  This ensures any uninitialized
+                            // memory will be filled with the proper value.
+                            codec->getScanlines(dstPtr, 1, bitmap.rowBytes());
+                        }
+                        break;
+                    }
+                }
+            }
+
             premultiply_if_necessary(bitmap);
             swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kStripe_Mode: {
             const int height = decodeInfo.height();
             // This value is chosen arbitrarily.  We exercise more cases by choosing a value that
             // does not align with image blocks.
             const int stripeHeight = 37;
@@ skipping 1023 matching lines @@
             skr.visit(i, drawsAsSingletonPictures);
         }
         sk_sp<SkPicture> macroPic(macroRec.finishRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return check_against_reference(bitmap, src, fSink);
     });
 }
 
 }  // namespace DM