Add SkEncodedInfo to report properties of encoded image data

src/codec/SkWebpCodec.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 "SkWebpCodec.h"
 #include "SkTemplates.h"
@@ skipping 13 matching lines @@
     // WEBP starts with the following:
     // RIFFXXXXWEBPVP
     // Where XXXX is unspecified.
     const char* bytes = static_cast<const char*>(buf);
     return bytesRead >= 14 && !memcmp(bytes, "RIFF", 4) && !memcmp(&bytes[8], "WEBPVP", 6);
 }
 
 // Parse headers of RIFF container, and check for valid Webp (VP8) content.
 // NOTE: This calls peek instead of read, since onGetPixels will need these
 // bytes again.
-static bool webp_parse_header(SkStream* stream, SkImageInfo* info) {
+static bool webp_parse_header(SkStream* stream, SkEncodedInfo* info) {
     unsigned char buffer[WEBP_VP8_HEADER_SIZE];
     SkASSERT(WEBP_VP8_HEADER_SIZE <= SkCodec::MinBufferedBytesNeeded());
 
     const size_t bytesPeeked = stream->peek(buffer, WEBP_VP8_HEADER_SIZE);
     if (bytesPeeked != WEBP_VP8_HEADER_SIZE) {
         // Use read + rewind as a backup
         if (stream->read(buffer, WEBP_VP8_HEADER_SIZE) != WEBP_VP8_HEADER_SIZE
             || !stream->rewind())
         return false;
     }
@@ skipping 10 matching lines @@
         if (!sk_64_isS32(size)) {
             return false;
         }
         // now check that if we are 4-bytes per pixel, we also don't overflow
         if (sk_64_asS32(size) > (0x7FFFFFFF >> 2)) {
             return false;
         }
     }
 
     if (info) {
-        // FIXME: Is N32 the right type?
-        // Is unpremul the right type? Clients of SkCodec may assume it's the
-        // best type, when Skia currently cannot draw unpremul (and raster is faster
-        // with premul).
-        *info = SkImageInfo::Make(features.width, features.height, kN32_SkColorType,
-                                  SkToBool(features.has_alpha) ? kUnpremul_SkAlphaType
-                                                              : kOpaque_SkAlphaType);
+        SkEncodedInfo::Color color;
+        SkEncodedInfo::Alpha alpha;
+        switch (features.format) {
+            case 0:
+                // This indicates a "mixed" format.  We would see this for
+                // animated webps or for webps encoded in multiple fragments.
+                // I believe that this is a rare case.
+                // We could also guess kYUV here, but I think it makes more
+                // sense to guess kBGRA which is likely closer to the final
+                // output.  Otherwise, we might end up converting
+                // BGRA->YUVA->BGRA.
+                color = SkEncodedInfo::kBGRA_Color;
+                alpha = SkEncodedInfo::kUnpremul_Alpha;
+                break;
+            case 1:
+                // This is the lossy format (YUV).
+                color = SkToBool(features.has_alpha) ? SkEncodedInfo::kYUVA_Color :

[scroggo, 2016/03/24 20:51:04]

nit: I would find this a little clearer as

if (has_alpha) {
  color = 
  alpha = 
} else {
  color = 
  alpha = 
}

[msarett, 2016/03/24 22:42:07]

Done.

+                                SkEncodedInfo::kYUV_Color;
+                alpha = SkToBool(features.has_alpha) ? SkEncodedInfo::kUnpremul_Alpha :
+                                SkEncodedInfo::kOpaque_Alpha;
+                break;
+            case 2:
+                // This is the lossless format (BGRA).
+                // FIXME: Should we check the has_alpha flag here?  It looks

[msarett, 2016/03/24 16:21:40]

Forgot to mention that I emailed webp-discuss about this.  AFAICT the spec is
unclear.

+                //        like the image is encoded with an alpha channel
+                //        regardless of whether or not the alpha flag is set.
+                color = SkEncodedInfo::kBGRA_Color;
+                alpha = SkEncodedInfo::kUnpremul_Alpha;
+                break;
+            default:
+                return false;
+        }
+
+        *info = SkEncodedInfo::Make(features.width, features.height, color, alpha, 8);
     }
     return true;
 }
 
 SkCodec* SkWebpCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
-    SkImageInfo info;
+    SkEncodedInfo info;
     if (webp_parse_header(stream, &info)) {
         return new SkWebpCodec(info, streamDeleter.release());
     }
     return nullptr;
 }
 
 // This version is slightly different from SkCodecPriv's version of conversion_possible. It
 // supports both byte orders for 8888.
 static bool webp_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) {
     if (dst.profileType() != src.profileType()) {
@@ skipping 155 matching lines @@
                 return kSuccess;
             case VP8_STATUS_SUSPENDED:
                 // Break out of the switch statement. Continue the loop.
                 break;
             default:
                 return kInvalidInput;
         }
     }
 }
 
-SkWebpCodec::SkWebpCodec(const SkImageInfo& info, SkStream* stream)
+SkWebpCodec::SkWebpCodec(const SkEncodedInfo& info, SkStream* stream)
     : INHERITED(info, stream) {}