Incremental decode: only use subset for subsetting

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 168 matching lines @@
 
     // Check if there is a subset.
     SkIRect subset;
     int subsetY = 0;
     int subsetWidth = nativeSize.width();
     int subsetHeight = nativeSize.height();
     if (options.fSubset) {
         // We will need to know about subsetting in the y-dimension in order to use the
         // scanline decoder.
         // Update the subset to account for scaling done by this->codec().
-        SkIRect* subsetPtr = options.fSubset;
+        const SkIRect* subsetPtr = options.fSubset;
 
         // Do the divide ourselves, instead of calling get_scaled_dimension. If
         // X and Y are 0, they should remain 0, rather than being upgraded to 1
         // due to being smaller than the sampleSize.
         const int subsetX = subsetPtr->x() / nativeSampleSize;
         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 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 which rows to
         // decode.
-        // Note: We *could* use "subsetY" and "subsetHeight" (calculated above) for
-        // incrementalSubset, but this code gives us a tighter bounds on the subset,
-        // meaning that we can start with the first row actually needed by the output,
-        // and stop when we've decoded the last row needed by the output.
+        SkCodec::Options incrementalOptions = sampledOptions;
         SkIRect incrementalSubset;
-        incrementalSubset.fTop = startY;
-        incrementalSubset.fBottom = startY + (dstHeight - 1) * sampleY + 1;
         if (sampledOptions.fSubset) {
+            incrementalSubset.fTop = subsetY;
+            incrementalSubset.fBottom = subsetY + subsetHeight;
             incrementalSubset.fLeft = sampledOptions.fSubset->fLeft;
             incrementalSubset.fRight = sampledOptions.fSubset->fRight;
-        } else {
-            incrementalSubset.fLeft = 0;
-            incrementalSubset.fRight = nativeSize.width();
+            incrementalOptions.fSubset = &incrementalSubset;
         }
-        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;
@@ skipping 101 matching lines @@
                 void* rowPtr = SkTAddOffset<void>(pixels, rowBytes * get_dst_coord(srcY, sampleY));
                 SkSampler::Fill(fillInfo, rowPtr, rowBytes, fillValue, options.fZeroInitialized);
             }
             return SkCodec::kIncompleteInput;
         }
         default:
             SkASSERT(false);
             return SkCodec::kUnimplemented;
     }
 }