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 64 matching lines @@
     return NewFromStream(new SkMemoryStream(data));
 }
 
 SkCodec::SkCodec(const SkImageInfo& info, SkStream* stream)
     : fSrcInfo(info)
     , fStream(stream)
     , fNeedsRewind(false)
     , fDstInfo()
     , fOptions()
     , fCurrScanline(-1)
+    , fSubsetWidth(0)
 {}
 
 SkCodec::~SkCodec() {}
 
 bool SkCodec::rewindIfNeeded() {
     if (!fStream) {
         // Some codecs do not have a stream, but they hold others that do. They
         // must handle rewinding themselves.
         return true;
     }
 
     // Store the value of fNeedsRewind so we can update it. Next read will
     // require a rewind.
     const bool needsRewind = fNeedsRewind;
     fNeedsRewind = true;
     if (!needsRewind) {
         return true;
     }
 
     // startScanlineDecode will need to be called before decoding scanlines.
     fCurrScanline = -1;
+    fSubsetWidth = 0;
 
     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 51 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 ||

[scroggo, 2015/10/02 18:27:03]

nit: I would lean towards separating these out logically, e.g.

if (0 > subsetLeft || subsetLeft >= dstInfo.width() ||  // boundary check left
    0 > subsetWidth || subsetLeft + subsetWidth > dstInfo.width()) { // right

+            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;
         ctable = nullptr;
     }
 
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
 
     // Set options.
     Options optsStorage;
     if (nullptr == options) {
         options = &optsStorage;
     }
 
-    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;
+    fSubsetWidth = subsetWidth;
     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 ((rowBytes < fDstInfo.minRowBytes() && countLines > 1 ) || countLines <= 0
-         || fCurrScanline + countLines > fDstInfo.height()) {
+    if (countLines <= 0 || fCurrScanline + countLines > fDstInfo.height()) {
         return 0;
     }
 
     const uint32_t linesDecoded = this->onGetScanlines(dst, countLines, rowBytes);
     if (linesDecoded < countLines) {
         this->fillIncompleteImage(this->dstInfo(), dst, rowBytes, this->options().fZeroInitialized,
                 countLines, linesDecoded);
     }
     fCurrScanline += linesDecoded;
     return linesDecoded;
@@ skipping 31 matching lines @@
             return get_output_row_interlaced(inputScanline, this->getInfo().height());
     }
 }
 
 void SkCodec::fillIncompleteImage(const SkImageInfo& info, void* dst, size_t rowBytes,
         ZeroInitialized zeroInit, int linesRequested, int linesDecoded) {
     void* fillDst;
     SkImageInfo fillInfo;
     const uint32_t fillValue = this->getFillValue(info.colorType(), info.alphaType());
     const int linesRemaining = linesRequested - linesDecoded;
+    const int fillWidth = fSubsetWidth ? fSubsetWidth : info.width();
     switch (this->getScanlineOrder()) {
         case kTopDown_SkScanlineOrder:
         case kNone_SkScanlineOrder:
             fillDst = SkTAddOffset<void>(dst, linesDecoded * rowBytes);
-            fillInfo = info.makeWH(info.width(), linesRemaining);
+            fillInfo = info.makeWH(fillWidth, linesRemaining);
             SkSwizzler::Fill(fillDst, fillInfo, rowBytes, fillValue, zeroInit);
             break;
         case kBottomUp_SkScanlineOrder:
             fillDst = dst;
-            fillInfo = info.makeWH(info.width(), linesRemaining);
+            fillInfo = info.makeWH(fillWidth, linesRemaining);
             SkSwizzler::Fill(fillDst, fillInfo, rowBytes, fillValue, zeroInit);
             break;
         case kOutOfOrder_SkScanlineOrder:
             SkASSERT(1 == linesRequested || this->getInfo().height() == linesRequested);
-            fillInfo = info.makeWH(info.width(), 1);
+            fillInfo = info.makeWH(fillWidth, 1);
             for (int srcY = linesDecoded; srcY < linesRequested; srcY++) {
                 fillDst = SkTAddOffset<void>(dst, this->outputScanline(srcY) * rowBytes);
                 SkSwizzler::Fill(fillDst, fillInfo, rowBytes, fillValue, zeroInit);
             }
             break;
     }
 }