Add scaled subset API to SkCodec

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();
 }
 
+bool SkCodec::getScaledSubsetDimensions(float desiredScale, const Options& options) const {
+    // Negative and zero scales are errors.
+    SkASSERT(desiredScale > 0.0f);
+    if (desiredScale <= 0.0f) {
+        return false;
+    }
+
+    // Upscaling is not supported. We will suggest a full decode if
+    // upscaling is requested.
+    if (desiredScale >= 1.0f) {
+        desiredScale = 1.0f;
+    }
+
+    // If the client is not requesting a subset decode,
+    // getScaledDimensions() should be used.
+    if (!options.fSubset || !options.fScaledDimensions || !options.fScaledSubset) {
+        return false;
+    }
+
+    if (!is_valid_subset(*options.fSubset, this->getInfo().dimensions())) {
+        return false;
+    }
+
+    return this->onGetScaledSubsetDimensions(desiredScale, options);
+}
+
+bool SkCodec::subsetSupported(const SkIRect& subset, bool isScanlineDecode) {
+    if (!is_valid_subset(subset, this->getInfo().dimensions())) {

[scroggo, 2015/10/12 20:47:07]

nit: fInfo.dimensions()

No need to call the accessor function, since this class can access it directly
(unless there was a side effect, and I believe there is not).

+        return false;
+    }
+
+    return this->onSubsetSupported(subset, isScanlineDecode);
+}
+
+bool SkCodec::onSubsetSupported(const SkIRect& subset, bool isScanlineDecode) {
+    if (!isScanlineDecode) {
+        return false;
+    }
+
+    // We support subsetting in the x-dimension for the scanline decoder.
+    // Subsetting in the y-dimension can be accomplished using skipScanlines().
+    return subset.top() == 0 && subset.height() == this->getInfo().height();
+}
+
+bool SkCodec::scaledSubsetSupported(const SkISize& dstSize, const Options& options,
+        bool isScanlineDecode) {
+    SkIRect* subset = options.fSubset;
+
+    // If there is no subsetting, we simply check if we can scale to dstSize
+    if (!subset) {
+        return this->dimensionsSupported(dstSize);
+    }
+
+    SkISize* scaledDimensions = options.fScaledDimensions;
+    SkIRect* scaledSubset = options.fScaledSubset;
+    if (!scaledDimensions && !scaledSubset) {
+        // If there is no scaling, check if we support the subset requested
+        return this->subsetSupported(*subset, isScanlineDecode);
+    }
+
+    if (!scaledDimensions || !scaledSubset) {
+        // Both scaledDimensions and scaledSubset must be non-NULL to perform
+        // a scaled subset decode.
+        return false;
+    }
+
+    if (!is_valid_subset(*scaledSubset, *scaledDimensions)) {
+        return false;
+    }
+
+    return this->onScaledSubsetSupported(options, isScanlineDecode);
+}
+
+bool SkCodec::onScaledSubsetSupported(const Options& options, bool isScanlineDecode) {
+    if (!isScanlineDecode) {
+        return false;
+    }
+
+    if (!this->dimensionsSupported(*options.fScaledDimensions)) {
+        return false;
+    }
+
+    // We support subsetting in the x-dimension for the scanline decoder.
+    // Subsetting in the y-dimension can be accomplished using skipScanlines().
+    return options.fSubset->top() == 0 &&
+            options.fSubset->height() == options.fScaledDimensions->height();
+}
+
 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 21 matching lines @@
     }
 
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
 
     // Default 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?
-            return kUnimplemented;
-        }
     }
 
-    // FIXME: Support subsets somehow? Note that this works for SkWebpCodec
-    // because it supports arbitrary scaling/subset combinations.
-    if (!this->dimensionsSupported(info.dimensions())) {
+    if (!this->scaledSubsetSupported(info.dimensions(), *options, false)) {
         return kInvalidScale;
     }
 
     // On an incomplete decode, the subclass will specify the number of scanlines that it decoded
     // successfully.
     int rowsDecoded = 0;
     const Result result = this->onGetPixels(info, pixels, rowBytes, *options, ctable, ctableCount,
             &rowsDecoded);
 
     if ((kIncompleteInput == result || kSuccess == result) && ctableCount) {
@@ skipping 35 matching lines @@
     }
 
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
 
     // Set options.
     Options optsStorage;
     if (nullptr == options) {
         options = &optsStorage;
-    } else if (options->fSubset) {
-        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()) {
-            return kInvalidInput;
-        }
     }
 
-    // FIXME: Support subsets somehow?
-    if (!this->dimensionsSupported(dstInfo.dimensions())) {
+    if (!this->scaledSubsetSupported(dstInfo.dimensions(), *options, true)) {
         return kInvalidScale;
     }
 
     const Result result = this->onStartScanlineDecode(dstInfo, *options, ctable, ctableCount);
     if (result != SkCodec::kSuccess) {
         return result;
     }
 
     fCurrScanline = 0;
     fDstInfo = dstInfo;
@@ skipping 96 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(fillInfo, fillDst, rowBytes, fillValue, zeroInit, sampler);
             }
             break;
         }
     }
 }