Add color xform support to SkWebpCodec

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 "SkColorSpaceXform.h"
 #include "SkWebpCodec.h"
 #include "SkStreamPriv.h"
 #include "SkTemplates.h"
 
 // A WebP decoder on top of (subset of) libwebp
 // For more information on WebP image format, and libwebp library, see:
 //   https://code.google.com/speed/webp/
 //   http://www.webmproject.org/code/#libwebp-webp-image-library
 //   https://chromium.googlesource.com/webm/libwebp
 
@@ skipping 117 matching lines @@
             break;
         default:
             return nullptr;
     }
 
     SkEncodedInfo info = SkEncodedInfo::Make(color, alpha, 8);
     return new SkWebpCodec(features.width, features.height, info, std::move(colorSpace),
                            streamDeleter.release(), demux.release(), std::move(data));
 }
 
-// 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) {
+static bool webp_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src,
+                                     SkColorSpaceXform* colorXform) {
     if (!valid_alpha(dst.alphaType(), src.alphaType())) {
         return false;
     }
 
     switch (dst.colorType()) {
-        // Both byte orders are supported.
+        case kRGBA_F16_SkColorType:
+            return nullptr != colorXform;
         case kBGRA_8888_SkColorType:
         case kRGBA_8888_SkColorType:
             return true;
         case kRGB_565_SkColorType:
-            return src.alphaType() == kOpaque_SkAlphaType;
+            return nullptr == colorXform && src.alphaType() == kOpaque_SkAlphaType;
         default:
             return false;
     }
 }
 
 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));
@@ skipping 33 matching lines @@
     // As stated below, libwebp snaps to even left and top. Make sure top and left are even, so we
     // decode this exact subset.
     // Leave right and bottom unmodified, so we suggest a slightly larger subset than requested.
     desiredSubset->fLeft = (desiredSubset->fLeft >> 1) << 1;
     desiredSubset->fTop = (desiredSubset->fTop >> 1) << 1;
     return true;
 }
 
 SkCodec::Result SkWebpCodec::onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t rowBytes,
                                          const Options& options, SkPMColor*, int*,
-                                         int* rowsDecoded) {
-    if (!webp_conversion_possible(dstInfo, this->getInfo())) {
+                                         int* rowsDecodedPtr) {
+
+    std::unique_ptr<SkColorSpaceXform> colorXform = nullptr;
+    if (needs_color_xform(dstInfo, this->getInfo())) {
+        colorXform = SkColorSpaceXform::New(sk_ref_sp(this->getInfo().colorSpace()),
+                                            sk_ref_sp(dstInfo.colorSpace()));
+    }
+
+    if (!webp_conversion_possible(dstInfo, this->getInfo(), colorXform.get())) {
         return kInvalidConversion;
     }
 
     WebPDecoderConfig config;
     if (0 == WebPInitDecoderConfig(&config)) {
         // ABI mismatch.
         // FIXME: New enum for this?
         return kInvalidInput;
     }
 
@@ skipping 37 matching lines @@
     }
 
     SkISize dstDimensions = dstInfo.dimensions();
     if (bounds.size() != dstDimensions) {
         // Caller is requesting scaling.
         config.options.use_scaling = 1;
         config.options.scaled_width = dstDimensions.width();
         config.options.scaled_height = dstDimensions.height();
     }
 
-    config.output.colorspace = webp_decode_mode(dstInfo.colorType(),
-            dstInfo.alphaType() == kPremul_SkAlphaType);
-    config.output.u.RGBA.rgba = (uint8_t*) dst;
-    config.output.u.RGBA.stride = (int) rowBytes;
-    config.output.u.RGBA.size = dstInfo.getSafeSize(rowBytes);
+    // FIXME (msarett):
+    // Lossless webp is encoded as BGRA.  In that case, it would be more efficient to
+    // to decode BGRA and apply the color xform to a BGRA buffer.

[scroggo, 2016/09/07 20:32:58]

Why don't we today?

[msarett, 2016/09/07 22:27:41]

I haven't implemented BGRA as an input yet :)

+    config.output.colorspace = colorXform ? MODE_RGBA :
+            webp_decode_mode(dstInfo.colorType(), dstInfo.alphaType() == kPremul_SkAlphaType);
     config.output.is_external_memory = 1;
 
+    SkAutoTMalloc<uint32_t> pixels;
+    if (kRGBA_F16_SkColorType == dstInfo.colorType()) {
+        // The best we can do is to decode into an 8888 buffer and then transform the entire
+        // buffer to F16.  libwebp does not support a row-by-row decode.

[scroggo, 2016/09/07 20:32:58]

It seems like this comment mostly applies to the below case, too?

[msarett, 2016/09/07 22:27:41]

Yeah, I'll move it up.  It's just that it's awful in the F16 case because we
need to allocate an extra buffer.

+        pixels.reset(dstDimensions.width() * dstDimensions.height());
+        config.output.u.RGBA.rgba = (uint8_t*) pixels.get();
+        config.output.u.RGBA.stride = (int) dstDimensions.width() * sizeof(uint32_t);
+        config.output.u.RGBA.size = config.output.u.RGBA.stride * dstDimensions.height();
+    } else {
+        config.output.u.RGBA.rgba = (uint8_t*) dst;
+        config.output.u.RGBA.stride = (int) rowBytes;
+        config.output.u.RGBA.size = dstInfo.getSafeSize(rowBytes);
+    }
+
     WebPIterator frame;
     SkAutoTCallVProc<WebPIterator, WebPDemuxReleaseIterator> autoFrame(&frame);
     // If this succeeded in NewFromStream(), it should succeed again here.
     SkAssertResult(WebPDemuxGetFrame(fDemux, 1, &frame));
 
     SkAutoTCallVProc<WebPIDecoder, WebPIDelete> idec(WebPIDecode(nullptr, 0, &config));
     if (!idec) {
         return kInvalidInput;
     }
 
+    int rowsDecoded;
+    SkCodec::Result result;
     switch (WebPIUpdate(idec, frame.fragment.bytes, frame.fragment.size)) {
         case VP8_STATUS_OK:
-            return kSuccess;
-        case VP8_STATUS_SUSPENDED:
-            WebPIDecGetRGB(idec, rowsDecoded, nullptr, nullptr, nullptr);
-            return kIncompleteInput;
+            rowsDecoded = dstInfo.height();
+            result = kSuccess;
+            break;
+        case VP8_STATUS_SUSPENDED: {

[scroggo, 2016/09/07 20:32:58]

Nit: do you need the braces?

[msarett, 2016/09/07 22:27:41]

No, removed.

+            WebPIDecGetRGB(idec, rowsDecodedPtr, nullptr, nullptr, nullptr);
+
+            rowsDecoded = *rowsDecodedPtr;
+            result = kIncompleteInput;
+            break;
+        }
         default:
             return kInvalidInput;
     }
+
+    if (colorXform) {
+        SkAlphaType xformAlphaType = color_xform_alpha_type(dstInfo.alphaType(),
+                                                            this->getInfo().alphaType());
+
+        uint32_t* src = (uint32_t*) config.output.u.RGBA.rgba;
+        size_t srcRowBytes = config.output.u.RGBA.stride;
+        for (int y = 0; y < rowsDecoded; y++) {
+            colorXform->apply(dst, src, dstInfo.width(), dstInfo.colorType(), xformAlphaType);
+            dst = SkTAddOffset<void>(dst, rowBytes);
+            src = SkTAddOffset<uint32_t>(src, srcRowBytes);
+        }
+    }
+
+    return result;
 }
 
 SkWebpCodec::SkWebpCodec(int width, int height, const SkEncodedInfo& info,
                          sk_sp<SkColorSpace> colorSpace, SkStream* stream, WebPDemuxer* demux,
                          sk_sp<SkData> data)
     : INHERITED(width, height, info, stream, std::move(colorSpace))
     , fDemux(demux)
     , fData(std::move(data))
 {}