Revert of 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));
 }
 
-static bool webp_conversion_possible(const SkImageInfo& dst, const SkImageInfo& src,
-                                     SkColorSpaceXform* colorXform) {
+// 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 (!valid_alpha(dst.alphaType(), src.alphaType())) {
         return false;
     }
 
     switch (dst.colorType()) {
-        case kRGBA_F16_SkColorType:
-            return nullptr != colorXform;
+        // Both byte orders are supported.
         case kBGRA_8888_SkColorType:
         case kRGBA_8888_SkColorType:
             return true;
         case kRGB_565_SkColorType:
-            return nullptr == colorXform && src.alphaType() == kOpaque_SkAlphaType;
+            return 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* 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())) {
+                                         int* rowsDecoded) {
+    if (!webp_conversion_possible(dstInfo, this->getInfo())) {
         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();
     }
 
-    // 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.
-    config.output.colorspace = colorXform ? MODE_RGBA :
-            webp_decode_mode(dstInfo.colorType(), dstInfo.alphaType() == kPremul_SkAlphaType);
+    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);
     config.output.is_external_memory = 1;
 
-    // We will decode the entire image and then perform the color transform.  libwebp
-    // does not provide a row-by-row API.  This is a shame particularly in the F16 case,
-    // where we need to allocate an extra image-sized buffer.
-    SkAutoTMalloc<uint32_t> pixels;
-    if (kRGBA_F16_SkColorType == dstInfo.colorType()) {
-        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:
-            rowsDecoded = dstInfo.height();
-            result = kSuccess;
-            break;
+            return kSuccess;
         case VP8_STATUS_SUSPENDED:
-            WebPIDecGetRGB(idec, rowsDecodedPtr, nullptr, nullptr, nullptr);
-            rowsDecoded = *rowsDecodedPtr;
-            result = kIncompleteInput;
-            break;
+            WebPIDecGetRGB(idec, rowsDecoded, nullptr, nullptr, nullptr);
+            return kIncompleteInput;
         default:
             return kInvalidInput;
     }
-
-    if (colorXform) {
-        SkAlphaType xformAlphaType = select_alpha_xform(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))
 {}