Support Float32 output from SkColorSpaceXform

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 131 matching lines @@
                     numColors - numColorsWithAlpha);
         } else {
             SkOpts::RGB_to_BGR1(colorTable + numColorsWithAlpha, palette,
                     numColors - numColorsWithAlpha);
         }
     }
 
     // If we are not decoding to F16, we can color xform now and store the results
     // in the color table.
     if (fColorXform && kRGBA_F16_SkColorType != dstInfo.colorType()) {
-        SkColorType xformColorType = is_rgba(dstInfo.colorType()) ?
-                kRGBA_8888_SkColorType : kBGRA_8888_SkColorType;
-        SkAlphaType xformAlphaType = select_alpha_xform(dstInfo.alphaType(),
+        SkColorSpaceXform::ColorFormat xformColorFormat = is_rgba(dstInfo.colorType()) ?
+                SkColorSpaceXform::kRGBA_8888_ColorFormat :
+                SkColorSpaceXform::kBGRA_8888_ColorFormat;
+        SkAlphaType xformAlphaType = select_xform_alpha(dstInfo.alphaType(),
                                                         this->getInfo().alphaType());
-        fColorXform->apply(colorTable, colorTable, numColors, xformColorType, xformAlphaType);
+        fColorXform->apply(colorTable, colorTable, numColors, xformColorFormat, xformAlphaType);
     }
 
     // Pad the color table with the last color in the table (or black) in the case that
     // invalid pixel indices exceed the number of colors in the table.
     const int maxColors = 1 << fBitDepth;
     if (numColors < maxColors) {
         SkPMColor lastColor = numColors > 0 ? colorTable[numColors - 1] : SK_ColorBLACK;
         sk_memset32(colorTable + numColors, lastColor, maxColors - numColors);
     }
 
@@ skipping 206 matching lines @@
             fStorage.reset(SkAlign4(fSrcRowBytes) + colorXformBytes);
             fSwizzlerSrcRow = fStorage.get();
             fColorXformSrcRow = SkTAddOffset<uint32_t>(fSwizzlerSrcRow, SkAlign4(fSrcRowBytes));
             break;
         }
     }
 }
 
 void SkPngCodec::applyXformRow(void* dst, const void* src, SkColorType colorType,
                                SkAlphaType alphaType, int width) {
+    SkColorSpaceXform::ColorFormat colorFormat = select_xform_format(colorType);

[msarett, 2016/09/14 20:20:35]

Leon, ideally your PNG change can land first?  I think this will refactor nicer
under your design.

[scroggo, 2016/09/14 20:35:01]

That depends. How much of a hurry are you to get this in?

I saw an error on the bots that I have figured out how to repro locally, but I'm
still investigating. (It happens in a webp image, which should not be affected
by my changes...)

Once that's fixed, I still need to update Google3, unless we can work around it.
Given the lack of progress there (taviso@ and clay@ have not been responsive) it
might be worth trying to get an exception for using our own copy of the library.
It won't get us off the hook for updating it, but it can give us some more time
to do so.

[msarett, 2016/09/14 21:09:43]

I'll probably want to write some stuff based on this, but I won't rush it until
I have a queue.
IMHO if you're blocked by waiting on code reviews, we might as well reland the
special Skia copy.  When someone complains it might be a good way to ping the
review.

     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);
+            fColorXform->apply(dst, (const uint32_t*) src, width, colorFormat, alphaType);
             break;
         case kSwizzleColor_XformMode:
             fSwizzler->swizzle(fColorXformSrcRow, (const uint8_t*) src);
-            fColorXform->apply(dst, fColorXformSrcRow, width, colorType, alphaType);
+            fColorXform->apply(dst, fColorXformSrcRow, width, colorFormat, 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)
@@ skipping 15 matching lines @@
     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;
         }
 
-        SkAlphaType xformAlphaType = select_alpha_xform(dstInfo.alphaType(),
+        SkAlphaType xformAlphaType = select_xform_alpha(dstInfo.alphaType(),
                                                         this->getInfo().alphaType());
         int width = fSwizzler ? fSwizzler->swizzleWidth() : dstInfo.width();
 
         for (; y < count; y++) {
             png_read_row(fPng_ptr, fSwizzlerSrcRow, nullptr);
             this->applyXformRow(dst, fSwizzlerSrcRow, dstInfo.colorType(), xformAlphaType, width);
             dst = SkTAddOffset<void>(dst, rowBytes);
         }
 
         return y;
@@ skipping 65 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);
             }
         }
 
-        SkAlphaType xformAlphaType = select_alpha_xform(dstInfo.alphaType(),
+        SkAlphaType xformAlphaType = select_xform_alpha(dstInfo.alphaType(),
                                                         this->getInfo().alphaType());
         int width = fSwizzler ? fSwizzler->swizzleWidth() : dstInfo.width();
         srcRow = storage.get();
         for (int y = 0; y < count; y++) {
             this->applyXformRow(dst, srcRow, dstInfo.colorType(), xformAlphaType, width);
             srcRow = SkTAddOffset<uint8_t>(srcRow, fSrcRowBytes);
             dst = SkTAddOffset<void>(dst, rowBytes);
         }
 
         return count;
@@ skipping 370 matching lines @@
         *rowsDecoded = count;
         return kIncompleteInput;
     }
 
     return kSuccess;
 }
 
 uint64_t SkPngCodec::onGetFillValue(const SkImageInfo& dstInfo) const {
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
     if (colorPtr) {
-        SkAlphaType alphaType = select_alpha_xform(dstInfo.alphaType(),
+        SkAlphaType alphaType = select_xform_alpha(dstInfo.alphaType(),
                                                    this->getInfo().alphaType());
         return get_color_table_fill_value(dstInfo.colorType(), alphaType, colorPtr, 0,
                                           fColorXform.get());
     }
     return INHERITED::onGetFillValue(dstInfo);
 }
 
 SkCodec* SkPngCodec::NewFromStream(SkStream* stream, SkPngChunkReader* chunkReader) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
 
     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;
 }