Support more swizzles to 565 in SkCodec

src/codec/SkCodec_libico.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 "SkBmpCodec.h"
 #include "SkCodec_libico.h"
 #include "SkCodec_libpng.h"
@@ skipping 158 matching lines @@
     for (int32_t i = 0; i < codecs->count(); i++) {
         SkImageInfo info = codecs->operator[](i)->getInfo();
         uint32_t size = info.width() * info.height();
         if (size > maxSize) {
             maxSize = size;
             maxIndex = i;
         }
     }
     SkImageInfo info = codecs->operator[](maxIndex)->getInfo();
 
+    // ICOs contain an alpha mask after the image which means we cannot
+    // guarantee that an image is opaque, even if the sub-codec thinks it
+    // is.
+    // FIXME (msarett): The BMP decoder depends on the alpha type in order
+    // to decode correctly, otherwise it could report kUnpremul and we would
+    // not have to correct it here. Is there a better way?
+    // FIXME (msarett): This is only true for BMP in ICO - could a PNG in ICO
+    // be opaque? Is it okay that we missed out on the opportunity to mark
+    // such an image as opaque?
+    info = info.makeAlphaType(kUnpremul_SkAlphaType);
+
     // Note that stream is owned by the embedded codec, the ico does not need
     // direct access to the stream.
     return SkNEW_ARGS(SkIcoCodec, (info, codecs.detach()));
 }
 
 /*
  * Creates an instance of the decoder
  * Called only by NewFromStream
  */
 SkIcoCodec::SkIcoCodec(const SkImageInfo& info,
@@ skipping 37 matching lines @@
  * Initiates the Ico decode
  */
 SkCodec::Result SkIcoCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options& opts, SkPMColor* ct,
                                         int* ptr) {
     if (opts.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
+
+    if (!valid_alpha(dstInfo.alphaType(), this->getInfo().alphaType())) {
+        return kInvalidConversion;
+    }
+
     // We return invalid scale if there is no candidate image with matching
     // dimensions.
     Result result = kInvalidScale;
     for (int32_t i = 0; i < fEmbeddedCodecs->count(); i++) {
+        SkCodec* embeddedCodec = fEmbeddedCodecs->operator[](i);
         // If the dimensions match, try to decode
-        if (dstInfo.dimensions() ==
-                fEmbeddedCodecs->operator[](i)->getInfo().dimensions()) {
+        if (dstInfo.dimensions() == embeddedCodec->getInfo().dimensions()) {
 
             // Perform the decode
-            result = fEmbeddedCodecs->operator[](i)->getPixels(dstInfo,
-                    dst, dstRowBytes, &opts, ct, ptr);
+            // FIXME: (msarett): ICO is considered non-opaque, even if the embedded BMP
+            // incorrectly claims it has no alpha.
+            SkImageInfo info = dstInfo.makeAlphaType(embeddedCodec->getInfo().alphaType());
+            result = embeddedCodec->getPixels(info, dst, dstRowBytes, &opts, ct, ptr);
 
             // On a fatal error, keep trying to find an image to decode
             if (kInvalidConversion == result || kInvalidInput == result ||
                     kInvalidScale == result) {
                 SkCodecPrintf("Warning: Attempt to decode candidate ico failed.\n");
                 continue;
             }
 
             // On success or partial success, return the result
             return result;
         }
     }
 
     SkCodecPrintf("Error: No matching candidate image in ico.\n");
     return result;
 }