Let SkWebpCodec decode to 565

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 "SkWebpCodec.h"
 #include "SkTemplates.h"
 
@@ skipping 64 matching lines @@
 SkCodec* SkWebpCodec::NewFromStream(SkStream* stream) {
     SkAutoTDelete<SkStream> streamDeleter(stream);
     SkImageInfo info;
     if (webp_parse_header(stream, &info)) {
         return SkNEW_ARGS(SkWebpCodec, (info, streamDeleter.detach()));
     }
     return NULL;
 }
 
 static bool conversion_possible(const SkImageInfo& dst, const SkImageInfo& src) {
+    if (dst.profileType() != src.profileType()) {
+        return false;
+    }
     switch (dst.colorType()) {
         // Both byte orders are supported.
         case kBGRA_8888_SkColorType:
         case kRGBA_8888_SkColorType:
             break;
+        case kRGB_565_SkColorType:
+            if (src.alphaType() == kOpaque_SkAlphaType
+                && dst.alphaType() == kOpaque_SkAlphaType)
+            {

[msarett, 2015/08/06 19:30:03]

nit: I think the bracket should go on the previous line?

[scroggo, 2015/08/06 20:42:44]

Maybe? In general the { does not get its own line, but we do not have hard and
fast rules about what to do when line breaking a conditional. If that all fit on
one line, I would have said:

if (condition) {
  // code

With it on two lines, I could indent the following line 8 spaces:

if (long condition...
        && other condition) {
    // code

Or I can line up with the "(" -

if (long condition...
    && other condtion) {
    // code...

In that last version, the code lines up with the second part of the condition,
so I moved the brace to its own line. IMO that is more readable than the other
options.

+                return true;
+            }
         default:
             return false;
     }
-    if (dst.profileType() != src.profileType()) {
-        return false;
-    }
     if (dst.alphaType() == src.alphaType()) {
         return true;
     }
     return kPremul_SkAlphaType == dst.alphaType() &&
             kUnpremul_SkAlphaType == src.alphaType();
 }
 
 SkISize SkWebpCodec::onGetScaledDimensions(float desiredScale) const {
     SkISize dim = this->getInfo().dimensions();
     // SkCodec treats zero dimensional images as errors, so the minimum size
     // that we will recommend is 1x1.
     dim.fWidth = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fWidth));
     dim.fHeight = SkTMax(1, SkScalarRoundToInt(desiredScale * dim.fHeight));
     return dim;
 }
 
 static WEBP_CSP_MODE webp_decode_mode(SkColorType ct, bool premultiply) {
     switch (ct) {
         case kBGRA_8888_SkColorType:
             return premultiply ? MODE_bgrA : MODE_BGRA;
         case kRGBA_8888_SkColorType:
             return premultiply ? MODE_rgbA : MODE_RGBA;
+        case kRGB_565_SkColorType:
+            return MODE_RGB_565;
         default:
             return MODE_LAST;
     }
 }
 
 // The WebP decoding API allows us to incrementally pass chunks of bytes as we receive them to the
 // decoder with WebPIAppend. In order to do so, we need to read chunks from the SkStream. This size
 // is arbitrary.
 static const size_t BUFFER_SIZE = 4096;
 
@@ skipping 117 matching lines @@
                 // Break out of the switch statement. Continue the loop.
                 break;
             default:
                 return kInvalidInput;
         }
     }
 }
 
 SkWebpCodec::SkWebpCodec(const SkImageInfo& info, SkStream* stream)
     : INHERITED(info, stream) {}