[poc] redecode

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 21 matching lines @@
  * deletingthe provisions above and replace them with the notice and
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "config.h"
 #include "platform/image-decoders/jpeg/JPEGImageDecoder.h"
 
 #include "platform/PlatformInstrumentation.h"
+#include "platform/graphics/GraphicsScreen.h"
 
 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
@@ skipping 418 matching lines @@
             jpeg_calc_output_dimensions(&m_info);
             m_decoder->setDecodedSize(m_info.output_width, m_info.output_height);
 
             m_decoder->setOrientation(readImageOrientation(info()));
 
 #if USE(QCMSLIB)
             // Allow color management of the decoded RGBA pixels if possible.
             if (!m_decoder->ignoresGammaAndColorProfile()) {
                 ColorProfile colorProfile;
                 readColorProfile(info(), colorProfile);
-                createColorTransform(colorProfile, colorSpaceHasAlpha(m_info.out_color_space));
-                if (m_transform) {
+                bool imageHasAlpha = colorSpaceHasAlpha(m_info.out_color_space);
+                RefPtr<ColorSpaceProfile> imageColorProfile = createColorTransform(colorProfile, imageHasAlpha);
+                m_decoder->setHasColorProfile(!!imageColorProfile.get());
+                if (m_decoder->hasColorProfile()) {
+                    // FIXME: allow YUV decoding of color profiled images.
                     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)
+                    if (m_transform && m_info.out_color_space == JCS_EXT_BGRA)
                         m_info.out_color_space = JCS_EXT_RGBA;
 #endif
+                    if (imageColorProfilesEnabled()) {
+                        RELEASE_ASSERT(imageColorProfile->profile());
+                        m_decoder->setColorProfile(imageColorProfile);
+                    }
                 }
-                m_decoder->setHasColorProfile(!!m_transform);
             }
 #endif
             if (overrideColorSpace == JCS_YCbCr) {
                 m_info.out_color_space = JCS_YCbCr;
                 m_info.raw_data_out = TRUE;
                 m_uvSize = computeYUVSize(&m_info, 1, ImageDecoder::SizeForMemoryAllocation); // 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
             // image is a sequential JPEG.
             m_info.buffered_image = jpeg_has_multiple_scans(&m_info);
             if (m_info.buffered_image) {
                 m_err.pub.emit_message = emit_message;
                 m_err.num_corrupt_warnings = 0;
             }
 
+            fprintf(stderr, "JPEG decoder %p headerAvailable %dx%d %s\n", m_decoder, m_info.image_width, m_info.image_height, onlySize ? "size-only-decode" : "");
+
             if (onlySize) {
                 // This exits the function while there is still potentially
                 // data in the buffer. Before this function is called again,
                 // the SharedBuffer may be collapsed (by a call to
                 // mergeSegmentsIntoBuffer), invalidating the "buffer" (which
                 // in reality is a pointer into the SharedBuffer's data).
                 // Defensively empty the buffer, but first find the latest
                 // restart position and signal to restart, so the next call to
                 // fillBuffer will resume from the correct point.
                 m_needsRestart = true;
@@ skipping 112 matching lines @@
 #if USE(QCMSLIB)
     qcms_transform* colorTransform() const { return m_transform; }
 
     void clearColorTransform()
     {
         if (m_transform)
             qcms_transform_release(m_transform);
         m_transform = 0;
     }
 
-    void createColorTransform(const ColorProfile& colorProfile, bool hasAlpha)
+    PassRefPtr<ColorSpaceProfile> createColorTransform(const ColorProfile& colorProfile, bool hasAlpha)
     {
         clearColorTransform();
 
+        fprintf(stderr, "JPEG decoder %p createColorTransform ", m_decoder);
+
+        if (m_decoder->deviceProfile())
+            fprintf(stderr, ": device %p\n", m_decoder->deviceProfile().get());
+        else
+            fprintf(stderr, ": %p\n", nullptr);
+        fprintf(stderr, "image color profiles enabled: %d\n", imageColorProfilesEnabled());
+        fflush(stderr);
+
         if (colorProfile.isEmpty())
-            return;
+            return nullptr;
+
         qcms_profile* deviceProfile = ImageDecoder::qcmsOutputDeviceProfile();
+        if (m_decoder->deviceProfile())
+            deviceProfile = m_decoder->deviceProfile()->profile();
         if (!deviceProfile)
-            return;
+            return nullptr;
+
         qcms_profile* inputProfile = qcms_profile_from_memory(colorProfile.data(), colorProfile.size());
         if (!inputProfile)
-            return;
+            return nullptr;
+
+        fprintf(stderr, " from source profile [%s]", qcms_profile_get_description(inputProfile));
+        fprintf(stderr, " to [%s]\n", qcms_profile_get_description(deviceProfile));
+        fflush(stderr);
+
+        // There is no need to create a color transform if the color profiles match.
+        if (imageColorProfilesEnabled() && qcms_profile_match(inputProfile, deviceProfile))
+            return ColorSpaceProfile::create(inputProfile);
+
         // We currently only support color profiles for RGB profiled images.
         ASSERT(rgbData == qcms_profile_get_color_space(inputProfile));
         qcms_data_type dataFormat = hasAlpha ? QCMS_DATA_RGBA_8 : QCMS_DATA_RGB_8;
         // FIXME: Don't force perceptual intent if the image profile contains an intent.
         m_transform = qcms_transform_create(inputProfile, dataFormat, deviceProfile, dataFormat, QCMS_INTENT_PERCEPTUAL);
+        if (m_transform)
+            return ColorSpaceProfile::create(inputProfile);
+
         qcms_profile_release(inputProfile);
+        return nullptr;
     }
 #endif
 
 private:
     JSAMPARRAY allocateSampleArray()
     {
         // Some output color spaces don't need the sample array: don't allocate in that case.
 #if defined(TURBO_JPEG_RGB_SWIZZLE)
         if (turboSwizzled(m_info.out_color_space))
             return nullptr;
@@ skipping 90 matching lines @@
 
 void term_source(j_decompress_ptr jd)
 {
     reinterpret_cast_ptr<decoder_source_mgr*>(jd->src)->reader->decoder()->complete();
 }
 
 JPEGImageDecoder::JPEGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes)
     : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes)
     , m_hasColorProfile(false)
 {
+    fprintf(stderr, "JPEG decoder %p created %s\n", this, !isMainThread() ? "impl-side-thread" : "");
 }
 
 JPEGImageDecoder::~JPEGImageDecoder()
 {
 }
 
 bool JPEGImageDecoder::setSize(unsigned width, unsigned height)
 {
     if (!ImageDecoder::setSize(width, height))
         return false;
@@ skipping 225 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 = m_reader->colorTransform())
+            if (qcms_transform* transform = m_reader->colorTransform()) {
+                if (info->output_scanline <= 3 || info->output_scanline >= info->output_height)
+                    fprintf(stderr, "JPEG decoder %p %dx%d color transform row %d\n", this, size().width(), size().height(), info->output_scanline - 1);
                 qcms_transform_data_type(transform, row, row, info->output_width, rgbOutputColorSpace() == JCS_EXT_BGRA ? QCMS_OUTPUT_BGRX : QCMS_OUTPUT_RGBX);
+            }
 #endif
+            if (info->output_scanline <= 3)
+                fprintf(stderr, "JPEG decoder %p %dx%d row %d\n", this, size().width(), size().height(), info->output_scanline - 1);
+
+            if (info->output_scanline >= info->output_height) {
+                fprintf(stderr, "JPEG decoder %p %dx%d row %d\n", this, size().width(), size().height(), info->output_scanline - 1);
+                fflush(stderr);
+            }
         }
+
         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:
         return outputRows<JCS_CMYK>(m_reader.get(), buffer);
     default:
         ASSERT_NOT_REACHED();
     }
 
     return setFailed();
 }
 
 void JPEGImageDecoder::complete()
 {
+    fflush(stderr);
+
     if (m_frameBufferCache.isEmpty())
         return;
 
     m_frameBufferCache[0].setHasAlpha(false);
     m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
 }
 
 inline bool isComplete(const JPEGImageDecoder* decoder, bool onlySize)
 {
     if (decoder->hasImagePlanes() && !onlySize)
@@ skipping 16 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.clear();
 }
 
 }