Allow creating multiple scanline decoders.

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 101 matching lines @@
     png_get_tRNS(png_ptr, info_ptr, &trans, &num_trans, NULL);
     return num_trans > 0;
 }
 
 // Method for coverting to either an SkPMColor or a similarly packed
 // unpremultiplied color.
 typedef uint32_t (*PackColorProc)(U8CPU a, U8CPU r, U8CPU g, U8CPU b);
 
 // Note: SkColorTable claims to store SkPMColors, which is not necessarily
 // the case here.
-bool SkPngCodec::decodePalette(bool premultiply, int bitDepth, int* ctableCount) {
+bool SkPngCodec::decodePalette(bool premultiply, int* ctableCount) {
     int numPalette;
     png_colorp palette;
     png_bytep trans;
 
     if (!png_get_PLTE(fPng_ptr, fInfo_ptr, &palette, &numPalette)) {
         return false;
     }
 
     // Note: These are not necessarily SkPMColors
     SkPMColor colorStorage[256];    // worst-case storage
@@ skipping 36 matching lines @@
     }
 
     /*  BUGGY IMAGE WORKAROUND
         Invalid images could contain pixel values that are greater than the number of palette
         entries. Since we use pixel values as indices into the palette this could result in reading
         beyond the end of the palette which could leak the contents of uninitialized memory. To
         ensure this doesn't happen, we grow the colortable to the maximum size that can be
         addressed by the bitdepth of the image and fill it with the last palette color or black if
         the palette is empty (really broken image).
     */
-    int colorCount = SkTMax(numPalette, 1 << SkTMin(bitDepth, 8));
+    int colorCount = SkTMax(numPalette, 1 << SkTMin(fBitDepth, 8));
     SkPMColor lastColor = index > 0 ? colorPtr[-1] : SkPackARGB32(0xFF, 0, 0, 0);
     for (; index < colorCount; index++) {
         *colorPtr++ = lastColor;
     }
 
     // Set the new color count
     if (ctableCount != NULL) {
         *ctableCount = colorCount;
     }
 
@@ skipping 176 matching lines @@
     : INHERITED(info, stream)
     , fPng_ptr(png_ptr)
     , fInfo_ptr(info_ptr)
     , fSrcConfig(SkSwizzler::kUnknown)
     , fNumberPasses(INVALID_NUMBER_PASSES)
     , fReallyHasAlpha(false)
     , fBitDepth(bitDepth)
 {}
 
 SkPngCodec::~SkPngCodec() {
-    // First, ensure that the scanline decoder is left in a finished state.
-    SkAutoTDelete<SkScanlineDecoder> decoder(this->detachScanlineDecoder());
-    if (NULL != decoder) {
-        this->finish();
-    }
-
     this->destroyReadStruct();
 }
 
 void SkPngCodec::destroyReadStruct() {
     if (fPng_ptr) {
         // We will never have a NULL fInfo_ptr with a non-NULL fPng_ptr
         SkASSERT(fInfo_ptr);
         png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
         fPng_ptr = NULL;
         fInfo_ptr = NULL;
@@ skipping 54 matching lines @@
     // Set to the default before calling decodePalette, which may change it.
     fReallyHasAlpha = false;
 
     //srcColorType was determined in readHeader() which determined png color type
     const SkColorType srcColorType = this->getInfo().colorType();
 
     switch (srcColorType) {
         case kIndex_8_SkColorType:
             //decode palette to Skia format
             fSrcConfig = SkSwizzler::kIndex;
-            if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(), fBitDepth,
+            if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(),
                     ctableCount)) {
                 return kInvalidInput;
             }
             break;
         case kGray_8_SkColorType:
             fSrcConfig = SkSwizzler::kGray;
             break; 
         case kN32_SkColorType:
             if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
                     fSrcConfig = SkSwizzler::kRGBX;
@@ skipping 48 matching lines @@
             return false;
     }
 }
 
 SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
                                         size_t rowBytes, const Options& options,
                                         SkPMColor ctable[], int* ctableCount) {
     if (!conversion_possible(requestedInfo, this->getInfo())) {
         return kInvalidConversion;
     }
-    // Do not allow a regular decode if the caller has asked for a scanline decoder
-    if (NULL != this->scanlineDecoder()) {
-        SkCodecPrintf("cannot getPixels() if a scanline decoder has been created\n");
-        return kInvalidParameters;
-    }
     if (requestedInfo.dimensions() != this->getInfo().dimensions()) {
         return kInvalidScale;
     }
     if (!this->handleRewind()) {
         return kCouldNotRewind;
     }
 
     // Note that ctable and ctableCount may be modified if there is a color table
     const Result result = this->initializeSwizzler(requestedInfo, dst, rowBytes,
                                                    options, ctable, ctableCount);
@@ skipping 48 matching lines @@
 
     this->finish();
     return kSuccess;
 }
 
 void SkPngCodec::finish() {
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         // We've already read all the scanlines. This is a success.
         return;
     }
+    // FIXME: Is this necessary?

[scroggo, 2015/07/09 20:52:31]

I copied the below comment from SkImageDecoder_libpng.cpp, but as I made this
change I started to wonder whether it was true. It states that it reads the rest
of the file, which made me wonder what would happen in the case of a scanline
decoder, where we potentially have not read the rest of the image. Does it work
in that case?

Looking at the libpng documentation, it sounds like we only need to call it if
we want to find out information stored in the end of the stream, or if we want
to continue reading the stream after the PNG itself - i.e. the PNG is embedded
in some larger stream we want to keep reading from where the PNG left off. This
may be the case where we did a single decode (perhaps we're reading from some
kind of Asset stream on Android that we are expected to leave at the end of the
PNG so something else can continue reading the stream), but if we've already
copied into an SkMemoryStream (as is the case for region decoding), this call
seems unnecessary. Not sure how expensive it is though.

Emmalee, any thoughts?

     /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
     png_read_end(fPng_ptr, fInfo_ptr);
 }
 
 class SkPngScanlineDecoder : public SkScanlineDecoder {
 public:
     SkPngScanlineDecoder(const SkImageInfo& dstInfo, SkPngCodec* codec)
         : INHERITED(dstInfo)
         , fCodec(codec)
         , fHasAlpha(false)
     {
         fStorage.reset(dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
         fSrcRow = static_cast<uint8_t*>(fStorage.get());
     }
 
+    ~SkPngScanlineDecoder() {
+        fCodec->finish();
+    }
+
     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;
         }
 
         for (int i = 0; i < count; i++) {
             png_read_rows(fCodec->fPng_ptr, &fSrcRow, png_bytepp_NULL, 1);
             fCodec->fSwizzler->setDstRow(dst);
             fHasAlpha |= !SkSwizzler::IsOpaque(fCodec->fSwizzler->next(fSrcRow));
@@ skipping 14 matching lines @@
         //as png_read_rows has it's own loop which calls png_read_row count times.
         for (int i = 0; i < count; i++) {
             png_read_rows(fCodec->fPng_ptr, &fSrcRow, png_bytepp_NULL, 1);
         }
         return SkCodec::kSuccess;
     }
 
     bool onReallyHasAlpha() const override { return fHasAlpha; }
 
 private:
-    SkPngCodec*         fCodec;     // Unowned.
-    bool                fHasAlpha;
-    SkAutoMalloc        fStorage;
-    uint8_t*            fSrcRow;
+    SkAutoTDelete<SkPngCodec>   fCodec;
+    bool                        fHasAlpha;
+    SkAutoMalloc                fStorage;
+    uint8_t*                    fSrcRow;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 
 class SkPngInterlacedScanlineDecoder : public SkScanlineDecoder {
 public:
     SkPngInterlacedScanlineDecoder(const SkImageInfo& dstInfo, SkPngCodec* codec)
         : INHERITED(dstInfo)
         , fCodec(codec)
         , fHasAlpha(false)
         , fCurrentRow(0)
         , fHeight(dstInfo.height())
         , fRewindNeeded(false)
     {
         fSrcRowBytes = dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig);
         fGarbageRow.reset(fSrcRowBytes);
         fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
     }
 
+    ~SkPngInterlacedScanlineDecoder() {
+        fCodec->finish();
+    }
+
     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 (fRewindNeeded) {
             if(false == fCodec->handleRewind()) {
                 return SkCodec::kCouldNotRewind;
             }
         } else {
             fRewindNeeded = true;
         }
@@ skipping 35 matching lines @@
 
     SkCodec::Result onSkipScanlines(int count) override {
         //when ongetScanlines is called it will skip to fCurrentRow
         fCurrentRow += count;
         return SkCodec::kSuccess;
     }
 
     bool onReallyHasAlpha() const override { return fHasAlpha; }
 
 private:
-    SkPngCodec*         fCodec;     // Unowned.
-    bool                fHasAlpha;
-    int                 fCurrentRow;
-    int                 fHeight;
-    size_t              fSrcRowBytes;
-    bool                fRewindNeeded;
-    SkAutoMalloc        fGarbageRow;
-    uint8_t*            fGarbageRowPtr;
+    SkAutoTDelete<SkPngCodec>   fCodec;
+    bool                        fHasAlpha;
+    int                         fCurrentRow;
+    int                         fHeight;
+    size_t                      fSrcRowBytes;
+    bool                        fRewindNeeded;
+    SkAutoMalloc                fGarbageRow;
+    uint8_t*                    fGarbageRowPtr;
 
     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;
     }
-    if (!this->handleRewind()) {
+    // Create a new SkPngCodec, to be owned by the scanline decoder.
+    SkStream* stream = this->stream()->duplicate();
+    if (!stream) {
+        return NULL;
+    }
+    SkAutoTDelete<SkPngCodec> codec (static_cast<SkPngCodec*>(SkPngCodec::NewFromStream(stream)));
+    if (!codec) {
         return NULL;
     }
 
     // Note: We set dst to NULL since we do not know it yet. rowBytes is not needed,
     // since we'll be manually updating the dstRow, but the SkSwizzler requires it to
     // be at least dstInfo.minRowBytes.
-    if (this->initializeSwizzler(dstInfo, NULL, dstInfo.minRowBytes(), options, ctable,
+    if (codec->initializeSwizzler(dstInfo, NULL, dstInfo.minRowBytes(), options, ctable,
             ctableCount) != kSuccess) {
         SkCodecPrintf("failed to initialize the swizzler.\n");
         return NULL;
     }
 
     SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
     if (fNumberPasses > 1) {
         // interlaced image
-        return SkNEW_ARGS(SkPngInterlacedScanlineDecoder, (dstInfo, this));
+        return SkNEW_ARGS(SkPngInterlacedScanlineDecoder, (dstInfo, codec.detach()));
     }
 
-    return SkNEW_ARGS(SkPngScanlineDecoder, (dstInfo, this));
+    return SkNEW_ARGS(SkPngScanlineDecoder, (dstInfo, codec.detach()));
 }