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 249 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 200 matching lines @@
         case kSwizzleColor_XformMode: {
             const size_t colorXformBytes = dstInfo.width() * sizeof(uint32_t);
             fStorage.reset(colorXformBytes);
             fColorXformSrcRow = (uint32_t*) fStorage.get();
             break;
         }
     }
 }
 
 void SkPngCodec::applyXformRow(void* dst, const void* src) {
-    const SkColorType colorType = this->dstInfo().colorType();
     switch (fXformMode) {
         case kSwizzleOnly_XformMode:
             fSwizzler->swizzle(dst, (const uint8_t*) src);
             break;
         case kColorOnly_XformMode:
-            fColorXform->apply(dst, (const uint32_t*) src, fXformWidth, colorType, fXformAlphaType);
+            fColorXform->apply(dst, (const uint32_t*) src, fXformWidth, fXformColorFormat,
+                               fXformAlphaType);
             break;
         case kSwizzleColor_XformMode:
             fSwizzler->swizzle(fColorXformSrcRow, (const uint8_t*) src);
-            fColorXform->apply(dst, fColorXformSrcRow, fXformWidth, colorType, fXformAlphaType);
+            fColorXform->apply(dst, fColorXformSrcRow, fXformWidth, fXformColorFormat,
+                               fXformAlphaType);
             break;
     }
 }
 
 class SkPngNormalDecoder : public SkPngCodec {
 public:
     SkPngNormalDecoder(const SkEncodedInfo& info, const SkImageInfo& imageInfo, SkStream* stream,
             SkPngChunkReader* reader, png_structp png_ptr, png_infop info_ptr, int bitDepth)
         : INHERITED(info, imageInfo, stream, reader, png_ptr, info_ptr, bitDepth)
         , fLinesDecoded(0)
@@ skipping 614 matching lines @@
         }
     }
 
     // Copy the color table to the client if they request kIndex8 mode.
     copy_color_table(dstInfo, fColorTable, ctable, ctableCount);
 
     this->initializeSwizzler(dstInfo, options);
     return true;
 }
 
-void SkPngCodec::initializeXformAlphaAndWidth() {
-    fXformAlphaType = select_alpha_xform(this->dstInfo().alphaType(), this->getInfo().alphaType());
-    fXformWidth = this->swizzler() ? this->swizzler()->swizzleWidth() : this->dstInfo().width();
+void SkPngCodec::initializeXformParams() {
+    switch (fXformMode) {
+        case kColorOnly_XformMode:
+            fXformColorFormat = select_xform_format(this->dstInfo().colorType());
+            fXformAlphaType = select_xform_alpha(this->dstInfo().alphaType(),
+                                                 this->getInfo().alphaType());
+            fXformWidth = this->dstInfo().width();
+            break;
+        case kSwizzleColor_XformMode:
+            fXformColorFormat = select_xform_format(this->dstInfo().colorType());
+            fXformAlphaType = select_xform_alpha(this->dstInfo().alphaType(),
+                                                 this->getInfo().alphaType());
+            fXformWidth = this->swizzler()->swizzleWidth();
+            break;
+        default:
+            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::initializeSwizzler(const SkImageInfo& dstInfo, const Options& options) {
     SkImageInfo swizzlerInfo = dstInfo;
     Options swizzlerOptions = options;
@@ skipping 66 matching lines @@
     if (!this->rereadHeaderIfNecessary()) {
         return kCouldNotRewind;
     }
 #endif
 
     if (options.fSubset) {
         return kUnimplemented;
     }
 
     this->allocateStorage(dstInfo);
-    this->initializeXformAlphaAndWidth();
+    this->initializeXformParams();
     return this->decodeAllRows(dst, rowBytes, rowsDecoded);
 }
 
 SkCodec::Result SkPngCodec::onStartIncrementalDecode(const SkImageInfo& dstInfo,
         void* dst, size_t rowBytes, const SkCodec::Options& options,
         SkPMColor* ctable, int* ctableCount) {
     if (!conversion_possible(dstInfo, this->getInfo()) ||
         !this->initializeXforms(dstInfo, options, ctable, ctableCount))
     {
         return kInvalidConversion;
@@ skipping 14 matching lines @@
     } else {
         firstRow = 0;
         lastRow = dstInfo.height() - 1;
     }
     this->setRange(firstRow, lastRow, dst, rowBytes);
     return kSuccess;
 }
 
 SkCodec::Result SkPngCodec::onIncrementalDecode(int* rowsDecoded) {
     // FIXME: Only necessary on the first call.
-    this->initializeXformAlphaAndWidth();
+    this->initializeXformParams();
 
     return this->decode(rowsDecoded);
 }
 
 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 = nullptr;
     if (read_header(streamDeleter.get(), chunkReader, &outCodec, nullptr, nullptr)) {
         // Codec has taken ownership of the stream.
         SkASSERT(outCodec);
         streamDeleter.release();
         return outCodec;
     }
 
     return nullptr;
 }