Make swizzler optional for SkPngCodec, refactor xforms

src/codec/SkPngCodec.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 "SkBitmap.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 362 matching lines @@
         case kBGRA_8888_SkColorType:
         case kRGBA_F16_SkColorType:
             return true;
         case kRGB_565_SkColorType:
             return kOpaque_SkAlphaType == src.alphaType();
         default:
             return dst.colorType() == src.colorType();
     }
 }
 
-void SkPngCodec::allocateStorage() {
-    size_t colorXformBytes = fColorXform ? fSwizzler->swizzleWidth() * sizeof(uint32_t) : 0;
-
-    fStorage.reset(SkAlign4(fSrcRowBytes) + colorXformBytes);
-    fSwizzlerSrcRow = fStorage.get();
-    fColorXformSrcRow =
-            fColorXform ? SkTAddOffset<uint32_t>(fSwizzlerSrcRow, SkAlign4(fSrcRowBytes)) : 0;
+void SkPngCodec::allocateStorage(const SkImageInfo& dstInfo) {
+    switch (fXformMode) {
+        case kSwizzleOnly_XformMode:
+            fStorage.reset(SkAlign4(fSrcRowBytes));
+            fSwizzlerSrcRow = fStorage.get();
+            break;
+        case kColorOnly_XformMode:
+            // Intentional fall through.  A swizzler hasn't been created yet, but one will
+            // be created later if we are sampling or subsetting.  We'll go ahead and allocate
+            // enough memory to swizzle if necessary.
+        case kSwizzleColor_XformMode: {
+            size_t colorXformBytes = dstInfo.width() * sizeof(uint32_t);
+            fStorage.reset(SkAlign4(fSrcRowBytes) + colorXformBytes);
+            fSwizzlerSrcRow = fStorage.get();
+            fColorXformSrcRow = SkTAddOffset<uint32_t>(fSwizzlerSrcRow, SkAlign4(fSrcRowBytes));
+            break;
+        }
+    }
 }
 
-static inline bool apply_xform_on_decode(SkColorType dstColorType, SkEncodedInfo::Color srcColor) {
-    // We will apply the color xform when reading the color table, unless F16 is requested.
-    return SkEncodedInfo::kPalette_Color != srcColor || kRGBA_F16_SkColorType == dstColorType;
+void SkPngCodec::applyXformRow(void* dst, const void* src, SkColorType colorType,
+                               SkAlphaType alphaType, int width) {
+    switch (fXformMode) {
+        case kSwizzleOnly_XformMode:
+            fSwizzler->swizzle(dst, (const uint8_t*) src);
+            break;
+        case kColorOnly_XformMode:
+            fColorXform->apply(dst, (const uint32_t*) src, width, colorType, alphaType);
+            break;
+        case kSwizzleColor_XformMode:
+            fSwizzler->swizzle(fColorXformSrcRow, (const uint8_t*) src);
+            fColorXform->apply(dst, fColorXformSrcRow, width, colorType, alphaType);
+            break;
+    }
 }
 
 class SkPngNormalCodec : public SkPngCodec {
 public:
     SkPngNormalCodec(const SkEncodedInfo& encodedInfo, const SkImageInfo& imageInfo,
             SkStream* stream, SkPngChunkReader* chunkReader, png_structp png_ptr,
             png_infop info_ptr, int bitDepth)
         : INHERITED(encodedInfo, imageInfo, stream, chunkReader, png_ptr, info_ptr, bitDepth, 1)
     {}
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
         if (!png_conversion_possible(dstInfo, this->getInfo()) ||
             !this->initializeXforms(dstInfo, options, ctable, ctableCount))
         {
             return kInvalidConversion;
         }
 
-        this->allocateStorage();
+        this->allocateStorage(dstInfo);
         return kSuccess;
     }
 
     int readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count, int startRow)
     override {
         SkASSERT(0 == startRow);
 
         // Assume that an error in libpng indicates an incomplete input.
         int y = 0;
         if (setjmp(png_jmpbuf((png_struct*)fPng_ptr))) {
             SkCodecPrintf("Failed to read row.\n");
             return y;
         }
 
-        void* swizzlerDstRow = dst;
-        size_t swizzlerDstRowBytes = rowBytes;
-
-        bool colorXform = fColorXform &&
-                apply_xform_on_decode(dstInfo.colorType(), this->getEncodedInfo().color());
-        if (colorXform) {
-            swizzlerDstRow = fColorXformSrcRow;
-            swizzlerDstRowBytes = 0;
-        }
-
         SkAlphaType xformAlphaType = xform_alpha_type(dstInfo.alphaType(),
                                                       this->getInfo().alphaType());
+        int width = fSwizzler ? fSwizzler->swizzleWidth() : dstInfo.width();
+
         for (; y < count; y++) {
             png_read_row(fPng_ptr, fSwizzlerSrcRow, nullptr);
-            fSwizzler->swizzle(swizzlerDstRow, fSwizzlerSrcRow);
-
-            if (colorXform) {
-                fColorXform->apply(dst, (const uint32_t*) swizzlerDstRow, fSwizzler->swizzleWidth(),
-                                   dstInfo.colorType(), xformAlphaType);
-                dst = SkTAddOffset<void>(dst, rowBytes);
-            }
-
-            swizzlerDstRow = SkTAddOffset<void>(swizzlerDstRow, swizzlerDstRowBytes);
+            this->applyXformRow(dst, fSwizzlerSrcRow, dstInfo.colorType(), xformAlphaType, width);
+            dst = SkTAddOffset<void>(dst, rowBytes);
         }
 
         return y;
     }
 
     int onGetScanlines(void* dst, int count, size_t rowBytes) override {
         return this->readRows(this->dstInfo(), dst, rowBytes, count, 0);
     }
 
     bool onSkipScanlines(int count) override {
@@ skipping 24 matching lines @@
     }
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
         if (!png_conversion_possible(dstInfo, this->getInfo()) ||
             !this->initializeXforms(dstInfo, options, ctable, ctableCount))
         {
             return kInvalidConversion;
         }
 
-        this->allocateStorage();
+        this->allocateStorage(dstInfo);
         fCanSkipRewind = true;
         return SkCodec::kSuccess;
     }
 
     int readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count, int startRow)
     override {
         if (setjmp(png_jmpbuf((png_struct*)fPng_ptr))) {
             SkCodecPrintf("Failed to get scanlines.\n");
             // FIXME (msarett): Returning 0 is pessimistic.  If we can complete a single pass,
             // we may be able to report that all of the memory has been initialized.  Even if we
@@ skipping 13 matching lines @@
             for (int y = 0; y < count; y++) {
                 png_read_row(fPng_ptr, srcRow, nullptr);
                 srcRow += fSrcRowBytes;
             }
             // Discard rows that we don't need.
             for (int y = 0; y < this->getInfo().height() - startRow - count; y++) {
                 png_read_row(fPng_ptr, fSwizzlerSrcRow, nullptr);
             }
         }
 
-        // Swizzle and xform the rows we care about
-        void* swizzlerDstRow = dst;
-        size_t swizzlerDstRowBytes = rowBytes;
-
-        bool colorXform = fColorXform &&
-                apply_xform_on_decode(dstInfo.colorType(), this->getEncodedInfo().color());
-        if (colorXform) {
-            swizzlerDstRow = fColorXformSrcRow;
-            swizzlerDstRowBytes = 0;
-        }
-
         SkAlphaType xformAlphaType = xform_alpha_type(dstInfo.alphaType(),
                                                       this->getInfo().alphaType());
+        int width = fSwizzler ? fSwizzler->swizzleWidth() : dstInfo.width();
         srcRow = storage.get();
         for (int y = 0; y < count; y++) {
-            fSwizzler->swizzle(swizzlerDstRow, srcRow);
+            this->applyXformRow(dst, srcRow, dstInfo.colorType(), xformAlphaType, width);
             srcRow = SkTAddOffset<uint8_t>(srcRow, fSrcRowBytes);
-
-            if (colorXform) {
-                fColorXform->apply(dst, (const uint32_t*) swizzlerDstRow, fSwizzler->swizzleWidth(),
-                                   dstInfo.colorType(), xformAlphaType);
-                dst = SkTAddOffset<void>(dst, rowBytes);
-            }
-
-            swizzlerDstRow = SkTAddOffset<void>(swizzlerDstRow, swizzlerDstRowBytes);
+            dst = SkTAddOffset<void>(dst, rowBytes);
         }
 
         return count;
     }
 
     int onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // rewind stream if have previously called onGetScanlines,
         // since we need entire progressive image to get scanlines
         if (fCanSkipRewind) {
             // We already rewound in onStartScanlineDecode, so there is no reason to rewind.
@@ skipping 245 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkPngCodec::initializeXforms(const SkImageInfo& dstInfo, const Options& options,
                                   SkPMColor ctable[], int* ctableCount) {
     if (setjmp(png_jmpbuf((png_struct*)fPng_ptr))) {
         SkCodecPrintf("Failed on png_read_update_info.\n");
         return false;
     }
     png_read_update_info(fPng_ptr, fInfo_ptr);
 
-    // It's important to reset fColorXform to nullptr.  We don't do this on rewinding
-    // because the interlaced scanline decoder may need to rewind.
+    // Reset fSwizzler and fColorXform.  We can't do this in onRewind() because the
+    // interlaced scanline decoder may need to rewind.
+    fSwizzler.reset(nullptr);
     fColorXform = nullptr;
-    SkImageInfo swizzlerInfo = dstInfo;
-    Options swizzlerOptions = options;
+
     bool needsColorXform = needs_color_xform(dstInfo, this->getInfo());
     if (needsColorXform) {
-        switch (dstInfo.colorType()) {
-            case kRGBA_8888_SkColorType:
-            case kBGRA_8888_SkColorType:
-            case kRGBA_F16_SkColorType:
-                swizzlerInfo = swizzlerInfo.makeColorType(kRGBA_8888_SkColorType);
-                if (kPremul_SkAlphaType == dstInfo.alphaType()) {
-                    swizzlerInfo = swizzlerInfo.makeAlphaType(kUnpremul_SkAlphaType);
-                }
-                break;
-            case kIndex_8_SkColorType:
-                break;
-            default:
-                return false;
+        if (kGray_8_SkColorType == dstInfo.colorType()) {
+            // FIXME (msarett):
+            // Support color xforms for gray output?
+            return false;
         }
 
         fColorXform = SkColorSpaceXform::New(sk_ref_sp(this->getInfo().colorSpace()),
                                              sk_ref_sp(dstInfo.colorSpace()));
 
         if (!fColorXform && kRGBA_F16_SkColorType == dstInfo.colorType()) {
             return false;
         }
+    }
 
-        // When there is a color xform, we swizzle into temporary memory, which is not
-        // zero initialized.
-        // FIXME (msarett):
-        // Is this a problem?
-        swizzlerOptions.fZeroInitialized = kNo_ZeroInitialized;
+    // If the image is RGBA and we have a color xform, we can skip the swizzler.
+    // FIXME (msarett):
+    // Support more input types to fColorXform (ex: RGB, Gray) and skip the swizzler more often.
+    if (fColorXform && SkEncodedInfo::kRGBA_Color == this->getEncodedInfo().color() &&
+        !options.fSubset)
+    {
+        fXformMode = kColorOnly_XformMode;
+        return true;
     }
 
     if (SkEncodedInfo::kPalette_Color == this->getEncodedInfo().color()) {
         if (!this->createColorTable(dstInfo, ctableCount)) {
             return false;
         }
     }
 
-    // Copy the color table to the client if they request kIndex8 mode
-    copy_color_table(swizzlerInfo, fColorTable, ctable, ctableCount);
+    // Copy the color table to the client if they request kIndex8 mode.
+    copy_color_table(dstInfo, fColorTable, ctable, ctableCount);
 
-    // Create the swizzler.  SkPngCodec retains ownership of the color table.
+    this->initializeSwizzler(dstInfo, options);
+    return true;
+}
+
+static inline bool apply_xform_on_decode(SkColorType dstColorType, SkEncodedInfo::Color srcColor) {
+    // We will apply the color xform when reading the color table, unless F16 is requested.
+    return SkEncodedInfo::kPalette_Color != srcColor || kRGBA_F16_SkColorType == dstColorType;
+}
+
+void SkPngCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& options) {
+    SkImageInfo swizzlerInfo = dstInfo;
+    Options swizzlerOptions = options;
+    fXformMode = kSwizzleOnly_XformMode;
+    if (fColorXform && apply_xform_on_decode(dstInfo.colorType(), this->getEncodedInfo().color())) {
+        swizzlerInfo = swizzlerInfo.makeColorType(kRGBA_8888_SkColorType);
+        if (kPremul_SkAlphaType == dstInfo.alphaType()) {
+            swizzlerInfo = swizzlerInfo.makeAlphaType(kUnpremul_SkAlphaType);
+        }
+
+        fXformMode = kSwizzleColor_XformMode;
+
+        // Here, we swizzle into temporary memory, which is not zero initialized.
+        // FIXME (msarett):
+        // Is this a problem?
+        swizzlerOptions.fZeroInitialized = kNo_ZeroInitialized;
+    }
+
     const SkPMColor* colors = get_color_ptr(fColorTable.get());
     fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colors, swizzlerInfo,
                                                swizzlerOptions));
     SkASSERT(fSwizzler);
-    return true;
+}
+
+SkSampler* SkPngCodec::getSampler(bool createIfNecessary) {
+    if (fSwizzler || !createIfNecessary) {
+        return fSwizzler;
+    }
+
+    this->initializeSwizzler(this->dstInfo(), this->options());
+    return fSwizzler;
 }
 
 bool SkPngCodec::onRewind() {
     // This sets fPng_ptr and fInfo_ptr to nullptr. If read_header
     // succeeds, they will be repopulated, and if it fails, they will
     // remain nullptr. Any future accesses to fPng_ptr and fInfo_ptr will
     // come through this function which will rewind and again attempt
     // to reinitialize them.
     this->destroyReadStruct();
 
@@ skipping 15 matching lines @@
     if (!png_conversion_possible(dstInfo, this->getInfo()) ||
         !this->initializeXforms(dstInfo, options, ctable, ctableCount))
     {
         return kInvalidConversion;
     }
 
     if (options.fSubset) {
         return kUnimplemented;
     }
 
-    this->allocateStorage();
+    this->allocateStorage(dstInfo);
     int count = this->readRows(dstInfo, dst, rowBytes, dstInfo.height(), 0);
     if (count > dstInfo.height()) {
         *rowsDecoded = count;
         return kIncompleteInput;
     }
 
     return kSuccess;
 }
 
 uint32_t SkPngCodec::onGetFillValue(SkColorType colorType) const {
@@ skipping 10 matching lines @@
     SkCodec* outCodec;
     if (read_header(stream, chunkReader, &outCodec, nullptr, nullptr)) {
         // Codec has taken ownership of the stream.
         SkASSERT(outCodec);
         streamDeleter.release();
         return outCodec;
     }
 
     return nullptr;
 }