Fix color xform width bug when scaling/subsetting

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 340 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(const SkImageInfo& dstInfo) {
-    const int width = this->getInfo().width();
-    size_t colorXformBytes = fColorXform ? width * sizeof(uint32_t) : 0;
+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;
 }
 
 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(dstInfo);
+        this->allocateStorage();
         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(fPng_ptr))) {
             SkCodecPrintf("Failed to read row.\n");
             return y;
         }
 
         void* swizzlerDstRow = dst;
         size_t swizzlerDstRowBytes = rowBytes;
         if (fColorXform) {
             swizzlerDstRow = fColorXformSrcRow;
             swizzlerDstRowBytes = 0;
         }
 
         SkAlphaType xformAlphaType = (kOpaque_SkAlphaType == this->getInfo().alphaType()) ?
                 kOpaque_SkAlphaType : dstInfo.alphaType();
         for (; y < count; y++) {
             png_read_row(fPng_ptr, fSwizzlerSrcRow, nullptr);
             fSwizzler->swizzle(swizzlerDstRow, fSwizzlerSrcRow);
 
             if (fColorXform) {
-                fColorXform->apply(dst, (const uint32_t*) swizzlerDstRow, dstInfo.width(),
+                fColorXform->apply(dst, (const uint32_t*) swizzlerDstRow, fSwizzler->swizzleWidth(),
                                    dstInfo.colorType(), xformAlphaType);
                 dst = SkTAddOffset<void>(dst, rowBytes);
             }
 
             swizzlerDstRow = SkTAddOffset<void>(swizzlerDstRow, swizzlerDstRowBytes);
         }
 
         return y;
     }
 
@@ skipping 30 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(dstInfo);
+        this->allocateStorage();
         fCanSkipRewind = true;
         return SkCodec::kSuccess;
     }
 
     int readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count, int startRow)
     override {
         if (setjmp(png_jmpbuf(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 30 matching lines @@
 
         SkAlphaType xformAlphaType = (kOpaque_SkAlphaType == this->getInfo().alphaType()) ?
                 kOpaque_SkAlphaType : dstInfo.alphaType();
         srcRow = storage.get();
         for (int y = 0; y < count; y++) {
             fSwizzler->swizzle(swizzlerDstRow, srcRow);
             srcRow = SkTAddOffset<uint8_t>(srcRow, fSrcRowBytes);
 
             if (fColorXform) {
                 if (fColorXform) {
-                    fColorXform->apply(dst, (const uint32_t*) swizzlerDstRow, dstInfo.width(),
-                                       dstInfo.colorType(), xformAlphaType);
+                    fColorXform->apply(dst, (const uint32_t*) swizzlerDstRow,
+                                       fSwizzler->swizzleWidth(), dstInfo.colorType(),
+                                       xformAlphaType);
                     dst = SkTAddOffset<void>(dst, rowBytes);
                 }
             }
 
             swizzlerDstRow = SkTAddOffset<void>(swizzlerDstRow, swizzlerDstRowBytes);
         }
 
         return count;
     }
 
@@ skipping 328 matching lines @@
     if (!png_conversion_possible(dstInfo, this->getInfo()) ||
         !this->initializeXforms(dstInfo, options, ctable, ctableCount))
     {
         return kInvalidConversion;
     }
 
     if (options.fSubset) {
         return kUnimplemented;
     }
 
-    this->allocateStorage(dstInfo);
+    this->allocateStorage();
     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;
 }