Add subsetting to SkScanlineDecoder

src/codec/SkCodec.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 "SkBmpCodec.h"
 #include "SkCodec.h"
 #include "SkData.h"
@@ skipping 93 matching lines @@
     // startScanlineDecode will need to be called before decoding scanlines.
     fCurrScanline = -1;
 
     if (!fStream->rewind()) {
         return false;
     }
 
     return this->onRewind();
 }
 
+SkISize SkCodec::getScaledDimensions(float desiredScale) const {
+    // Negative and zero scales are errors.
+    SkASSERT(desiredScale > 0.0f);
+    if (desiredScale <= 0.0f) {
+        return SkISize::Make(0, 0);
+    }
+
+    // Upscaling is not supported. Return the original size if the client
+    // requests an upscale.
+    if (desiredScale >= 1.0f) {
+        return this->getInfo().dimensions();
+    }
+    return this->onGetScaledDimensions(desiredScale);
+}
+
+bool SkCodec::getValidSubset(SkIRect* desiredSubset) const {
+    if (!desiredSubset) {
+        return false;
+    }
+
+    SkIRect dimensions  = SkIRect::MakeSize(this->getInfo().dimensions());
+    if (!dimensions.contains(*desiredSubset)) {
+        return false;
+    }
+
+    return this->onGetValidSubset(desiredSubset);
+}
+
 SkCodec::Result SkCodec::getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
                                    const Options* options, SkPMColor ctable[], int* ctableCount) {
     if (kUnknown_SkColorType == info.colorType()) {
         return kInvalidConversion;
     }
     if (nullptr == pixels) {
         return kInvalidParameters;
     }
     if (rowBytes < info.minRowBytes()) {
         return kInvalidParameters;
@@ skipping 67 matching lines @@
 }
 
 SkCodec::Result SkCodec::getPixels(const SkImageInfo& info, void* pixels, size_t rowBytes) {
     return this->getPixels(info, pixels, rowBytes, nullptr, nullptr, nullptr);
 }
 
 SkCodec::Result SkCodec::startScanlineDecode(const SkImageInfo& dstInfo,
         const SkCodec::Options* options, SkPMColor ctable[], int* ctableCount) {
     // Reset fCurrScanline in case of failure.
     fCurrScanline = -1;
+
     // Ensure that valid color ptrs are passed in for kIndex8 color type
     if (kIndex_8_SkColorType == dstInfo.colorType()) {
         if (nullptr == ctable || nullptr == ctableCount) {
             return SkCodec::kInvalidParameters;
         }
     } else {
         if (ctableCount) {
             *ctableCount = 0;
         }
         ctableCount = nullptr;
         ctable = nullptr;
     }
 
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
 
     // Set options.
     Options optsStorage;
     if (nullptr == options) {
         options = &optsStorage;
     } else if (options->fSubset) {
-        SkIRect subset(*options->fSubset);
-        if (!this->onGetValidSubset(&subset) || subset != *options->fSubset) {
-            // FIXME: How to differentiate between not supporting subset at all
-            // and not supporting this particular subset?
+        SkIRect size = SkIRect::MakeSize(dstInfo.dimensions());
+        if (!size.contains(*options->fSubset)) {
+            return kInvalidInput;
+        }
+
+        // We only support subsetting in the x-dimension for scanline decoder.
+        // Subsetting in the y-dimension can be accomplished using skipScanlines().
+        if (options->fSubset->top() != 0 || options->fSubset->height() != dstInfo.height()) {

[msarett, 2015/10/07 22:15:14]

Alternatively we can just ignore the y-coordinates of the subset.  But I think
it might be better to be sure that the client knows that they are responsible
for subsetting in the y-dimension.

             return kUnimplemented;
         }
     }
 
     // FIXME: Support subsets somehow?
     if (!this->dimensionsSupported(dstInfo.dimensions())) {
         return kInvalidScale;
     }
 
+    fDstInfo = dstInfo;
+    fOptions = *options;

[msarett, 2015/10/07 22:15:14]

SkJpegCodec might need to call getSampler() in startScanlineDecode().
We cannot call getSampler() until fDstInfo and fOptions are set.

I know you had a reason for not setting these fields until the end of this
function, but I can't remember what it was...

[scroggo, 2015/10/08 20:16:07]

The reason is because I did not want to update them until we knew that
onStartScanlineDecode succeeded. This way we do not have some dstInfo and
options that perhaps did not work. It does not go all the way though - we could
be even more defensive about this and reset them at the beginning (like we do
with fCurrScanline).
Do you mean in onStartScanlineDecode? That function receives dstInfo and options
as parameters, so it seems like you can just read those.

[msarett, 2015/10/09 20:03:44]

Acknowledged.

     const Result result = this->onStartScanlineDecode(dstInfo, *options, ctable, ctableCount);
     if (result != SkCodec::kSuccess) {
         return result;
     }
 
     fCurrScanline = 0;
-    fDstInfo = dstInfo;
-    fOptions = *options;
     return kSuccess;
 }
 
 SkCodec::Result SkCodec::startScanlineDecode(const SkImageInfo& dstInfo) {
     return this->startScanlineDecode(dstInfo, nullptr, nullptr, nullptr);
 }
 
 int SkCodec::getScanlines(void* dst, int countLines, size_t rowBytes) {
     if (fCurrScanline < 0) {
         return 0;
@@ skipping 85 matching lines @@
             SkASSERT(1 == linesRequested || this->getInfo().height() == linesRequested);
             const SkImageInfo fillInfo = info.makeWH(info.width(), 1);
             for (int srcY = linesDecoded; srcY < linesRequested; srcY++) {
                 fillDst = SkTAddOffset<void>(dst, this->outputScanline(srcY) * rowBytes);
                 fill_proc(sampler, fillDst, fillInfo, rowBytes, fillValue, zeroInit);
             }
             break;
         }
     }
 }