Revert of 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 encoded alpha type.  The transIndex might be valid if it less
+        // Determine the recommended 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 indicate kBinary, since every
-        // pixel will either be fully opaque or fully transparent.
-        SkEncodedInfo::Alpha alpha = (transIndex < 256) ? SkEncodedInfo::kBinary_Alpha :
-                SkEncodedInfo::kOpaque_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;
 
         // Return the codec
-        // 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(SkEncodedInfo::kPalette_Color, alpha, 8);
-        *codecOut = new SkGifCodec(size.width(), size.height(), info, streamDeleter.release(),
-                gif.release(), transIndex, frameRect, frameIsSubset);
+        // 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,
+                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(int width, int height, const SkEncodedInfo& info, SkStream* stream,
-        GifFileType* gif, uint32_t transIndex, const SkIRect& frameRect, bool frameIsSubset)
-    : INHERITED(width, height, info, stream)
+SkGifCodec::SkGifCodec(const SkImageInfo& srcInfo, SkStream* stream, GifFileType* gif,
+        uint32_t transIndex, const SkIRect& frameRect, bool frameIsSubset)
+    : INHERITED(srcInfo, 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;
 }