Use SkEncodedInfo in place of SkSwizzler::SrcConfig

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 421 matching lines @@
     return true;
 }
 
 SkPngCodec::SkPngCodec(int width, int height, const SkEncodedInfo& info, SkStream* stream,
                        SkPngChunkReader* chunkReader, png_structp png_ptr, png_infop info_ptr,
                        int bitDepth, int numberPasses, sk_sp<SkColorSpace> colorSpace)
     : INHERITED(width, height, info, stream, colorSpace)
     , fPngChunkReader(SkSafeRef(chunkReader))
     , fPng_ptr(png_ptr)
     , fInfo_ptr(info_ptr)
-    , fSrcConfig(SkSwizzler::kUnknown)
     , fNumberPasses(numberPasses)
     , fBitDepth(bitDepth)
 {}
 
 SkPngCodec::~SkPngCodec() {
     this->destroyReadStruct();
 }
 
 void SkPngCodec::destroyReadStruct() {
     if (fPng_ptr) {
@@ skipping 14 matching lines @@
                                                SkPMColor ctable[],
                                                int* ctableCount) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
     png_read_update_info(fPng_ptr, fInfo_ptr);
 
-    // suggestedColorType was determined in read_header() based on the encodedColorType
-    const SkColorType suggestedColorType = this->getInfo().colorType();
-
-    switch (suggestedColorType) {
-        case kIndex_8_SkColorType:
-            //decode palette to Skia format
-            fSrcConfig = SkSwizzler::kIndex;
-            if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(),
-                    ctableCount)) {
-                return kInvalidInput;
-            }
-            break;
-        case kGray_8_SkColorType:
-            fSrcConfig = SkSwizzler::kGray;
-            break;
-        case kN32_SkColorType: {
-            const uint8_t encodedColorType = png_get_color_type(fPng_ptr, fInfo_ptr);
-            if (PNG_COLOR_TYPE_GRAY_ALPHA == encodedColorType ||
-                    PNG_COLOR_TYPE_GRAY == encodedColorType) {
-                // If encodedColorType is GRAY, there must be a transparent chunk.
-                // Otherwise, suggestedColorType would be kGray.  We have already
-                // instructed libpng to convert the transparent chunk to alpha,
-                // so we can treat both GRAY and GRAY_ALPHA as kGrayAlpha.
-                SkASSERT(encodedColorType == PNG_COLOR_TYPE_GRAY_ALPHA ||
-                        png_get_valid(fPng_ptr, fInfo_ptr, PNG_INFO_tRNS));
-
-                fSrcConfig = SkSwizzler::kGrayAlpha;
-            } else {
-                if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
-                    fSrcConfig = SkSwizzler::kRGB;
-                } else {
-                    fSrcConfig = SkSwizzler::kRGBA;
-                }
-            }
-            break;
+    if (SkEncodedInfo::kPalette_Color == this->getEncodedInfo().color()) {
+        if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(), ctableCount)) {
+            return kInvalidInput;
         }
-        default:
-            // We will always recommend one of the above colorTypes.
-            SkASSERT(false);
     }
 
     // Copy the color table to the client if they request kIndex8 mode
     copy_color_table(requestedInfo, fColorTable, ctable, ctableCount);
 
     // Create the swizzler.  SkPngCodec retains ownership of the color table.
     const SkPMColor* colors = get_color_ptr(fColorTable.get());
-    fSwizzler.reset(SkSwizzler::CreateSwizzler(fSrcConfig, colors, requestedInfo, options));
+    fSwizzler.reset(SkSwizzler::CreateSwizzler(this->getEncodedInfo(), colors, requestedInfo,
+            options));
     SkASSERT(fSwizzler);
 
     return kSuccess;
 }
 
 
 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();
 
     png_structp png_ptr;
     png_infop info_ptr;
     if (!read_header(this->stream(), fPngChunkReader.get(), &png_ptr, &info_ptr,
                      nullptr, nullptr, nullptr, nullptr, nullptr)) {
         return false;
     }
 
     fPng_ptr = png_ptr;
     fInfo_ptr = info_ptr;
     return true;
 }
 
+static int bytes_per_pixel(int bitsPerPixel) {
+    // Note that we will have to change this implementation if we start
+    // supporting outputs from libpng that are less than 8-bits per component.
+    return bitsPerPixel / 8;
+}
+
 SkCodec::Result SkPngCodec::onGetPixels(const SkImageInfo& requestedInfo, void* dst,
                                         size_t dstRowBytes, const Options& options,
                                         SkPMColor ctable[], int* ctableCount,
                                         int* rowsDecoded) {
     if (!conversion_possible(requestedInfo, this->getInfo())) {
         return kInvalidConversion;
     }
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
 
     // Note that ctable and ctableCount may be modified if there is a color table
     const Result result = this->initializeSwizzler(requestedInfo, options, ctable, ctableCount);
     if (result != kSuccess) {
         return result;
     }
 
     const int width = requestedInfo.width();
     const int height = requestedInfo.height();
-    const int bpp = SkSwizzler::BytesPerPixel(fSrcConfig);
+    const int bpp = bytes_per_pixel(this->getEncodedInfo().bitsPerPixel());
     const size_t srcRowBytes = width * bpp;
 
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     int row = 0;
     // This must be declared above the call to setjmp to avoid memory leaks on incomplete images.
     SkAutoTMalloc<uint8_t> storage;
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         // Assume that any error that occurs while reading rows is caused by an incomplete input.
         if (fNumberPasses > 1) {
@@ skipping 76 matching lines @@
         if (!conversion_possible(dstInfo, this->getInfo())) {
             return kInvalidConversion;
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
                                                        ctableCount);
         if (result != kSuccess) {
             return result;
         }
 
-        fStorage.reset(this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig()));
+        fStorage.reset(this->getInfo().width() *
+                (bytes_per_pixel(this->getEncodedInfo().bitsPerPixel())));
         fSrcRow = fStorage.get();
 
         return kSuccess;
     }
 
     int onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // Assume that an error in libpng indicates an incomplete input.
         int row = 0;
         if (setjmp(png_jmpbuf(this->png_ptr()))) {
             SkCodecPrintf("setjmp long jump!\n");
@@ skipping 51 matching lines @@
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
                                                        ctableCount);
         if (result != kSuccess) {
             return result;
         }
 
         fHeight = dstInfo.height();
         // FIXME: This need not be called on a second call to onStartScanlineDecode.
-        fSrcRowBytes = this->getInfo().width() * SkSwizzler::BytesPerPixel(this->srcConfig());
+        fSrcRowBytes = this->getInfo().width() *
+                (bytes_per_pixel(this->getEncodedInfo().bitsPerPixel()));
         fGarbageRow.reset(fSrcRowBytes);
         fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
         fCanSkipRewind = true;
 
         return SkCodec::kSuccess;
     }
 
     int onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
         // rewind stream if have previously called onGetScanlines,
         // since we need entire progressive image to get scanlines
@@ skipping 101 matching lines @@
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(width, height, imageInfo, streamDeleter.release(),
                                         chunkReader, png_ptr, info_ptr, bitDepth, colorSpace);
     }
 
     return new SkPngInterlacedScanlineDecoder(width, height, imageInfo, streamDeleter.release(),
                                               chunkReader, png_ptr, info_ptr, bitDepth,
                                               numberPasses, colorSpace);
 }