Make SkPngCodec decode progressively.

src/codec/SkSampledCodec.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 "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkMath.h"
@@ skipping 83 matching lines @@
         // If the native codec does not support the requested scale, scale by sampling.
         return this->sampledDecode(info, pixels, rowBytes, options);
     }
 
     // Calculate the scaled subset bounds.
     int scaledSubsetX = subset->x() / sampleSize;
     int scaledSubsetY = subset->y() / sampleSize;
     int scaledSubsetWidth = info.width();
     int scaledSubsetHeight = info.height();
 
+    const SkImageInfo scaledInfo = info.makeWH(scaledSize.width(), scaledSize.height());
+
+    {
+        // Although startScanlineDecode expects the bottom and top to match the
+        // SkImageInfo, startIncrementalDecode uses them to determine when to start
+        // and end calling the callback.
+        SkIRect incrementalSubset = SkIRect::MakeXYWH(scaledSubsetX, scaledSubsetY,
+                                                      scaledSubsetWidth, scaledSubsetHeight);
+        codecOptions.fSubset = &incrementalSubset;
+        const SkCodec::Result startResult = this->codec()->startIncrementalDecode(
+                scaledInfo, pixels, rowBytes, &codecOptions,
+                options.fColorPtr, options.fColorCount);
+        if (SkCodec::kSuccess == startResult) {
+            int rowsDecoded;
+            const SkCodec::Result incResult = this->codec()->incrementalDecode(&rowsDecoded);
+            if (incResult == SkCodec::kSuccess) {
+                return SkCodec::kSuccess;
+            }
+            SkASSERT(SkCodec::kIncompleteInput == incResult);
+
+            // FIXME: Can zero initialized be read from SkCodec::fOptions?
+            this->codec()->fillIncompleteImage(scaledInfo, pixels, rowBytes,
+                    options.fZeroInitialized, scaledSubsetHeight, rowsDecoded);
+            return SkCodec::kIncompleteInput;
+        } else if (startResult != SkCodec::kUnimplemented) {
+            return startResult;
+        }
+        // Otherwise fall down to use the old scanline decoder.
+        // codecOptions.fSubset will be reset below, so it will not continue to
+        // point to the object that is no longer on the stack.
+    }
+
     // Start the scanline decode.
     SkIRect scanlineSubset = SkIRect::MakeXYWH(scaledSubsetX, 0, scaledSubsetWidth,
             scaledSize.height());
     codecOptions.fSubset = &scanlineSubset;
-    SkCodec::Result result = this->codec()->startScanlineDecode(info.makeWH(scaledSize.width(),
-            scaledSize.height()), &codecOptions, options.fColorPtr, options.fColorCount);
+
+    SkCodec::Result result = this->codec()->startScanlineDecode(scaledInfo,
+            &codecOptions, options.fColorPtr, options.fColorCount);
     if (SkCodec::kSuccess != result) {
         return result;
     }
 
     // At this point, we are only concerned with subsetting.  Either no scale was
     // requested, or the this->codec() is handling the scale.
-    switch (this->codec()->getScanlineOrder()) {
-        case SkCodec::kTopDown_SkScanlineOrder:
-        case SkCodec::kNone_SkScanlineOrder: {
-            if (!this->codec()->skipScanlines(scaledSubsetY)) {
-                this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
-                        scaledSubsetHeight, 0);
-                return SkCodec::kIncompleteInput;
-            }
+    // Note that subsetting is only supported for kTopDown, so this code will not be
+    // reached for other orders.
+    SkASSERT(this->codec()->getScanlineOrder() == SkCodec::kTopDown_SkScanlineOrder);
+    if (!this->codec()->skipScanlines(scaledSubsetY)) {
+        this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
+                scaledSubsetHeight, 0);
+        return SkCodec::kIncompleteInput;
+    }
 
-            int decodedLines = this->codec()->getScanlines(pixels, scaledSubsetHeight, rowBytes);
-            if (decodedLines != scaledSubsetHeight) {
-                return SkCodec::kIncompleteInput;
-            }
-            return SkCodec::kSuccess;
-        }
-        default:
-            SkASSERT(false);
-            return SkCodec::kUnimplemented;
+    int decodedLines = this->codec()->getScanlines(pixels, scaledSubsetHeight, rowBytes);
+    if (decodedLines != scaledSubsetHeight) {
+        return SkCodec::kIncompleteInput;
     }
+    return SkCodec::kSuccess;
 }
 
 
 SkCodec::Result SkSampledCodec::sampledDecode(const SkImageInfo& info, void* pixels,
         size_t rowBytes, const AndroidOptions& options) {
     // We should only call this function when sampling.
     SkASSERT(options.fSampleSize > 1);
 
     // Create options struct for the codec.
     SkCodec::Options sampledOptions;
@@ skipping 22 matching lines @@
         subsetY = subsetPtr->y() / nativeSampleSize;
 
         subsetWidth = get_scaled_dimension(subsetPtr->width(), nativeSampleSize);
         subsetHeight = get_scaled_dimension(subsetPtr->height(), nativeSampleSize);
 
         // The scanline decoder only needs to be aware of subsetting in the x-dimension.
         subset.setXYWH(subsetX, 0, subsetWidth, nativeSize.height());
         sampledOptions.fSubset = ⊂
     }
 
+    // Since we guarantee that output dimensions are always at least one (even if the sampleSize
+    // is greater than a given dimension), the input sampleSize is not always the sampleSize that
+    // we use in practice.
+    const int sampleX = subsetWidth / info.width();
+    const int sampleY = subsetHeight / info.height();
+
+    const int samplingOffsetY = get_start_coord(sampleY);
+    const int startY = samplingOffsetY + subsetY;
+    int dstHeight = info.height();
+
+    const SkImageInfo nativeInfo = info.makeWH(nativeSize.width(), nativeSize.height());
+
+    {
+        // Although startScanlineDecode expects the bottom and top to match the
+        // SkImageInfo, startIncrementalDecode uses them to determine when to start
+        // and end calling the callback.
+        SkIRect incrementalSubset;
+        incrementalSubset.fTop = startY;
+        incrementalSubset.fBottom = startY + (dstHeight - 1) * sampleY + 1;

[msarett, 2016/09/14 13:21:06]

Why are we doing this again?

[scroggo_chromium, 2016/09/14 14:54:13]

Modifying the top and bottom? Because unlike the scanline decoder, the
incremental decoder does not have a way to skip individual scanlines. Instead,
it tells it any lines to skip at the beginning and the end (and then uses
sampleY to skip any lines in the middle).

[msarett, 2016/09/14 15:39:54]

Sorry let me rephrase.  Why do we need to do this math to determine the bottom
of the subset?
"startY + (dstHeight - 1) * sampleY + 1"

[scroggo, 2016/09/14 17:43:00]

dstHeight is the height of the output (this was part of the SkAndroidCodec,
which promises to scale to the size of the SkImageInfo provided). But now we're
going to pass a subset to an SkCodec, which interprets it as a subset into the
original image. So we need to compute the size of a subset in the original image
that, when sampled with our algorithm, will create an image of size dstHeight.
Does that make sense? Do you expect to see different math/something simpler?

[msarett, 2016/09/14 18:16:05]

My latest interpretation:
We *could* get away with using "subsetY and "subsetHeight" (calculated above),
but this code gives us tighter bounds on the subset - meaning that we don't
include rows that we'll skip anyway due to sampling.

LGTM, maybe a comment?

[scroggo_chromium, 2016/09/14 22:01:41]

Done.

+        if (sampledOptions.fSubset) {
+            incrementalSubset.fLeft = sampledOptions.fSubset->fLeft;
+            incrementalSubset.fRight = sampledOptions.fSubset->fRight;
+        } else {
+            incrementalSubset.fLeft = 0;
+            incrementalSubset.fRight = nativeSize.width();
+        }
+        SkCodec::Options incrementalOptions = sampledOptions;
+        incrementalOptions.fSubset = &incrementalSubset;
+        const SkCodec::Result startResult = this->codec()->startIncrementalDecode(nativeInfo,
+                pixels, rowBytes, &incrementalOptions, options.fColorPtr, options.fColorCount);
+        if (SkCodec::kSuccess == startResult) {
+            SkSampler* sampler = this->codec()->getSampler(true);
+            if (!sampler) {
+                return SkCodec::kUnimplemented;
+            }
+
+            if (sampler->setSampleX(sampleX) != info.width()) {
+                return SkCodec::kInvalidScale;
+            }
+            if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) {
+                return SkCodec::kInvalidScale;
+            }
+
+            sampler->setSampleY(sampleY);
+
+            int rowsDecoded;
+            const SkCodec::Result incResult = this->codec()->incrementalDecode(&rowsDecoded);
+            if (incResult == SkCodec::kSuccess) {
+                return SkCodec::kSuccess;
+            }
+            SkASSERT(incResult == SkCodec::kIncompleteInput);
+            const int lastRowInOutput = (rowsDecoded - startY) / sampleY;
+            // FIXME: Should this be info or nativeInfo? Does it make a difference?
+            this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
+                                               info.height(), lastRowInOutput);
+            return SkCodec::kIncompleteInput;
+        } else if (startResult != SkCodec::kUnimplemented) {
+            return startResult;
+        } // kUnimplemented means use the old method.
+    }
+
     // Start the scanline decode.
-    SkCodec::Result result = this->codec()->startScanlineDecode(
-            info.makeWH(nativeSize.width(), nativeSize.height()), &sampledOptions,
-            options.fColorPtr, options.fColorCount);
+    SkCodec::Result result = this->codec()->startScanlineDecode(nativeInfo,
+            &sampledOptions, options.fColorPtr, options.fColorCount);
     if (SkCodec::kSuccess != result) {
         return result;
     }
 
     SkSampler* sampler = this->codec()->getSampler(true);
     if (!sampler) {
         return SkCodec::kUnimplemented;
     }
 
-    // Since we guarantee that output dimensions are always at least one (even if the sampleSize
-    // is greater than a given dimension), the input sampleSize is not always the sampleSize that
-    // we use in practice.
-    const int sampleX = subsetWidth / info.width();
-    const int sampleY = subsetHeight / info.height();
     if (sampler->setSampleX(sampleX) != info.width()) {
         return SkCodec::kInvalidScale;
     }
     if (get_scaled_dimension(subsetHeight, sampleY) != info.height()) {
         return SkCodec::kInvalidScale;
     }
 
-    const int samplingOffsetY = get_start_coord(sampleY);
-    const int startY = samplingOffsetY + subsetY;
-    int dstHeight = info.height();
     switch(this->codec()->getScanlineOrder()) {
         case SkCodec::kTopDown_SkScanlineOrder: {
             if (!this->codec()->skipScanlines(startY)) {
                 this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
                         dstHeight, 0);
                 return SkCodec::kIncompleteInput;
             }
             void* pixelPtr = pixels;
             for (int y = 0; y < dstHeight; y++) {
                 if (1 != this->codec()->getScanlines(pixelPtr, 1, rowBytes)) {
@@ skipping 44 matching lines @@
                 int srcY = this->codec()->outputScanline(y);
                 if (!is_coord_necessary(srcY, sampleY, dstHeight)) {
                     continue;
                 }
 
                 void* rowPtr = SkTAddOffset<void>(pixels, rowBytes * get_dst_coord(srcY, sampleY));
                 SkSampler::Fill(fillInfo, rowPtr, rowBytes, fillValue, options.fZeroInitialized);
             }
             return SkCodec::kIncompleteInput;
         }
-        case SkCodec::kNone_SkScanlineOrder: {
-            const int linesNeeded = subsetHeight - samplingOffsetY;
-            SkAutoTMalloc<uint8_t> storage(linesNeeded * rowBytes);
-            uint8_t* storagePtr = storage.get();
-
-            if (!this->codec()->skipScanlines(startY)) {
-                this->codec()->fillIncompleteImage(info, pixels, rowBytes, options.fZeroInitialized,
-                        dstHeight, 0);
-                return SkCodec::kIncompleteInput;
-            }
-            int scanlines = this->codec()->getScanlines(storagePtr, linesNeeded, rowBytes);
-
-            for (int y = 0; y < dstHeight; y++) {
-                memcpy(pixels, storagePtr, info.minRowBytes());
-                storagePtr += sampleY * rowBytes;
-                pixels = SkTAddOffset<void>(pixels, rowBytes);
-            }
-
-            if (scanlines < dstHeight) {
-                // this->codec() has already handled filling uninitialized memory.
-                return SkCodec::kIncompleteInput;
-            }
-            return SkCodec::kSuccess;
-        }
         default:
             SkASSERT(false);
             return SkCodec::kUnimplemented;
     }
 }