Modify SkPngCodec to recognize 565 images from the sBIT chunk

include/codec/SkEncodedInfo.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkEncodedInfo_DEFINED
 #define SkEncodedInfo_DEFINED
 
@@ skipping 47 matching lines @@
         kYUVA_Color,
 
         // JPEG
         // Photoshop actually writes inverted CMYK data into JPEGs, where zero
         // represents 100% ink coverage.  For this reason, we treat CMYK JPEGs
         // as having inverted CMYK.  libjpeg-turbo warns that this may break
         // other applications, but the CMYK JPEGs we see on the web expect to
         // be treated as inverted CMYK.
         kInvertedCMYK_Color,
         kYCCK_Color,
+
+        // PNG
+        // 565 images may be encoded to PNG by specifying the number of
+        // significant bits for each channel.  This is a strange 565
+        // representation because the image is still encoded with 8 bits per
+        // component.
+        k565_Color,
     };
 
     static SkEncodedInfo Make(Color color, Alpha alpha, int bitsPerComponent) {
         SkASSERT(1 == bitsPerComponent ||
                  2 == bitsPerComponent ||
                  4 == bitsPerComponent ||
                  8 == bitsPerComponent ||
                  16 == bitsPerComponent);
 
         switch (color) {
@@ skipping 20 matching lines @@
                 break;
             case kRGBA_Color:
                 SkASSERT(kOpaque_Alpha != alpha);
                 SkASSERT(bitsPerComponent >= 8);
                 break;
             case kBGRA_Color:
             case kYUVA_Color:
                 SkASSERT(kOpaque_Alpha != alpha);
                 SkASSERT(8 == bitsPerComponent);
                 break;
-            default:
-                SkASSERT(false);
+            case k565_Color:
+                SkASSERT(kOpaque_Alpha == alpha);
                 break;
         }
 
         return SkEncodedInfo(color, alpha, bitsPerComponent);
     }
 
     /*
      * Returns an SkImageInfo with Skia color and alpha types that are the
      * closest possible match to the encoded info.
      */
@@ skipping 21 matching lines @@
             case kYCCK_Color:
                 SkASSERT(kOpaque_Alpha == fAlpha);
                 return SkImageInfo::Make(width, height, kN32_SkColorType,
                                          kOpaque_SkAlphaType, colorSpace);
             case kRGBA_Color:
             case kBGRA_Color:
             case kYUVA_Color:
                 SkASSERT(kOpaque_Alpha != fAlpha);
                 return SkImageInfo::Make(width, height, kN32_SkColorType,
                                          kUnpremul_SkAlphaType, std::move(colorSpace));
+            case k565_Color:
+                SkASSERT(kOpaque_Alpha == fAlpha);
+                return SkImageInfo::Make(width, height, kRGB_565_SkColorType,
+                                         kOpaque_SkAlphaType, std::move(colorSpace));
             default:
                 SkASSERT(false);
                 return SkImageInfo::MakeUnknown();
         }
     }
 
     Color color() const { return fColor; }
     Alpha alpha() const { return fAlpha; }
     uint8_t bitsPerComponent() const { return fBitsPerComponent; }
 
     uint8_t bitsPerPixel() const {
         switch (fColor) {
             case kGray_Color:
                 return fBitsPerComponent;
             case kGrayAlpha_Color:
                 return 2 * fBitsPerComponent;
             case kPalette_Color:
                 return fBitsPerComponent;
             case kRGB_Color:
             case kBGR_Color:
             case kYUV_Color:
+            case k565_Color:

[reed1, 2016/08/17 13:13:06]

What is the interpretation of bytsPerPixel() in this class? decompressed size?

[msarett, 2016/08/17 13:17:35]

Encoded size.

In this case, even though we recognize that the image is 565, the encoded bits
per pixel are 3*8.  Because the png is encoded with 8-bit channels.

                 return 3 * fBitsPerComponent;
             case kRGBA_Color:
             case kBGRA_Color:
             case kBGRX_Color:
             case kYUVA_Color:
             case kInvertedCMYK_Color:
             case kYCCK_Color:
                 return 4 * fBitsPerComponent;
             default:
                 SkASSERT(false);
                 return 0;
         }
     }
 
 private:
 
     SkEncodedInfo(Color color, Alpha alpha, uint8_t bitsPerComponent)
         : fColor(color)
         , fAlpha(alpha)
         , fBitsPerComponent(bitsPerComponent)
     {}
 
     Color   fColor;
     Alpha   fAlpha;
     uint8_t fBitsPerComponent;
 };
 
 #endif