Create a scanline decoder without creating a codec

src/codec/SkCodec_libpng.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 "SkCodec_libpng.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 576 matching lines @@
         return kSuccess;
     }
 
     // read rest of file, and get additional comment and time chunks in info_ptr
     png_read_end(fPng_ptr, fInfo_ptr);
     return kSuccess;
 }
 
 class SkPngScanlineDecoder : public SkScanlineDecoder {
 public:
-    SkPngScanlineDecoder(const SkImageInfo& dstInfo, SkPngCodec* codec)
-        : INHERITED(dstInfo)
+    SkPngScanlineDecoder(const SkImageInfo& srcInfo, SkPngCodec* codec)
+        : INHERITED(srcInfo)
         , fCodec(codec)
         , fHasAlpha(false)
+    {}
+
+    SkCodec::Result onStart(const SkImageInfo& dstInfo,
+                            const SkCodec::Options& options,
+                            SkPMColor ctable[], int* ctableCount) override
     {
+        if (!fCodec->handleRewind()) {
+            return SkCodec::kCouldNotRewind;
+        }
+
+        if (!conversion_possible(dstInfo, this->getInfo())) {
+            return SkCodec::kInvalidConversion;
+        }
+
+        // Check to see if scaling was requested.
+        if (dstInfo.dimensions() != this->getInfo().dimensions()) {
+            return SkCodec::kInvalidScale;
+        }
+
+        const SkCodec::Result result = fCodec->initializeSwizzler(dstInfo, options, ctable,
+                                                                  ctableCount);
+        if (result != SkCodec::kSuccess) {
+            return result;
+        }
+
+        fHasAlpha = false;
         fStorage.reset(dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
         fSrcRow = static_cast<uint8_t*>(fStorage.get());
+
+        return SkCodec::kSuccess;
     }
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
         if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
             SkCodecPrintf("setjmp long jump!\n");
             return SkCodec::kInvalidInput;
         }
 
         void* dstRow = dst;
         for (int i = 0; i < count; i++) {
@@ skipping 27 matching lines @@
     bool                        fHasAlpha;
     SkAutoMalloc                fStorage;
     uint8_t*                    fSrcRow;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 
 class SkPngInterlacedScanlineDecoder : public SkScanlineDecoder {
 public:
-    SkPngInterlacedScanlineDecoder(const SkImageInfo& dstInfo, SkPngCodec* codec)
-        : INHERITED(dstInfo)
+    SkPngInterlacedScanlineDecoder(const SkImageInfo& srcInfo, SkPngCodec* codec)
+        : INHERITED(srcInfo)
         , fCodec(codec)
         , fHasAlpha(false)
         , fCurrentRow(0)
-        , fHeight(dstInfo.height())
+        , fHeight(srcInfo.height())
+        , fCanSkipRewind(false)
+    {}
+
+    SkCodec::Result onStart(const SkImageInfo& dstInfo,
+                            const SkCodec::Options& options,
+                            SkPMColor ctable[], int* ctableCount) override
     {
+        if (!fCodec->handleRewind()) {
+            return SkCodec::kCouldNotRewind;
+        }
+
+        if (!conversion_possible(dstInfo, this->getInfo())) {
+            return SkCodec::kInvalidConversion;
+        }
+
+        // Check to see if scaling was requested.
+        if (dstInfo.dimensions() != this->getInfo().dimensions()) {
+            return SkCodec::kInvalidScale;
+        }
+
+        const SkCodec::Result result = fCodec->initializeSwizzler(dstInfo, options, ctable,
+                                                                  ctableCount);
+        if (result != SkCodec::kSuccess) {
+            return result;
+        }
+
+        fHasAlpha = false;
+        fCurrentRow = 0;
+        fHeight = dstInfo.height();
         fSrcRowBytes = dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig);
         fGarbageRow.reset(fSrcRowBytes);
         fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
+        fCanSkipRewind = true;
+
+        return SkCodec::kSuccess;
     }
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
-        //rewind stream if have previously called onGetScanlines, 
-        //since we need entire progressive image to get scanlines
-        if (!fCodec->handleRewind()) {
+        // rewind stream if have previously called onGetScanlines,
+        // since we need entire progressive image to get scanlines
+        if (fCanSkipRewind) {
+            // We already rewound in onStart, so there is no reason to rewind.
+            // Next time onGetScanlines is called, we will need to rewind.
+            fCanSkipRewind = false;
+        } else if (!fCodec->handleRewind()) {
             return SkCodec::kCouldNotRewind;
         }
+
         if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
             SkCodecPrintf("setjmp long jump!\n");
             return SkCodec::kInvalidInput;
         }
         const int number_passes = png_set_interlace_handling(fCodec->fPng_ptr);
         SkAutoMalloc storage(count * fSrcRowBytes);
         uint8_t* storagePtr = static_cast<uint8_t*>(storage.get());
         uint8_t* srcRow;
         for (int i = 0; i < number_passes; i++) {
             //read rows we planned to skip into garbage row
@@ skipping 32 matching lines @@
     bool onReallyHasAlpha() const override { return fHasAlpha; }
 
 private:
     SkAutoTDelete<SkPngCodec>   fCodec;
     bool                        fHasAlpha;
     int                         fCurrentRow;
     int                         fHeight;
     size_t                      fSrcRowBytes;
     SkAutoMalloc                fGarbageRow;
     uint8_t*                    fGarbageRowPtr;
+    // FIXME: This imitates behavior in SkCodec::rewindIfNeeded. That function
+    // is called whenever some action is taken that reads the stream and
+    // therefore the next call will require a rewind. So it modifies a boolean
+    // to note that the *next* time it is called a rewind is needed.
+    // SkPngInterlacedScanlineDecoder has an extra wrinkle - calling onStart
+    // followed by onGetScanlines does *not* require a rewind. Since
+    // rewindIfNeeded does not have this flexibility, we need to add another
+    // layer.
+    bool                        fCanSkipRewind;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
-
-SkScanlineDecoder* SkPngCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo,
-        const Options& options, SkPMColor ctable[], int* ctableCount) {
-    if (!conversion_possible(dstInfo, this->getInfo())) {
-        SkCodecPrintf("no conversion possible\n");
-        return NULL;
-    }
-    // Check to see if scaling was requested.
-    if (dstInfo.dimensions() != this->getInfo().dimensions()) {
-        return NULL;
-    }
-    // Create a new SkPngCodec, to be owned by the scanline decoder.
-    SkStream* stream = this->stream()->duplicate();
-    if (!stream) {
-        return NULL;
-    }
+SkScanlineDecoder* SkPngCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkPngCodec> codec (static_cast<SkPngCodec*>(SkPngCodec::NewFromStream(stream)));
     if (!codec) {
         return NULL;
     }
 
-    if (codec->initializeSwizzler(dstInfo, options, ctable, ctableCount) != kSuccess) {
-        SkCodecPrintf("failed to initialize the swizzler.\n");
-        return NULL;
+    codec->fNumberPasses = png_set_interlace_handling(codec->fPng_ptr);
+    SkASSERT(codec->fNumberPasses != INVALID_NUMBER_PASSES);
+
+    const SkImageInfo& srcInfo = codec->getInfo();
+    if (codec->fNumberPasses > 1) {
+        // interlaced image
+        return SkNEW_ARGS(SkPngInterlacedScanlineDecoder, (srcInfo, codec.detach()));
     }
 
-    SkASSERT(codec->fNumberPasses != INVALID_NUMBER_PASSES);
-    if (codec->fNumberPasses > 1) {
-        // interlaced image
-        return SkNEW_ARGS(SkPngInterlacedScanlineDecoder, (dstInfo, codec.detach()));
-    }
-
-    return SkNEW_ARGS(SkPngScanlineDecoder, (dstInfo, codec.detach()));
+    return SkNEW_ARGS(SkPngScanlineDecoder, (srcInfo, codec.detach()));
 }