Revert of Make SkPngCodec decode progressively.

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 "SkCodecPriv.h"
@@ skipping 136 matching lines @@
     // startScanlineDecode will need to be called before decoding scanlines.
     fCurrScanline = -1;
 
     if (!fStream->rewind()) {
         return false;
     }
 
     return this->onRewind();
 }
 
-#define CHECK_COLOR_TABLE                                   \
-    if (kIndex_8_SkColorType == info.colorType()) {         \
-        if (nullptr == ctable || nullptr == ctableCount) {  \
-            return SkCodec::kInvalidParameters;             \
-        }                                                   \
-    } else {                                                \
-        if (ctableCount) {                                  \
-            *ctableCount = 0;                               \
-        }                                                   \
-        ctableCount = nullptr;                              \
-        ctable = nullptr;                                   \
-    }
-
-
 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;
     }
 
-    CHECK_COLOR_TABLE;
+    if (kIndex_8_SkColorType == info.colorType()) {
+        if (nullptr == ctable || nullptr == ctableCount) {
+            return kInvalidParameters;
+        }
+    } else {
+        if (ctableCount) {
+            *ctableCount = 0;
+        }
+        ctableCount = nullptr;
+        ctable = nullptr;
+    }
 
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
 
     // Default options.
     Options optsStorage;
     if (nullptr == options) {
         options = &optsStorage;
     } else if (options->fSubset) {
@@ skipping 31 matching lines @@
                 rowsDecoded);
     }
 
     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::startIncrementalDecode(const SkImageInfo& info, void* pixels,
-        size_t rowBytes, const SkCodec::Options* options, SkPMColor* ctable, int* ctableCount) {
-    fStartedIncrementalDecode = false;
-
-    if (kUnknown_SkColorType == info.colorType()) {
-        return kInvalidConversion;
-    }
-    if (nullptr == pixels) {
-        return kInvalidParameters;
-    }
-
-    // Ensure that valid color ptrs are passed in for kIndex8 color type
-    CHECK_COLOR_TABLE;
-
-    // FIXME: If the rows come after the rows of a previous incremental decode,
-    // we might be able to skip the rewind, but only the implementation knows
-    // that. (e.g. PNG will always need to rewind, since we called longjmp, but
-    // a bottom-up BMP could skip rewinding if the new rows are above the old
-    // rows.)
-    if (!this->rewindIfNeeded()) {
-        return kCouldNotRewind;
-    }
-
-    // Set options.
-    Options optsStorage;
-    if (nullptr == options) {
-        options = &optsStorage;
-    } else if (options->fSubset) {
-        SkIRect size = SkIRect::MakeSize(info.dimensions());
-        if (!size.contains(*options->fSubset)) {
-            return kInvalidParameters;
-        }
-
-        const int top = options->fSubset->top();
-        const int bottom = options->fSubset->bottom();
-        if (top < 0 || top >= info.height() || top >= bottom || bottom > info.height()) {
-            return kInvalidParameters;
-        }
-    }
-
-    if (!this->dimensionsSupported(info.dimensions())) {
-        return kInvalidScale;
-    }
-
-    fDstInfo = info;
-    fOptions = *options;
-
-    const Result result = this->onStartIncrementalDecode(info, pixels, rowBytes,
-            fOptions, ctable, ctableCount);
-    if (kSuccess == result) {
-        fStartedIncrementalDecode = true;
-    } else if (kUnimplemented == result) {
-        // FIXME: This is temporarily necessary, until we transition SkCodec
-        // implementations from scanline decoding to incremental decoding.
-        // SkAndroidCodec will first attempt to use incremental decoding, but
-        // will fall back to scanline decoding if incremental returns
-        // kUnimplemented. rewindIfNeeded(), above, set fNeedsRewind to true
-        // (after potentially rewinding), but we do not want the next call to
-        // startScanlineDecode() to do a rewind.
-        fNeedsRewind = false;
-    }
-    return result;
-}
-
-
-SkCodec::Result SkCodec::startScanlineDecode(const SkImageInfo& info,
+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
-    CHECK_COLOR_TABLE;
+    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 size = SkIRect::MakeSize(info.dimensions());
+        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() != info.height()) {
+        if (options->fSubset->top() != 0 || options->fSubset->height() != dstInfo.height()) {
             return kInvalidInput;
         }
     }
 
     // FIXME: Support subsets somehow?
-    if (!this->dimensionsSupported(info.dimensions())) {
+    if (!this->dimensionsSupported(dstInfo.dimensions())) {
         return kInvalidScale;
     }
 
-    const Result result = this->onStartScanlineDecode(info, *options, ctable, ctableCount);
+    const Result result = this->onStartScanlineDecode(dstInfo, *options, ctable, ctableCount);
     if (result != SkCodec::kSuccess) {
         return result;
     }
 
     fCurrScanline = 0;
-    fDstInfo = info;
+    fDstInfo = dstInfo;
     fOptions = *options;
     return kSuccess;
 }
 
-#undef CHECK_COLOR_TABLE
-
-SkCodec::Result SkCodec::startScanlineDecode(const SkImageInfo& info) {
-    return this->startScanlineDecode(info, nullptr, nullptr, nullptr);
+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;
     }
 
     SkASSERT(!fDstInfo.isEmpty());
     if (countLines <= 0 || fCurrScanline + countLines > fDstInfo.height()) {
         return 0;
@@ skipping 27 matching lines @@
 }
 
 int SkCodec::outputScanline(int inputScanline) const {
     SkASSERT(0 <= inputScanline && inputScanline < this->getInfo().height());
     return this->onOutputScanline(inputScanline);
 }
 
 int SkCodec::onOutputScanline(int inputScanline) const {
     switch (this->getScanlineOrder()) {
         case kTopDown_SkScanlineOrder:
+        case kNone_SkScanlineOrder:
             return inputScanline;
         case kBottomUp_SkScanlineOrder:
             return this->getInfo().height() - inputScanline - 1;
         default:
             // This case indicates an interlaced gif and is implemented by SkGifCodec.
             SkASSERT(false);
             return 0;
     }
 }
 
@@ skipping 13 matching lines @@
     const uint32_t fillValue = this->getFillValue(info.colorType());
     const int linesRemaining = linesRequested - linesDecoded;
     SkSampler* sampler = this->getSampler(false);
 
     int fillWidth = info.width();
     if (fOptions.fSubset) {
         fillWidth = fOptions.fSubset->width();
     }
 
     switch (this->getScanlineOrder()) {
-        case kTopDown_SkScanlineOrder: {
+        case kTopDown_SkScanlineOrder:
+        case kNone_SkScanlineOrder: {
             const SkImageInfo fillInfo = info.makeWH(fillWidth, linesRemaining);
             fillDst = SkTAddOffset<void>(dst, linesDecoded * rowBytes);
             fill_proc(fillInfo, fillDst, rowBytes, fillValue, zeroInit, sampler);
             break;
         }
         case kBottomUp_SkScanlineOrder: {
             fillDst = dst;
             const SkImageInfo fillInfo = info.makeWH(fillWidth, linesRemaining);
             fill_proc(fillInfo, fillDst, rowBytes, fillValue, zeroInit, sampler);
             break;
         }
         case kOutOfOrder_SkScanlineOrder: {
             SkASSERT(1 == linesRequested || this->getInfo().height() == linesRequested);
             const SkImageInfo fillInfo = info.makeWH(fillWidth, 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;
         }
     }
 }