Use SkColorSpaceXform to handle color conversions in decoders

third_party/WebKit/Source/platform/image-decoders/webp/WEBPImageDecoder.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 10 matching lines @@
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "platform/image-decoders/webp/WEBPImageDecoder.h"
 
-#if USE(QCMSLIB)
-#include "qcms.h"
-#endif
-
 #if CPU(BIG_ENDIAN) || CPU(MIDDLE_ENDIAN)
 #error Blink assumes a little-endian target.
 #endif
 
 #if SK_B32_SHIFT  // Output little-endian RGBA pixels (Android).
 inline WEBP_CSP_MODE outputMode(bool hasAlpha) {
   return hasAlpha ? MODE_rgbA : MODE_RGBA;
 }
 #else  // Output little-endian BGRA pixels.
 inline WEBP_CSP_MODE outputMode(bool hasAlpha) {
@@ skipping 294 matching lines @@
   WebPChunkIterator chunkIterator;
   if (!WebPDemuxGetChunk(m_demux, "ICCP", 1, &chunkIterator)) {
     WebPDemuxReleaseChunkIterator(&chunkIterator);
     return;
   }
 
   const char* profileData =
       reinterpret_cast<const char*>(chunkIterator.chunk.bytes);
   size_t profileSize = chunkIterator.chunk.size;
 
-  setColorProfileAndComputeTransform(profileData, profileSize,
-                                     true /* hasAlpha */, false /* useSRGB */);
+  setColorSpaceAndComputeTransform(profileData, profileSize,
+                                   false /* useSRGB */);
 
   WebPDemuxReleaseChunkIterator(&chunkIterator);
 }
 
 void WEBPImageDecoder::applyPostProcessing(size_t frameIndex) {
   ImageFrame& buffer = m_frameBufferCache[frameIndex];
   int width;
   int decodedHeight;
   if (!WebPIDecGetRGB(m_decoder, &decodedHeight, &width, 0, 0))
     return;  // See also https://bugs.webkit.org/show_bug.cgi?id=74062
   if (decodedHeight <= 0)
     return;
 
   const IntRect& frameRect = buffer.originalFrameRect();
   ASSERT_WITH_SECURITY_IMPLICATION(width == frameRect.width());
   ASSERT_WITH_SECURITY_IMPLICATION(decodedHeight <= frameRect.height());
   const int left = frameRect.x();
   const int top = frameRect.y();
 
-#if USE(QCMSLIB)
-  if (qcms_transform* transform = colorTransform()) {
+#if USE(SKCOLORXFORM)
+  // FIXME:

[scroggo_chromium, 2016/10/20 12:45:04]

nit: TODO (msarett):

[msarett, 2016/10/20 13:20:52]

Done.

+  // Here we apply the color space transformation to the dst space.
+  // It does not really make sense to transform to a gamma-encoded
+  // space and then immediately after, perform a linear premultiply
+  // and linear blending.  Can we find a way to perform the
+  // premultiplication and blending in a linear space?
+  SkColorSpaceXform* xform = colorTransform();
+  if (xform) {
+    const SkColorSpaceXform::ColorFormat srcFormat =
+        SkColorSpaceXform::kBGRA_8888_ColorFormat;
+    const SkColorSpaceXform::ColorFormat dstFormat =
+        SkColorSpaceXform::kRGBA_8888_ColorFormat;
     for (int y = m_decodedHeight; y < decodedHeight; ++y) {
       const int canvasY = top + y;
       uint8_t* row = reinterpret_cast<uint8_t*>(buffer.getAddr(left, canvasY));
-      qcms_transform_data_type(transform, row, row, width, QCMS_OUTPUT_RGBX);
+      xform->apply(dstFormat, row, srcFormat, row, width,
+                   kUnpremul_SkAlphaType);
+
       uint8_t* pixel = row;
       for (int x = 0; x < width; ++x, pixel += 4) {
         const int canvasX = left + x;
         buffer.setRGBA(canvasX, canvasY, pixel[0], pixel[1], pixel[2],
                        pixel[3]);
       }
     }
   }
-#endif  // USE(QCMSLIB)
+#endif  // USE(SKCOLORXFORM)
 
   // During the decoding of the current frame, we may have set some pixels to be
   // transparent (i.e. alpha < 255). If the alpha blend source was
   // 'BlendAtopPreviousFrame', the values of these pixels should be determined
   // by blending them against the pixels of the corresponding previous frame.
   // Compute the correct opaque values now.
   // FIXME: This could be avoided if libwebp decoder had an API that used the
   // previous required frame to do the alpha-blending by itself.
   if ((m_formatFlags & ANIMATION_FLAG) && frameIndex &&
       buffer.getAlphaBlendSource() == ImageFrame::BlendAtopPreviousFrame &&
@@ skipping 129 matching lines @@
     // fully decoded.
     buffer.setHasAlpha(true);
     buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
   }
 
   const IntRect& frameRect = buffer.originalFrameRect();
   if (!m_decoder) {
     WEBP_CSP_MODE mode = outputMode(m_formatFlags & ALPHA_FLAG);
     if (!m_premultiplyAlpha)
       mode = outputMode(false);
-#if USE(QCMSLIB)
-    if (colorTransform())
-      mode = MODE_RGBA;  // Decode to RGBA for input to libqcms.
+#if USE(SKCOLORXFORM)
+    if (colorTransform()) {
+      // Swizzling between RGBA and BGRA is zero cost in a color transform.
+      // So when we have a color transform, we should decode to whatever is
+      // easiest for libwebp, and then let the color transform swizzle if
+      // necessary.
+      // Lossy webp is encoded as YUV (so RGBA and BGRA are the same cost).
+      // Lossless webp is encoded as BGRA. This means decoding to BGRA is
+      // either faster or the same cost as RGBA.
+      mode = MODE_BGRA;
+    }
 #endif
     WebPInitDecBuffer(&m_decoderBuffer);
     m_decoderBuffer.colorspace = mode;
     m_decoderBuffer.u.RGBA.stride =
         size().width() * sizeof(ImageFrame::PixelData);
     m_decoderBuffer.u.RGBA.size =
         m_decoderBuffer.u.RGBA.stride * frameRect.height();
     m_decoderBuffer.is_external_memory = 1;
     m_decoder = WebPINewDecoder(&m_decoderBuffer);
     if (!m_decoder)
@@ skipping 17 matching lines @@
         return false;
       }
     // FALLTHROUGH
     default:
       clear();
       return setFailed();
   }
 }
 
 }  // namespace blink