Add scanline decoding to SkCodec.

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 "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkBitmap.h"
 #include "SkMath.h"
+#include "SkScanlineDecoder.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper macros
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef png_jmpbuf
 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
@@ skipping 83 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.
-SkColorTable* decode_palette(png_structp png_ptr, png_infop info_ptr,
-                             bool premultiply, SkAlphaType* outAlphaType) {
-    SkASSERT(outAlphaType != NULL);
+bool SkPngCodec::decodePalette(bool premultiply) {
     int numPalette;
     png_colorp palette;
     png_bytep trans;
 
-    if (!png_get_PLTE(png_ptr, info_ptr, &palette, &numPalette)) {
-        return NULL;
+    if (!png_get_PLTE(fPng_ptr, fInfo_ptr, &palette, &numPalette)) {
+        return false;
     }
 
     /*  BUGGY IMAGE WORKAROUND
 
         We hit some images (e.g. fruit_.png) who contain bytes that are == colortable_count
         which is a problem since we use the byte as an index. To work around this we grow
         the colortable by 1 (if its < 256) and duplicate the last color into that slot.
     */
     const int colorCount = numPalette + (numPalette < 256);
     // Note: These are not necessarily SkPMColors.
     SkPMColor colorStorage[256];    // worst-case storage
     SkPMColor* colorPtr = colorStorage;
 
     int numTrans;
-    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
-        png_get_tRNS(png_ptr, info_ptr, &trans, &numTrans, NULL);
+    if (png_get_valid(fPng_ptr, fInfo_ptr, PNG_INFO_tRNS)) {
+        png_get_tRNS(fPng_ptr, fInfo_ptr, &trans, &numTrans, NULL);
     } else {
         numTrans = 0;
     }
 
     // check for bad images that might make us crash
     if (numTrans > numPalette) {
         numTrans = numPalette;
     }
 
     int index = 0;
     int transLessThanFF = 0;
 
     // Choose which function to use to create the color table. If the final destination's
     // colortype is unpremultiplied, the color table will store unpremultiplied colors.
     PackColorProc proc;
     if (premultiply) {
         proc = &SkPreMultiplyARGB;
     } else {
         proc = &SkPackARGB32NoCheck;
     }
     for (; index < numTrans; index++) {
         transLessThanFF |= (int)*trans - 0xFF;
         *colorPtr++ = proc(*trans++, palette->red, palette->green, palette->blue);
         palette++;
     }
 
-    if (transLessThanFF < 0) {
-        *outAlphaType = premultiply ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
-    } else {
-        *outAlphaType = kOpaque_SkAlphaType;
-    }
+    fReallyHasAlpha = transLessThanFF < 0;
 
     for (; index < numPalette; index++) {
         *colorPtr++ = SkPackARGB32(0xFF, palette->red, palette->green, palette->blue);
         palette++;
     }
 
     // see BUGGY IMAGE WORKAROUND comment above
     if (numPalette < 256) {
         *colorPtr = colorPtr[-1];
     }
 
-    return SkNEW_ARGS(SkColorTable, (colorStorage, colorCount));
+    fColorTable.reset(SkNEW_ARGS(SkColorTable, (colorStorage, colorCount)));
+    return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Creation
 ///////////////////////////////////////////////////////////////////////////////
 
 #define PNG_BYTES_TO_CHECK 4
 
 bool SkPngCodec::IsPng(SkStream* stream) {
     char buf[PNG_BYTES_TO_CHECK];
@@ skipping 131 matching lines @@
 
     // FIXME: Also need to check for sRGB (skbug.com/3471).
 
     SkImageInfo info = SkImageInfo::Make(origWidth, origHeight, skColorType,
                                          skAlphaType);
     SkCodec* codec = SkNEW_ARGS(SkPngCodec, (info, stream, png_ptr, info_ptr));
     autoClean.detach();
     return codec;
 }
 
+#define INVALID_NUMBER_PASSES -1
 SkPngCodec::SkPngCodec(const SkImageInfo& info, SkStream* stream,
                        png_structp png_ptr, png_infop info_ptr)
     : INHERITED(info, stream)
     , fPng_ptr(png_ptr)
-    , fInfo_ptr(info_ptr) {}
+    , fInfo_ptr(info_ptr)
+    , fSc(SkSwizzler::kUnknown)
+    , fNumberPasses(INVALID_NUMBER_PASSES)
+    , fReallyHasAlpha(false)
+{}
 
 SkPngCodec::~SkPngCodec() {
     png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Getting the pixels
 ///////////////////////////////////////////////////////////////////////////////
 
 static bool premul_and_unpremul(SkAlphaType A, SkAlphaType B) {
     return kPremul_SkAlphaType == A && kUnpremul_SkAlphaType == B;
 }
 
 static bool conversion_possible(const SkImageInfo& A, const SkImageInfo& B) {
     // TODO: Support other conversions
     if (A.colorType() != B.colorType()) {
         return false;
     }
     if (A.profileType() != B.profileType()) {
         return false;
     }
     if (A.alphaType() == B.alphaType()) {
         return true;
     }
     return premul_and_unpremul(A.alphaType(), B.alphaType())
             || premul_and_unpremul(B.alphaType(), A.alphaType());
 }
 
-SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
-                                        size_t rowBytes, SkPMColor ctable[],
-                                        int* ctableCount) {
-    if (!this->rewindIfNeeded()) {
-        return kCouldNotRewind;
-    }
-    if (requestedInfo.dimensions() != this->getOriginalInfo().dimensions()) {
-        return kInvalidScale;
-    }
-    if (!conversion_possible(requestedInfo, this->getOriginalInfo())) {
-        return kInvalidConversion;
-    }
-
-    SkBitmap decodedBitmap;
-    // If installPixels would have failed, getPixels should have failed before
-    // calling onGetPixels.
-    SkAssertResult(decodedBitmap.installPixels(requestedInfo, dst, rowBytes));
-
-    // Initialize all non-trivial objects before setjmp.
-    SkAutoTUnref<SkColorTable> colorTable;
-    SkAutoTDelete<SkSwizzler> swizzler;
-    SkAutoMalloc storage;                   // Scratch memory for pre-swizzled rows.
-
+SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo, void* dst,
+                                               size_t rowBytes) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkDebugf("setjmp long jump!\n");
         return kInvalidInput;
     }
 
     // FIXME: We already retrieved this information. Store it in SkPngCodec?
     png_uint_32 origWidth, origHeight;
     int bitDepth, pngColorType, interlaceType;
     png_get_IHDR(fPng_ptr, fInfo_ptr, &origWidth, &origHeight, &bitDepth,
                  &pngColorType, &interlaceType, int_p_NULL, int_p_NULL);
 
-    const int numberPasses = (interlaceType != PNG_INTERLACE_NONE) ?
+    fNumberPasses = (interlaceType != PNG_INTERLACE_NONE) ?
             png_set_interlace_handling(fPng_ptr) : 1;
 
-    SkSwizzler::SrcConfig sc;
-    bool reallyHasAlpha = false;
+    // Set to the default before calling decodePalette, which may change it.
+    fReallyHasAlpha = false;
     if (PNG_COLOR_TYPE_PALETTE == pngColorType) {
-        sc = SkSwizzler::kIndex;
-        SkAlphaType at = requestedInfo.alphaType();
-        colorTable.reset(decode_palette(fPng_ptr, fInfo_ptr,
-                                        kPremul_SkAlphaType == at,
-                                        &at));
-        if (!colorTable) {
+        fSc = SkSwizzler::kIndex;
+        if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType())) {
             return kInvalidInput;
         }
-
-        reallyHasAlpha = (at != kOpaque_SkAlphaType);
-
-        if (at != requestedInfo.alphaType()) {
-            // It turns out the image is opaque.
-            SkASSERT(kOpaque_SkAlphaType == at);
-        }
     } else if (kAlpha_8_SkColorType == requestedInfo.colorType()) {
         // Note: we check the destination, since otherwise we would have
         // told png to upscale.
         SkASSERT(PNG_COLOR_TYPE_GRAY == pngColorType);
-        sc = SkSwizzler::kGray;
+        fSc = SkSwizzler::kGray;
     } else if (this->getOriginalInfo().alphaType() == kOpaque_SkAlphaType) {
-        sc = SkSwizzler::kRGBX;
+        fSc = SkSwizzler::kRGBX;
     } else {
-        sc = SkSwizzler::kRGBA;
+        fSc = SkSwizzler::kRGBA;
     }
-    const SkPMColor* colors = colorTable ? colorTable->readColors() : NULL;
+    const SkPMColor* colors = fColorTable ? fColorTable->readColors() : NULL;
     // TODO: Support skipZeroes.
-    swizzler.reset(SkSwizzler::CreateSwizzler(sc, colors, requestedInfo,
-                                              dst, rowBytes, false));
-    if (!swizzler) {
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(fSc, colors, requestedInfo,
+                                               dst, rowBytes, false));
+    if (!fSwizzler) {
         // FIXME: CreateSwizzler could fail for another reason.
         return kUnimplemented;
     }
 
     // FIXME: Here is where we should likely insert some of the modifications
     // made in the factory.
     png_read_update_info(fPng_ptr, fInfo_ptr);
 
-    if (numberPasses > 1) {
+    return kSuccess;
+}
+
+SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
+                                        size_t rowBytes, SkPMColor ctable[],
+                                        int* ctableCount) {
+    if (!this->rewindIfNeeded()) {
+        return kCouldNotRewind;
+    }
+    if (requestedInfo.dimensions() != this->getOriginalInfo().dimensions()) {
+        return kInvalidScale;
+    }
+    if (!conversion_possible(requestedInfo, this->getOriginalInfo())) {
+        return kInvalidConversion;
+    }
+
+    const Result result = this->initializeSwizzler(requestedInfo, dst, rowBytes);
+    if (result != kSuccess) {
+        return result;
+    }
+
+    // FIXME: Could we use the return value of setjmp to specify the type of
+    // error?
+    if (setjmp(png_jmpbuf(fPng_ptr))) {
+        SkDebugf("setjmp long jump!\n");
+        return kInvalidInput;
+    }
+
+    SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
+    SkAutoMalloc storage;
+    if (fNumberPasses > 1) {
         const int width = requestedInfo.width();
         const int height = requestedInfo.height();
-        const int bpp = SkSwizzler::BytesPerPixel(sc);
+        const int bpp = SkSwizzler::BytesPerPixel(fSc);
         const size_t rowBytes = width * bpp;
 
         storage.reset(width * height * bpp);
         uint8_t* const base = static_cast<uint8_t*>(storage.get());
 
-        for (int i = 0; i < numberPasses; i++) {
+        for (int i = 0; i < fNumberPasses; i++) {
             uint8_t* row = base;
             for (int y = 0; y < height; y++) {
                 uint8_t* bmRow = row;
                 png_read_rows(fPng_ptr, &bmRow, png_bytepp_NULL, 1);
                 row += rowBytes;
             }
         }
 
         // Now swizzle it.
         uint8_t* row = base;
         for (int y = 0; y < height; y++) {
-            reallyHasAlpha |= swizzler->next(row);
+            fReallyHasAlpha |= fSwizzler->next(row);
             row += rowBytes;
         }
     } else {
-        storage.reset(requestedInfo.width() * SkSwizzler::BytesPerPixel(sc));
+        storage.reset(requestedInfo.width() * SkSwizzler::BytesPerPixel(fSc));
         uint8_t* srcRow = static_cast<uint8_t*>(storage.get());
         for (int y = 0; y < requestedInfo.height(); y++) {
             png_read_rows(fPng_ptr, &srcRow, png_bytepp_NULL, 1);
-            reallyHasAlpha |= swizzler->next(srcRow);
+            fReallyHasAlpha |= fSwizzler->next(srcRow);
         }
     }
 
+    // FIXME: do we need substituteTranspColor? Note that we cannot do it for
+    // scanline decoding, but we could do it here. Alternatively, we could do
+    // it as we go, instead of in post-processing like SkPNGImageDecoder.
+
+    return this->finish();
+}
+
+SkImageGenerator::Result SkPngCodec::finish() {
+    // FIXME: Maybe these should return incomplete?
+    if (setjmp(png_jmpbuf(fPng_ptr))) {
+        SkDebugf("setjmp long jump!\n");
+        return kInvalidInput;
+    }
     /* read rest of file, and get additional chunks in info_ptr - REQUIRED */
     png_read_end(fPng_ptr, fInfo_ptr);
 
-    // FIXME: do we need substituteTranspColor?
-
-    if (reallyHasAlpha && requestedInfo.alphaType() != kOpaque_SkAlphaType) {
-        // FIXME: We want to alert the caller. Is this the right way?
-        SkImageInfo* modInfo = const_cast<SkImageInfo*>(&requestedInfo);
-        *modInfo = requestedInfo.makeAlphaType(kOpaque_SkAlphaType);
-    }
     return kSuccess;
 }
+
+class SkPngScanlineDecoder : public SkScanlineDecoder {
+public:
+    // FIXME: Need to support subsets...
+    SkPngScanlineDecoder(const SkImageInfo& origInfo, const SkImageInfo& dstInfo,
+                         SkPngCodec* codec)
+        // FIXME: Does SkScanlineDecoder need origInfo? Maybe for subsets?
+        : INHERITED(origInfo, dstInfo)
+        , fDstInfo(dstInfo)
+        , fCodec(codec)
+        , fHasAlpha(false)
+    {
+        fStorage.reset(dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSc));
+        fSrcRow = static_cast<uint8_t*>(fStorage.get());
+    }
+
+    SkImageGenerator::Result onGetNextScanline(void* dst) SK_OVERRIDE {

[reed1, 2015/03/19 15:31:39]

Is it easy to override the N-scanlines method here, partly to offset the cost of
the setjmp/longjmp?

Do we really need both? Why not just have the N version?

[scroggo, 2015/03/19 17:59:19]

Yes.
The N version would offset it some, depending on what the caller supplied as N.

I considered adding the following function:

Result SkScanlineDecoder::setJmp();

Then our longjmp would jump back into that function, and we'd return some bad
result. This would allow us to only call setjmp once. Since not all
implementations need setjmp, and to hide what's going on a little bit from the
caller, we could change the name to something like start() (in keeping with the
call to finish(), at the end).
Maybe not. The 1 version is somewhat simpler, since we don't require the caller
to specify the rowbytes, but certainly it could be implemented/replaced by
calling the N version (and the caller needs to know the rowbytes anyway,
assuming they are using contiguous memory).

+        // FIXME: Could we use the return value of setjmp to specify the type of
+        // error?
+        if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
+            SkDebugf("setjmp long jump!\n");
+            return SkImageGenerator::kInvalidInput;
+        }
+
+        png_read_rows(fCodec->fPng_ptr, &fSrcRow, png_bytepp_NULL, 1);
+        fCodec->fSwizzler->setDstRow(dst);
+        fHasAlpha |= fCodec->fSwizzler->next(fSrcRow);
+        return SkImageGenerator::kSuccess;
+    }
+
+    SkImageGenerator::Result onFinish() SK_OVERRIDE {
+        return fCodec->finish();
+    }
+
+    bool onReallyHasAlpha() const SK_OVERRIDE { return fHasAlpha; }
+
+private:
+    const SkImageInfo&  fDstInfo;
+    SkPngCodec*         fCodec;     // Unowned.
+    bool                fHasAlpha;
+    SkAutoMalloc        fStorage;
+    uint8_t*            fSrcRow;
+
+    typedef SkScanlineDecoder INHERITED;
+};
+
+SkScanlineDecoder* SkPngCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo,
+        const SkIRect& origSubset) {
+    // Check to see if scaling was requested.
+    if (dstInfo.dimensions() != origSubset.size()) {
+        SkDebugf("Scaling not supported: dimensions: %d %d\toriginal: %d %d\n",
+                 dstInfo.width(), dstInfo.height(),
+                 origSubset.width(), origSubset.height());
+        return NULL;
+    }
+
+    if (!conversion_possible(dstInfo, this->getOriginalInfo())) {
+        SkDebugf("no conversion possible\n");
+        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()) != kSuccess) {
+        SkDebugf("failed to initialize the swizzler.\n");
+        return NULL;
+    }
+
+    SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
+    if (fNumberPasses > 1) {
+        // We cannot efficiently do scanline decoding.
+        return NULL;
+    }
+
+    return SkNEW_ARGS(SkPngScanlineDecoder, (this->getOriginalInfo(), dstInfo, this));
+}
+