Add subsetting to SkScaledCodec

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;
+    }
+
+    if (!is_valid_subset(desiredSubset, this->getInfo().dimensions())) {
+        return false;
+    }
+
+    return this->onGetValidSubset(desiredSubset);
+}
+
+bool SkCodec::getScaledSubsetDimensions(float desiredScale, 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 (nullptr == options->fSubset) {
+        return false;
+    }
+
+    if (!is_valid_subset(options->fSubset, this->getInfo().dimensions())) {
+        return false;
+    }
+
+    return this->onGetScaledSubsetDimensions(desiredScale, options);
+}
+
 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 64 matching lines @@
     }
 
     return result;
 }
 
 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) {
+        const SkCodec::Options* options, SkPMColor ctable[], int* ctableCount, int subsetLeft,
+        int subsetWidth) {
     // Reset fCurrScanline in case of failure.
     fCurrScanline = -1;
+
+    // Ensure that the subset parameters are valid
+    if (0 > subsetLeft || subsetLeft >= dstInfo.width() || 0 > subsetWidth ||
+            subsetLeft + subsetWidth > dstInfo.width()) {
+        return kInvalidParameters;
+    }
+
     // 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;
@@ skipping 15 matching lines @@
             // and not supporting this particular subset?
             return kUnimplemented;
         }
     }
 
     // FIXME: Support subsets somehow?
     if (!this->dimensionsSupported(dstInfo.dimensions())) {
         return kInvalidScale;
     }
 
-    const Result result = this->onStartScanlineDecode(dstInfo, *options, ctable, ctableCount);
+    const Result result = this->onStartScanlineDecode(dstInfo, *options, ctable, ctableCount,
+            subsetLeft, subsetWidth);
     if (result != SkCodec::kSuccess) {
         return result;
     }
 
     fCurrScanline = 0;
     fDstInfo = dstInfo;
     fOptions = *options;
     return kSuccess;
 }
 
+SkCodec::Result SkCodec::startScanlineDecode(const SkImageInfo& dstInfo,
+        const SkCodec::Options* options, SkPMColor ctable[], int* ctableCount) {
+    return this->startScanlineDecode(dstInfo, options, ctable, ctableCount, 0, dstInfo.width());
+}
+
 SkCodec::Result SkCodec::startScanlineDecode(const SkImageInfo& dstInfo) {
-    return this->startScanlineDecode(dstInfo, nullptr, nullptr, nullptr);
+    return this->startScanlineDecode(dstInfo, nullptr, nullptr, nullptr, 0, dstInfo.width());
 }
 
 int SkCodec::getScanlines(void* dst, int countLines, size_t rowBytes) {
     if (fCurrScanline < 0) {
         return 0;
     }
 
     SkASSERT(!fDstInfo.isEmpty());
     if (countLines <= 0 || fCurrScanline + countLines > fDstInfo.height()) {
         return 0;
@@ skipping 74 matching lines @@
             break;
         case kOutOfOrder_SkScanlineOrder:
             SkASSERT(1 == linesRequested || this->getInfo().height() == linesRequested);
             for (int srcY = linesDecoded; srcY < linesRequested; srcY++) {
                 fillDst = SkTAddOffset<void>(dst, this->outputScanline(srcY) * rowBytes);
                 SkSampler::Fill(fillDst, colorType, width, 1, rowBytes, fillValue, zeroInit);
             }
             break;
     }
 }