Add SkEncodedInfo to report properties of encoded image data

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 254 matching lines @@
 //
 // @param stream Input data. Will be read to get enough information to properly
 //      setup the codec.
 // @param chunkReader SkPngChunkReader, for reading unknown chunks. May be NULL.
 //      If not NULL, png_ptr will hold an *unowned* pointer to it. The caller is
 //      expected to continue to own it for the lifetime of the png_ptr.
 // @param png_ptrp Optional output variable. If non-NULL, will be set to a new
 //      png_structp on success.
 // @param info_ptrp Optional output variable. If non-NULL, will be set to a new
 //      png_infop on success;
-// @param imageInfo Optional output variable. If non-NULL, will be set to
+// @param info Optional output variable. If non-NULL, will be set to
 //      reflect the properties of the encoded image on success.
 // @param bitDepthPtr Optional output variable. If non-NULL, will be set to the
 //      bit depth of the encoded image on success.
 // @param numberPassesPtr Optional output variable. If non-NULL, will be set to
 //      the number_passes of the encoded image on success.
 // @return true on success, in which case the caller is responsible for calling
 //      png_destroy_read_struct(png_ptrp, info_ptrp).
 //      If it returns false, the passed in fields (except stream) are unchanged.
 static bool read_header(SkStream* stream, SkPngChunkReader* chunkReader,
                         png_structp* png_ptrp, png_infop* info_ptrp,
-                        SkImageInfo* imageInfo, int* bitDepthPtr, int* numberPassesPtr) {
+                        SkEncodedInfo* info, int* bitDepthPtr, int* numberPassesPtr) {
     // The image is known to be a PNG. Decode enough to know the SkImageInfo.
     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr,
                                                  sk_error_fn, sk_warning_fn);
     if (!png_ptr) {
         return false;
     }
 
     AutoCleanPng autoClean(png_ptr);
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
@@ skipping 37 matching lines @@
     // TODO: Should we handle this in SkSwizzler?  Could this also benefit
     //       RAW decodes?
     if (bitDepth == 16) {
         SkASSERT(PNG_COLOR_TYPE_PALETTE != encodedColorType);
         png_set_strip_16(png_ptr);
     }
 
     // Now determine the default colorType and alphaType and set the required transforms.
     // Often, we depend on SkSwizzler to perform any transforms that we need.  However, we
     // still depend on libpng for many of the rare and PNG-specific cases.
-    SkColorType colorType = kUnknown_SkColorType;
-    SkAlphaType alphaType = kUnknown_SkAlphaType;
+    SkEncodedInfo::Color color;
+    SkEncodedInfo::Alpha alpha;
     switch (encodedColorType) {
         case PNG_COLOR_TYPE_PALETTE:
             // Extract multiple pixels with bit depths of 1, 2, and 4 from a single
             // byte into separate bytes (useful for paletted and grayscale images).
             if (bitDepth < 8) {

[scroggo, 2016/03/23 14:48:50]

I think eventually we'll want to just use the raw bit depth and use the
SkSwizzler. But for now, don't you want to the SkEncodedInfo to report a
bitDepth of 8, since png_set_packing will bump it up to 8?

Similarly, bitDepth may be 16, but we already called strip_16, so the
SkEncodedInfo should say 8, right?

[msarett, 2016/03/24 16:20:44]

Thanks I completely missed this...

Yes, let's report 8 for now, and we'll start saying 1/2/4/8/16 when we can
handle it.

                 // TODO: Should we use SkSwizzler here?
                 png_set_packing(png_ptr);
             }
 
-            colorType = kIndex_8_SkColorType;
-            // Set the alpha type depending on if a transparency chunk exists.
-            alphaType = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) ?
-                    kUnpremul_SkAlphaType : kOpaque_SkAlphaType;
+            color = SkEncodedInfo::kPalette_Color;
+            // Set the alpha depending on if a transparency chunk exists.
+            alpha = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS) ?
+                    SkEncodedInfo::kUnpremul_Alpha : SkEncodedInfo::kOpaque_Alpha;
             break;
         case PNG_COLOR_TYPE_RGB:
             if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
                 // Convert to RGBA if transparency chunk exists.
                 png_set_tRNS_to_alpha(png_ptr);
-                alphaType = kUnpremul_SkAlphaType;
+                color = SkEncodedInfo::kRGBA_Color;
+                alpha = SkEncodedInfo::kBinary_Alpha;
             } else {
-                alphaType = kOpaque_SkAlphaType;
+                color = SkEncodedInfo::kRGB_Color;
+                alpha = SkEncodedInfo::kOpaque_Alpha;
             }
-            colorType = kN32_SkColorType;
             break;
         case PNG_COLOR_TYPE_GRAY:
             // Expand grayscale images to the full 8 bits from 1, 2, or 4 bits/pixel.
             if (bitDepth < 8) {
                 // TODO: Should we use SkSwizzler here?
                 png_set_expand_gray_1_2_4_to_8(png_ptr);
             }
 
             if (png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS)) {
                 png_set_tRNS_to_alpha(png_ptr);
-
-                // We will recommend kN32 here since we do not support kGray
-                // with alpha.
-                colorType = kN32_SkColorType;
-                alphaType = kUnpremul_SkAlphaType;
+                color = SkEncodedInfo::kGrayAlpha_Color;
+                alpha = SkEncodedInfo::kBinary_Alpha;
             } else {
-                colorType = kGray_8_SkColorType;
-                alphaType = kOpaque_SkAlphaType;
+                color = SkEncodedInfo::kGray_Color;
+                alpha = SkEncodedInfo::kOpaque_Alpha;
             }
             break;
         case PNG_COLOR_TYPE_GRAY_ALPHA:
-            // We will recommend kN32 here since we do not support anything
-            // similar to GRAY_ALPHA.
-            colorType = kN32_SkColorType;
-            alphaType = kUnpremul_SkAlphaType;
+            color = SkEncodedInfo::kGrayAlpha_Color;
+            alpha = SkEncodedInfo::kUnpremul_Alpha;
             break;
         case PNG_COLOR_TYPE_RGBA:
-            colorType = kN32_SkColorType;
-            alphaType = kUnpremul_SkAlphaType;
+            color = SkEncodedInfo::kRGBA_Color;
+            alpha = SkEncodedInfo::kUnpremul_Alpha;
             break;
         default:
             // All the color types have been covered above.
             SkASSERT(false);
+            color = SkEncodedInfo::kRGBA_Color;
+            alpha = SkEncodedInfo::kUnpremul_Alpha;
     }
 
     int numberPasses = png_set_interlace_handling(png_ptr);
     if (numberPassesPtr) {
         *numberPassesPtr = numberPasses;
     }
 
-    SkColorProfileType profileType = kLinear_SkColorProfileType;
-    if (png_get_valid(png_ptr, info_ptr, PNG_INFO_sRGB)) {
-        profileType = kSRGB_SkColorProfileType;
-    }
-
-    if (imageInfo) {
-        *imageInfo = SkImageInfo::Make(origWidth, origHeight, colorType, alphaType, profileType);
+    if (info) {
+        *info = SkEncodedInfo::Make(origWidth, origHeight, color, alpha, bitDepth);
     }
     autoClean.release();
     if (png_ptrp) {
         *png_ptrp = png_ptr;
     }
     if (info_ptrp) {
         *info_ptrp = info_ptr;
     }
 
     return true;
 }
 
-SkPngCodec::SkPngCodec(const SkImageInfo& info, SkStream* stream, SkPngChunkReader* chunkReader,
+SkPngCodec::SkPngCodec(const SkEncodedInfo& info, SkStream* stream, SkPngChunkReader* chunkReader,
                        png_structp png_ptr, png_infop info_ptr, int bitDepth, int numberPasses,
                        sk_sp<SkColorSpace> colorSpace)
     : INHERITED(info, stream, colorSpace)
     , fPngChunkReader(SkSafeRef(chunkReader))
     , fPng_ptr(png_ptr)
     , fInfo_ptr(info_ptr)
     , fSrcConfig(SkSwizzler::kUnknown)
     , fNumberPasses(numberPasses)
     , fBitDepth(bitDepth)
 {}
@@ skipping 191 matching lines @@
     const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
     if (colorPtr) {
         return get_color_table_fill_value(colorType, colorPtr, 0);
     }
     return INHERITED::onGetFillValue(colorType);
 }
 
 // Subclass of SkPngCodec which supports scanline decoding
 class SkPngScanlineDecoder : public SkPngCodec {
 public:
-    SkPngScanlineDecoder(const SkImageInfo& srcInfo, SkStream* stream,
+    SkPngScanlineDecoder(const SkEncodedInfo& info, SkStream* stream,
             SkPngChunkReader* chunkReader, png_structp png_ptr, png_infop info_ptr, int bitDepth,
             sk_sp<SkColorSpace> colorSpace)
-        : INHERITED(srcInfo, stream, chunkReader, png_ptr, info_ptr, bitDepth, 1, colorSpace)
+        : INHERITED(info, stream, chunkReader, png_ptr, info_ptr, bitDepth, 1, colorSpace)
         , fSrcRow(nullptr)
     {}
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
         if (!conversion_possible(dstInfo, this->getInfo())) {
             return kInvalidConversion;
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
@@ skipping 42 matching lines @@
 private:
     SkAutoTMalloc<uint8_t>      fStorage;
     uint8_t*                    fSrcRow;
 
     typedef SkPngCodec INHERITED;
 };
 
 
 class SkPngInterlacedScanlineDecoder : public SkPngCodec {
 public:
-    SkPngInterlacedScanlineDecoder(const SkImageInfo& srcInfo, SkStream* stream,
+    SkPngInterlacedScanlineDecoder(const SkEncodedInfo& info, SkStream* stream,
             SkPngChunkReader* chunkReader, png_structp png_ptr, png_infop info_ptr,
             int bitDepth, int numberPasses, sk_sp<SkColorSpace> colorSpace)
-        : INHERITED(srcInfo, stream, chunkReader, png_ptr, info_ptr, bitDepth, numberPasses,
+        : INHERITED(info, stream, chunkReader, png_ptr, info_ptr, bitDepth, numberPasses,
                     colorSpace)
         , fHeight(-1)
         , fCanSkipRewind(false)
     {
         SkASSERT(numberPasses != 1);
     }
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
         if (!conversion_possible(dstInfo, this->getInfo())) {
@@ skipping 102 matching lines @@
     // add another layer.
     bool                        fCanSkipRewind;
 
     typedef SkPngCodec INHERITED;
 };
 
 SkCodec* SkPngCodec::NewFromStream(SkStream* stream, SkPngChunkReader* chunkReader) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
     png_structp png_ptr;
     png_infop info_ptr;
-    SkImageInfo imageInfo;
+    SkEncodedInfo imageInfo;
     int bitDepth;
     int numberPasses;
 
     if (!read_header(stream, chunkReader, &png_ptr, &info_ptr, &imageInfo, &bitDepth,
                      &numberPasses)) {
         return nullptr;
     }
 
     auto colorSpace = read_color_space(png_ptr, info_ptr);
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(imageInfo, streamDeleter.release(), chunkReader,
                                         png_ptr, info_ptr, bitDepth, colorSpace);
     }
 
     return new SkPngInterlacedScanlineDecoder(imageInfo, streamDeleter.release(), chunkReader,
                                               png_ptr, info_ptr, bitDepth, numberPasses,
                                               colorSpace);
 }