Use SkColorSpaceXform to handle color conversions in decoders

third_party/WebKit/Source/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * Portions are Copyright (C) 2001-6 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 28 matching lines @@
 
 #include "platform/Histogram.h"
 #include "platform/PlatformInstrumentation.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Threading.h"
 #include <memory>
 
 extern "C" {
 #include <stdio.h>  // jpeglib.h needs stdio FILE.
 #include "jpeglib.h"
-#if USE(ICCJPEG)
 #include "iccjpeg.h"
-#endif
-#if USE(QCMSLIB)
-#include "qcms.h"
-#endif
 #include <setjmp.h>
 }
 
 #if CPU(BIG_ENDIAN) || CPU(MIDDLE_ENDIAN)
 #error Blink assumes a little-endian target.
 #endif
 
 #if defined(JCS_ALPHA_EXTENSIONS)
 #define TURBO_JPEG_RGB_SWIZZLE
 #if SK_B32_SHIFT  // Output little-endian RGBA pixels (Android).
 inline J_COLOR_SPACE rgbOutputColorSpace() {
   return JCS_EXT_RGBA;
 }
 #else  // Output little-endian BGRA pixels.
 inline J_COLOR_SPACE rgbOutputColorSpace() {
   return JCS_EXT_BGRA;
 }
 #endif
 inline bool turboSwizzled(J_COLOR_SPACE colorSpace) {
   return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA;
 }
-inline bool colorSpaceHasAlpha(J_COLOR_SPACE colorSpace) {
-  return turboSwizzled(colorSpace);
-}
 #else
 inline J_COLOR_SPACE rgbOutputColorSpace() {
   return JCS_RGB;
 }
-inline bool colorSpaceHasAlpha(J_COLOR_SPACE) {
-  return false;
-}
 #endif
 
 namespace {
 
 const int exifMarker = JPEG_APP0 + 1;
 
 // JPEG only supports a denominator of 8.
 const unsigned scaleDenominator = 8;
 
 }  // namespace
@@ skipping 208 matching lines @@
     m_info.src = reinterpret_cast_ptr<jpeg_source_mgr*>(&m_src);
 
     // Set up callback functions.
     m_src.pub.init_source = init_source;
     m_src.pub.fill_input_buffer = fill_input_buffer;
     m_src.pub.skip_input_data = skip_input_data;
     m_src.pub.resync_to_restart = jpeg_resync_to_restart;
     m_src.pub.term_source = term_source;
     m_src.reader = this;
 
-#if USE(ICCJPEG)
     // Retain ICC color profile markers for color management.
     setup_read_icc_profile(&m_info);
-#endif
+
     // Keep APP1 blocks, for obtaining exif data.
     jpeg_save_markers(&m_info, exifMarker, 0xFFFF);
   }
 
   ~JPEGImageReader() { jpeg_destroy_decompress(&m_info); }
 
   void skipBytes(long numBytes) {
     if (numBytes <= 0)
       return;
 
@@ skipping 122 matching lines @@
         // decoder, so using the full size is no longer possible.
         if (m_info.scale_num != m_info.scale_denom)
           overrideColorSpace = JCS_UNKNOWN;
         jpeg_calc_output_dimensions(&m_info);
         m_decoder->setDecodedSize(m_info.output_width, m_info.output_height);
 
         m_decoder->setOrientation(readImageOrientation(info()));
 
         // Allow color management of the decoded RGBA pixels if possible.
         if (!m_decoder->ignoresGammaAndColorProfile()) {
-#if USE(ICCJPEG)
           JOCTET* profile = nullptr;
           unsigned profileLength = 0;
           if (read_icc_profile(info(), &profile, &profileLength)) {
-            decoder()->setColorProfileAndComputeTransform(
+            decoder()->setColorSpaceAndComputeTransform(
                 reinterpret_cast<char*>(profile), profileLength,
-                colorSpaceHasAlpha(info()->out_color_space),
                 false /* useSRGB */);
             free(profile);
           }
-#endif  // USE(ICCJPEG)
-#if USE(QCMSLIB)
+
           if (decoder()->colorTransform()) {
             overrideColorSpace = JCS_UNKNOWN;
-#if defined(TURBO_JPEG_RGB_SWIZZLE)
-            // Input RGBA data to qcms. Note: restored to BGRA on output.
-            if (m_info.out_color_space == JCS_EXT_BGRA)
-              m_info.out_color_space = JCS_EXT_RGBA;
-#endif  // defined(TURBO_JPEG_RGB_SWIZZLE)
           }
-#endif  // USE(QCMSLIB)
         }
         if (overrideColorSpace == JCS_YCbCr) {
           m_info.out_color_space = JCS_YCbCr;
           m_info.raw_data_out = TRUE;
           m_uvSize = computeYUVSize(
               &m_info,
               1);  // U size and V size have to be the same if we got here
         }
 
         // Don't allocate a giant and superfluous memory buffer when the
@@ skipping 316 matching lines @@
 }
 
 template <J_COLOR_SPACE colorSpace>
 void setPixel(ImageFrame& buffer,
               ImageFrame::PixelData* pixel,
               JSAMPARRAY samples,
               int column) {
   ASSERT_NOT_REACHED();
 }
 
+// Used only for debugging with libjpeg (instead of libjpeg-turbo).
 template <>
 void setPixel<JCS_RGB>(ImageFrame& buffer,
                        ImageFrame::PixelData* pixel,
                        JSAMPARRAY samples,
                        int column) {
   JSAMPLE* jsample = *samples + column * 3;
   buffer.setRGBARaw(pixel, jsample[0], jsample[1], jsample[2], 255);
 }
 
 template <>
@@ skipping 10 matching lines @@
   // X =   X    * (1 -   K   ) +   K  [for X = C, M, or Y]
   // Thus, from Inverted CMYK to CMY is:
   // X = (1-iX) * (1 - (1-iK)) + (1-iK) => 1 - iX*iK
   // From CMY (0..1) to RGB (0..1):
   // R = 1 - C => 1 - (1 - iC*iK) => iC*iK  [G and B similar]
   unsigned k = jsample[3];
   buffer.setRGBARaw(pixel, jsample[0] * k / 255, jsample[1] * k / 255,
                     jsample[2] * k / 255, 255);
 }
 
+// Used only for JCS_CMYK and JCS_RGB output.  Note that JCS_RGB is used only
+// for debugging with libjpeg (instead of libjpeg-turbo).
 template <J_COLOR_SPACE colorSpace>
 bool outputRows(JPEGImageReader* reader, ImageFrame& buffer) {
   JSAMPARRAY samples = reader->samples();
   jpeg_decompress_struct* info = reader->info();
   int width = info->output_width;
 
   while (info->output_scanline < info->output_height) {
     // jpeg_read_scanlines will increase the scanline counter, so we
     // save the scanline before calling it.
     int y = info->output_scanline;
     // Request one scanline: returns 0 or 1 scanlines.
     if (jpeg_read_scanlines(info, samples, 1) != 1)
       return false;
-#if USE(QCMSLIB)
-    if (reader->decoder()->colorTransform() && colorSpace == JCS_RGB)
-      qcms_transform_data(reader->decoder()->colorTransform(), *samples,
-                          *samples, width);
-#endif
+
     ImageFrame::PixelData* pixel = buffer.getAddr(0, y);
     for (int x = 0; x < width; ++pixel, ++x)
       setPixel<colorSpace>(buffer, pixel, samples, x);
+
+    SkColorSpaceXform* xform = reader->decoder()->colorTransform();
+    if (JCS_RGB == colorSpace && xform) {
+      ImageFrame::PixelData* row = buffer.getAddr(0, y);
+      xform->apply(xformColorFormat(), row, xformColorFormat(), row, width,
+                   kOpaque_SkAlphaType);
+    }
   }
 
   buffer.setPixelsChanged(true);
   return true;
 }
 
 static bool outputRawData(JPEGImageReader* reader, ImagePlanes* imagePlanes) {
   JSAMPARRAY samples = reader->samples();
   jpeg_decompress_struct* info = reader->info();
 
@@ skipping 80 matching lines @@
     buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
   }
 
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
   if (turboSwizzled(info->out_color_space)) {
     while (info->output_scanline < info->output_height) {
       unsigned char* row = reinterpret_cast_ptr<unsigned char*>(
           buffer.getAddr(0, info->output_scanline));
       if (jpeg_read_scanlines(info, &row, 1) != 1)
         return false;
-#if USE(QCMSLIB)
-      if (qcms_transform* transform = colorTransform())
-        qcms_transform_data_type(transform, row, row, info->output_width,
-                                 rgbOutputColorSpace() == JCS_EXT_BGRA
-                                     ? QCMS_OUTPUT_BGRX
-                                     : QCMS_OUTPUT_RGBX);
-#endif
+
+      SkColorSpaceXform* xform = colorTransform();
+      if (xform) {
+        xform->apply(xformColorFormat(), row, xformColorFormat(), row,
+                     info->output_width, kOpaque_SkAlphaType);
+      }
     }
     buffer.setPixelsChanged(true);
     return true;
   }
 #endif
 
   switch (info->out_color_space) {
     case JCS_RGB:
       return outputRows<JCS_RGB>(m_reader.get(), buffer);
     case JCS_CMYK:
@@ skipping 33 matching lines @@
   // has failed.
   if (!m_reader->decode(onlySize) && isAllDataReceived())
     setFailed();
 
   // If decoding is done or failed, we don't need the JPEGImageReader anymore.
   if (isComplete(this, onlySize) || failed())
     m_reader.reset();
 }
 
 }  // namespace blink