Add SkEncodedInfo to report properties of encoded image data

src/codec/SkGifCodec.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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
@@ skipping 181 matching lines @@
 
     if (nullptr != codecOut) {
         SkISize size;
         SkIRect frameRect;
         if (!GetDimensions(gif, &size, &frameRect)) {
             gif_error("Invalid gif size.\n");
             return false;
         }
         bool frameIsSubset = (size != frameRect.size());
 
-        // Determine the recommended alpha type.  The transIndex might be valid if it less
+        // Determine the encoded alpha type.  The transIndex might be valid if it less
         // than 256.  We are not certain that the index is valid until we process the color
         // table, since some gifs have color tables with less than 256 colors.  If
         // there might be a valid transparent index, we must indicate that the image has
         // alpha.
-        // In the case where we must support alpha, we have the option to set the
-        // suggested alpha type to kPremul or kUnpremul.  Both are valid since the alpha
-        // component will always be 0xFF or the entire 32-bit pixel will be set to zero.
-        // We prefer kPremul because we support kPremul, and it is more efficient to use
-        // kPremul directly even when kUnpremul is supported.
-        SkAlphaType alphaType = (transIndex < 256) ? kPremul_SkAlphaType : kOpaque_SkAlphaType;
+        // In the case where we must support alpha, we indicate kBinary, since every
+        // pixel will either be fully opaque or fully transparent.
+        SkEncodedInfo::Alpha alpha = (transIndex < 256) ? SkEncodedInfo::kBinary_Alpha :
+                SkEncodedInfo::kOpaque_Alpha;
 
         // Return the codec
-        // kIndex is the most natural color type for gifs, so we set this as
-        // the default.
-        SkImageInfo imageInfo = SkImageInfo::Make(size.width(), size.height(), kIndex_8_SkColorType,
-                alphaType);
-        *codecOut = new SkGifCodec(imageInfo, streamDeleter.release(), gif.release(), transIndex,
+        // Use kPalette since Gifs are encoded with a color table.
+        // Use 8-bits per component, since this is the output we get from giflib.
+        // FIXME: Gifs can actually be encoded with 4-bits per pixel.  Can we support this?
+        SkEncodedInfo info = SkEncodedInfo::Make(size, SkEncodedInfo::kPalette_Color, alpha, 8);
+        *codecOut = new SkGifCodec(info, streamDeleter.release(), gif.release(), transIndex,
                 frameRect, frameIsSubset);
     } else {
         SkASSERT(nullptr != gifOut);
         streamDeleter.release();
         *gifOut = gif.release();
     }
     return true;
 }
 
 /*
  * Assumes IsGif was called and returned true
  * Creates a gif decoder
  * Reads enough of the stream to determine the image format
  */
 SkCodec* SkGifCodec::NewFromStream(SkStream* stream) {
     SkCodec* codec = nullptr;
     if (ReadHeader(stream, &codec, nullptr)) {
         return codec;
     }
     return nullptr;
 }
 
-SkGifCodec::SkGifCodec(const SkImageInfo& srcInfo, SkStream* stream, GifFileType* gif,
+SkGifCodec::SkGifCodec(const SkEncodedInfo& info, SkStream* stream, GifFileType* gif,
         uint32_t transIndex, const SkIRect& frameRect, bool frameIsSubset)
-    : INHERITED(srcInfo, stream)
+    : INHERITED(info, stream)
     , fGif(gif)
     , fSrcBuffer(new uint8_t[this->getInfo().width()])
     , fFrameRect(frameRect)
     // If it is valid, fTransIndex will be used to set fFillIndex.  We don't know if
     // fTransIndex is valid until we process the color table, since fTransIndex may
     // be greater than the size of the color table.
     , fTransIndex(transIndex)
     // Default fFillIndex is 0.  We will overwrite this if fTransIndex is valid, or if
     // there is a valid background color.
     , fFillIndex(0)
@@ skipping 344 matching lines @@
 int SkGifCodec::onOutputScanline(int inputScanline) const {
     if (fGif->Image.Interlace) {
         if (inputScanline < fFrameRect.top() || inputScanline >= fFrameRect.bottom()) {
             return inputScanline;
         }
         return get_output_row_interlaced(inputScanline - fFrameRect.top(), fFrameRect.height()) +
                 fFrameRect.top();
     }
     return inputScanline;
 }