[poc] redecode

third_party/WebKit/Source/platform/image-decoders/png/PNGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
  *
  * Portions are Copyright (C) 2001 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 21 matching lines @@
  * version of this file under the LGPL, indicate your decision by
  * 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/png/PNGImageDecoder.h"
 
+#include "platform/graphics/GraphicsScreen.h"
+
 #include "png.h"
 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR)
 #error version error: compile against a versioned libpng.
 #endif
 #if USE(QCMSLIB)
 #include "qcms.h"
 #endif
 
 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 4)
 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
@@ skipping 98 matching lines @@
     void createRowBuffer(int size) { m_rowBuffer = adoptArrayPtr(new png_byte[size]); }
     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, bool sRGB)
+    PassRefPtr<ColorSpaceProfile> createColorTransform(const ColorProfile& colorProfile, bool hasAlpha, bool sRGB)
     {
         clearColorTransform();
 
+        fprintf(stderr, "PNG 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() && !sRGB)
-            return;
+            return nullptr;
+
         qcms_profile* deviceProfile = ImageDecoder::qcmsOutputDeviceProfile();
+        if (m_decoder->deviceProfile())
+            deviceProfile = m_decoder->deviceProfile()->profile();
         if (!deviceProfile)
-            return;
-        qcms_profile* inputProfile = 0;
+            return nullptr;
+
+        qcms_profile* inputProfile = nullptr;
         if (!colorProfile.isEmpty())
             inputProfile = qcms_profile_from_memory(colorProfile.data(), colorProfile.size());
         else
             inputProfile = qcms_profile_sRGB();
         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 and RGBA 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:
     png_structp m_png;
     png_infop m_info;
     PNGImageDecoder* m_decoder;
     unsigned m_readOffset;
     unsigned m_currentBufferSize;
     bool m_decodingSizeOnly;
     bool m_hasAlpha;
     OwnPtr<png_byte[]> m_interlaceBuffer;
 #if USE(QCMSLIB)
     qcms_transform* m_transform;
     OwnPtr<png_byte[]> m_rowBuffer;
 #endif
 };
 
 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes, unsigned offset)
     : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes)
     , m_hasColorProfile(false)
     , m_offset(offset)
 {
+    fprintf(stderr, "PNG decoder %p created %s\n", this, !isMainThread() ? "impl-side-thread" : "");
 }
 
 PNGImageDecoder::~PNGImageDecoder()
 {
+    fprintf(stderr, "PNG decoder %p ~PNGImageDecoder() %s\n", this, !isMainThread() ? "impl-side-thread" : "");
 }
 
 #if USE(QCMSLIB)
 static void getColorProfile(png_structp png, png_infop info, ColorProfile& colorProfile, bool& sRGB)
 {
 #ifdef PNG_iCCP_SUPPORTED
     ASSERT(colorProfile.isEmpty());
     if (png_get_valid(png, info, PNG_INFO_sRGB)) {
         sRGB = true;
         return;
@@ skipping 73 matching lines @@
         // We only support color profiles for color PALETTE and RGB[A] PNG. Supporting
         // color profiles for gray-scale images is slightly tricky, at least using the
         // CoreGraphics ICC library, because we expand gray-scale images to RGB but we
         // do not similarly transform the color profile. We'd either need to transform
         // the color profile or we'd need to decode into a gray-scale image buffer and
         // hand that to CoreGraphics.
         bool sRGB = false;
         ColorProfile colorProfile;
         getColorProfile(png, info, colorProfile, sRGB);
         bool imageHasAlpha = (colorType & PNG_COLOR_MASK_ALPHA) || trnsCount;
-        m_reader->createColorTransform(colorProfile, imageHasAlpha, sRGB);
-        m_hasColorProfile = !!m_reader->colorTransform();
+        RefPtr<ColorSpaceProfile> imageColorProfile = m_reader->createColorTransform(colorProfile, imageHasAlpha, sRGB);
+        m_hasColorProfile = !!imageColorProfile.get();
+        if (m_hasColorProfile && imageColorProfilesEnabled()) {
+            RELEASE_ASSERT(imageColorProfile->profile());
+            m_colorProfile = imageColorProfile;
+        }
     }
 #endif
 
     if (!m_hasColorProfile) {
         // Deal with gamma and keep it under our control.
         const double inverseGamma = 0.45455;
         const double defaultGamma = 2.2;
         double gamma;
         if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) {
             const double maxGamma = 21474.83;
@@ skipping 11 matching lines @@
     if (interlaceType == PNG_INTERLACE_ADAM7)
         png_set_interlace_handling(png);
 
     // Update our info now.
     png_read_update_info(png, info);
     channels = png_get_channels(png, info);
     ASSERT(channels == 3 || channels == 4);
 
     m_reader->setHasAlpha(channels == 4);
 
+    fprintf(stderr, "PNG decoder %p headerAvailable %lux%lu %s\n", this, width, height, m_reader->decodingSizeOnly() ? "size-only-decode" : "");
+
     if (m_reader->decodingSizeOnly()) {
         // If we only needed the size, halt the reader.
 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5)
         // '0' argument to png_process_data_pause means: Do not cache unprocessed data.
         m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0));
 #else
         m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
         png->buffer_size = 0;
 #endif
     }
@@ skipping 82 matching lines @@
     png_bytep row = rowBuffer;
 
     if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
         unsigned colorChannels = hasAlpha ? 4 : 3;
         row = interlaceBuffer + (rowIndex * colorChannels * size().width());
         png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
     }
 
 #if USE(QCMSLIB)
     if (qcms_transform* transform = m_reader->colorTransform()) {
+        if (rowIndex < 3 || rowIndex >= (unsigned)size().height() - 1)
+            fprintf(stderr, "PNG decoder %p %dx%d color transform row %d\n", this, size().width(), size().height(), rowIndex);
         qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width());
         row = m_reader->rowBuffer();
     }
 #endif
 
+    if (rowIndex < 3)
+        fprintf(stderr, "PNG decoder %p %dx%d row %d\n", this, size().width(), size().height(), rowIndex);
+    if (rowIndex >= (unsigned)size().height() - 1) {
+        fprintf(stderr, "PNG decoder %p %dx%d row %d\n", this, size().width(), size().height(), rowIndex);
+        fflush(stderr);
+    }
+
     // Write the decoded row pixels to the frame buffer. The repetitive
     // form of the row write loops is for speed.
     ImageFrame::PixelData* address = buffer.getAddr(0, y);
     unsigned alphaMask = 255;
     int width = size().width();
 
     png_bytep pixel = row;
     if (hasAlpha) {
         if (buffer.premultiplyAlpha()) {
             for (int x = 0; x < width; ++x, pixel += 4) {
@@ skipping 13 matching lines @@
     }
 
     if (alphaMask != 255 && !buffer.hasAlpha())
         buffer.setHasAlpha(true);
 
     buffer.setPixelsChanged(true);
 }
 
 void PNGImageDecoder::complete()
 {
+    fflush(stderr);
+
     if (m_frameBufferCache.isEmpty())
         return;
 
     m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
 }
 
 inline bool isComplete(const PNGImageDecoder* decoder)
 {
     return decoder->frameIsCompleteAtIndex(0);
 }
@@ skipping 10 matching lines @@
     // has failed.
     if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
         setFailed();
 
     // If decoding is done or failed, we don't need the PNGImageReader anymore.
     if (isComplete(this) || failed())
         m_reader.clear();
 }
 
 } // namespace blink