[poc] redecode

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 11 matching lines @@
  * (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 "config.h"
 #include "platform/image-decoders/webp/WEBPImageDecoder.h"
 
+#include "platform/graphics/GraphicsScreen.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; }
@@ skipping 88 matching lines @@
     , m_hasColorProfile(false)
 #if USE(QCMSLIB)
     , m_transform(0)
 #endif
     , m_demux(0)
     , m_demuxState(WEBP_DEMUX_PARSING_HEADER)
     , m_haveAlreadyParsedThisData(false)
     , m_repetitionCount(cAnimationLoopOnce)
     , m_decodedHeight(0)
 {
+    fprintf(stderr, "WEBP decoder %p created %s\n", this, !isMainThread() ? "impl-side-thread" : "");
+
     m_blendFunction = (alphaOption == AlphaPremultiplied) ? alphaBlendPremultiplied : alphaBlendNonPremultiplied;
 }
 
 WEBPImageDecoder::~WEBPImageDecoder()
 {
     clear();
 }
 
 void WEBPImageDecoder::clear()
 {
@@ skipping 81 matching lines @@
             // Repetition count is the number of animation cycles to show,
             // where 0 means "infinite". But ImageSource::repetitionCount()
             // returns -1 for "infinite", and 0 and up for "show the image
             // animation one cycle more than the value". Subtract one here
             // to correctly handle the finite and infinite cases.
             --m_repetitionCount;
             // FIXME: Implement ICC profile support for animated images.
             m_formatFlags &= ~ICCP_FLAG;
         }
 
+        fprintf(stderr, "WEBP decoder %p headerAvailable %dx%d %s\n", this, size().width(), size().height(), "size-only-decode");
+
 #if USE(QCMSLIB)
         if ((m_formatFlags & ICCP_FLAG) && !ignoresGammaAndColorProfile())
             readColorProfile();
 #endif
     }
 
     ASSERT(isDecodedSizeAvailable());
     return true;
 }
 
@@ skipping 58 matching lines @@
 
 #if USE(QCMSLIB)
 
 void WEBPImageDecoder::clearColorTransform()
 {
     if (m_transform)
         qcms_transform_release(m_transform);
     m_transform = 0;
 }
 
-bool WEBPImageDecoder::createColorTransform(const char* data, size_t size)
+PassRefPtr<ColorSpaceProfile> WEBPImageDecoder::createColorTransform(const char* data, size_t size)
 {
     clearColorTransform();
 
+    fprintf(stderr, "WEBP decoder %p createColorTransform ", this);
+
+    if (m_deviceProfile)
+        fprintf(stderr, ": device %p\n", m_deviceProfile.get());
+    else
+        fprintf(stderr, ": %p\n", nullptr);
+    fprintf(stderr, "image color profiles enabled: %d\n", imageColorProfilesEnabled());
+    fflush(stderr);
+
     qcms_profile* deviceProfile = ImageDecoder::qcmsOutputDeviceProfile();
+    if (m_deviceProfile)
+        deviceProfile = m_deviceProfile->profile();
     if (!deviceProfile)
-        return false;
+        return nullptr;
+
     qcms_profile* inputProfile = qcms_profile_from_memory(data, size);
     if (!inputProfile)
-        return false;
+        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));
     // The input image pixels are RGBA format.
     qcms_data_type format = QCMS_DATA_RGBA_8;
     // FIXME: Don't force perceptual intent if the image profile contains an intent.
     m_transform = qcms_transform_create(inputProfile, format, deviceProfile, QCMS_DATA_RGBA_8, QCMS_INTENT_PERCEPTUAL);
+    if (m_transform)
+        return ColorSpaceProfile::create(inputProfile);
 
     qcms_profile_release(inputProfile);
-    return !!m_transform;
+    return nullptr;
 }
 
 void WEBPImageDecoder::readColorProfile()
 {
     WebPChunkIterator chunkIterator;
     if (!WebPDemuxGetChunk(m_demux, "ICCP", 1, &chunkIterator)) {
+        RELEASE_ASSERT(!m_hasColorProfile && !m_transform);
         WebPDemuxReleaseChunkIterator(&chunkIterator);
         return;
     }
 
     const char* profileData = reinterpret_cast<const char*>(chunkIterator.chunk.bytes);
     size_t profileSize = chunkIterator.chunk.size;
 
     // Only accept RGB color profiles from input class devices.
     bool ignoreProfile = false;
     if (profileSize < ImageDecoder::iccColorProfileHeaderLength)
         ignoreProfile = true;
     else if (!ImageDecoder::rgbColorProfile(profileData, profileSize))
         ignoreProfile = true;
     else if (!ImageDecoder::inputDeviceColorProfile(profileData, profileSize))
         ignoreProfile = true;
 
-    if (!ignoreProfile)
-        m_hasColorProfile = createColorTransform(profileData, profileSize);
+    if (ignoreProfile) {
+        RELEASE_ASSERT(!m_hasColorProfile && !m_transform);
+        WebPDemuxReleaseChunkIterator(&chunkIterator);
+        return;
+    }
+
+    RefPtr<ColorSpaceProfile> imageColorProfile = createColorTransform(profileData, profileSize);
+    m_hasColorProfile = !!imageColorProfile.get();
+    if (m_hasColorProfile && imageColorProfilesEnabled()) {
+        RELEASE_ASSERT(imageColorProfile->profile());
+        m_colorProfile = imageColorProfile;
+    }
 
     WebPDemuxReleaseChunkIterator(&chunkIterator);
 }
 
 #endif // USE(QCMSLIB)
 
 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 (m_decodedHeight < decodedHeight)
+        fprintf(stderr, "WEBP decoder %p %dx%d decode row %d\n", this, size().width(), size().height(), decodedHeight);
+
 #if USE(QCMSLIB)
     if (qcms_transform* transform = colorTransform()) {
+        if (m_decodedHeight < decodedHeight)
+            fprintf(stderr, "WEBP decoder %p %dx%d color transform row %d\n", this, size().width(), size().height(), decodedHeight);
         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);
             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]);
             }
         }
@@ skipping 140 matching lines @@
     }
 
     m_decoderBuffer.u.RGBA.rgba = reinterpret_cast<uint8_t*>(buffer.getAddr(frameRect.x(), frameRect.y()));
 
     switch (WebPIUpdate(m_decoder, dataBytes, dataSize)) {
     case VP8_STATUS_OK:
         applyPostProcessing(frameIndex);
         buffer.setHasAlpha((m_formatFlags & ALPHA_FLAG) || m_frameBackgroundHasAlpha);
         buffer.setStatus(ImageFrame::FrameComplete);
         clearDecoder();
+        fflush(stderr);
         return true;
     case VP8_STATUS_SUSPENDED:
         if (!isAllDataReceived() && !frameIsCompleteAtIndex(frameIndex)) {
             applyPostProcessing(frameIndex);
+            fflush(stderr);
             return false;
         }
         // FALLTHROUGH
     default:
         clear();
         return setFailed();
     }
 }
 
 } // namespace blink