WIP: Implement APNG

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 20 matching lines @@
  * licenses (the MPL or the GPL) and not to allow others to use your
  * 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 "platform/image-decoders/png/PNGImageDecoder.h"
 
+#include "platform/image-decoders/png/PNGImageReader.h"
 #include "png.h"
-#include "wtf/PtrUtil.h"
 #include <memory>
 
 #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)
 #else
 #define JMPBUF(png_ptr) png_ptr->jmpbuf
 #endif
 
-namespace {
-
-inline blink::PNGImageDecoder* imageDecoder(png_structp png)
-{
-    return static_cast<blink::PNGImageDecoder*>(png_get_progressive_ptr(png));
-}
-
-void PNGAPI pngHeaderAvailable(png_structp png, png_infop)
-{
-    imageDecoder(png)->headerAvailable();
-}
-
-void PNGAPI pngRowAvailable(png_structp png, png_bytep row, png_uint_32 rowIndex, int state)
-{
-    imageDecoder(png)->rowAvailable(row, rowIndex, state);
-}
-
-void PNGAPI pngComplete(png_structp png, png_infop)
-{
-    imageDecoder(png)->complete();
-}
-
-void PNGAPI pngFailed(png_structp png, png_const_charp)
-{
-    longjmp(JMPBUF(png), 1);
-}
-
-} // namespace
 
 namespace blink {
 
-class PNGImageReader final {
-    USING_FAST_MALLOC(PNGImageReader);
-    WTF_MAKE_NONCOPYABLE(PNGImageReader);
-public:
-    PNGImageReader(PNGImageDecoder* decoder, size_t readOffset)
-        : m_decoder(decoder)
-        , m_readOffset(readOffset)
-        , m_currentBufferSize(0)
-        , m_decodingSizeOnly(false)
-        , m_hasAlpha(false)
-#if USE(QCMSLIB)
-        , m_rowBuffer()
-#endif
-    {
-        m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0);
-        m_info = png_create_info_struct(m_png);
-        png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable, pngRowAvailable, pngComplete);
-    }
-
-    ~PNGImageReader()
-    {
-        png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
-        ASSERT(!m_png && !m_info);
-
-        m_readOffset = 0;
-    }
-
-    bool decode(const SegmentReader& data, bool sizeOnly)
-    {
-        m_decodingSizeOnly = sizeOnly;
-
-        // We need to do the setjmp here. Otherwise bad things will happen.
-        if (setjmp(JMPBUF(m_png)))
-            return m_decoder->setFailed();
-
-        const char* segment;
-        while (size_t segmentLength = data.getSomeData(segment, m_readOffset)) {
-            m_readOffset += segmentLength;
-            m_currentBufferSize = m_readOffset;
-            png_process_data(m_png, m_info, reinterpret_cast<png_bytep>(const_cast<char*>(segment)), segmentLength);
-            if (sizeOnly ? m_decoder->isDecodedSizeAvailable() : m_decoder->frameIsCompleteAtIndex(0))
-                return true;
-        }
-
-        return false;
-    }
-
-    png_structp pngPtr() const { return m_png; }
-    png_infop infoPtr() const { return m_info; }
-
-    size_t getReadOffset() const { return m_readOffset; }
-    void setReadOffset(size_t offset) { m_readOffset = offset; }
-    size_t currentBufferSize() const { return m_currentBufferSize; }
-    bool decodingSizeOnly() const { return m_decodingSizeOnly; }
-    void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
-    bool hasAlpha() const { return m_hasAlpha; }
-
-    png_bytep interlaceBuffer() const { return m_interlaceBuffer.get(); }
-    void createInterlaceBuffer(int size) { m_interlaceBuffer = wrapArrayUnique(new png_byte[size]); }
-#if USE(QCMSLIB)
-    png_bytep rowBuffer() const { return m_rowBuffer.get(); }
-    void createRowBuffer(int size) { m_rowBuffer = wrapArrayUnique(new png_byte[size]); }
-#endif
-
-private:
-    png_structp m_png;
-    png_infop m_info;
-    PNGImageDecoder* m_decoder;
-    size_t m_readOffset;
-    size_t m_currentBufferSize;
-    bool m_decodingSizeOnly;
-    bool m_hasAlpha;
-    std::unique_ptr<png_byte[]> m_interlaceBuffer;
-#if USE(QCMSLIB)
-    std::unique_ptr<png_byte[]> m_rowBuffer;
-#endif
-};
-
 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes, size_t offset)
     : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes)
     , m_offset(offset)
+    , m_metaDataDecoded(false)
+    , m_frameCount(0)
+    , m_currentFrame(0)
+    , m_repetitionCount(cAnimationLoopOnce)
 {
 }
 
 PNGImageDecoder::~PNGImageDecoder()
 {
 }
 
+size_t PNGImageDecoder::decodeFrameCount()
+{
+    if (!m_metaDataDecoded)
+        parse(PNGParseQuery::PNGMetaDataQuery);
+    return m_frameCount;
+}
+
+inline bool frameComplete(ImageFrame& frame)
+{
+    return frame.getStatus() == ImageFrame::FrameComplete;
+}
+
+void PNGImageDecoder::decode(size_t index)
+{
+    m_currentFrame = index;
+    m_reader->decode(*m_data, index);
+}
+
+void PNGImageDecoder::parse(PNGParseQuery query)
+{
+    if (failed())
+        return;
+
+    if (!m_reader)
+        m_reader = wrapUnique(new PNGImageReader(this, m_offset));
+
+    if (!m_reader->parse(*m_data, query) && isAllDataReceived())
+        setFailed();
+
+    if (query == PNGParseQuery::PNGMetaDataQuery)
+        m_frameCount = m_reader->frameCount();
+}
+
+void PNGImageDecoder::setRepetitionCount(size_t repetitionCount)
+{
+    m_repetitionCount = (repetitionCount == 0) ? cAnimationLoopInfinite
+                            : repetitionCount;
+}
+
+// This matches the existing behavior to loop once if decoding fails, but this
+// should be changed to stick with m_repetitionCount to match other browsers.
+// See crbug.com/267883
+int PNGImageDecoder::repetitionCount() const
+{
+    if (m_metaDataDecoded && isAllDataReceived() && m_reader->frameCount() == 1)
+        return cAnimationNone;
+    return failed() ? cAnimationLoopOnce : m_repetitionCount;
+}
+
+// These are mapped according to:
+// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+static inline ImageFrame::DisposalMethod getDisposalMethod(uint8_t disposalMethod)
+{
+    switch (disposalMethod) {
+        case 0:
+            return ImageFrame::DisposalMethod::DisposeKeep;
+        case 1:
+            return ImageFrame::DisposalMethod::DisposeOverwriteBgcolor;
+        case 2:
+            return ImageFrame::DisposalMethod::DisposeOverwritePrevious;
+        default:
+            return ImageFrame::DisposalMethod::DisposeNotSpecified;
+    }
+}
+
+
+// These are mapped according to:
+// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+static inline ImageFrame::AlphaBlendSource getAlphaBlend(uint8_t alphaBlend)
+{
+    if (alphaBlend == 1)
+        return ImageFrame::AlphaBlendSource::BlendAtopPreviousFrame;
+    return ImageFrame::AlphaBlendSource::BlendAtopBgcolor;
+}
+
+void PNGImageDecoder::initializeNewFrame(size_t index)
+{
+    const PNGImageReader::FrameInfo& frameInfo = m_reader->frameInfo(index);
+    ImageFrame* buffer = &m_frameBufferCache[index];
+
+    IntRect frameRectWithinSize = intersection(frameInfo.frameRect,
+                                               {IntPoint(), size()});
+    buffer->setOriginalFrameRect(frameRectWithinSize);
+    buffer->setDuration(frameInfo.duration);
+    buffer->setDisposalMethod(getDisposalMethod(frameInfo.disposalMethod));
+    buffer->setAlphaBlendSource(getAlphaBlend(frameInfo.alphaBlend));
+}
+
 void PNGImageDecoder::headerAvailable()
 {
     png_structp png = m_reader->pngPtr();
     png_infop info = m_reader->infoPtr();
     png_uint_32 width = png_get_image_width(png, info);
     png_uint_32 height = png_get_image_height(png, info);
 
-    // Protect against large PNGs. See http://bugzil.la/251381 for more details.
-    const unsigned long maxPNGSize = 1000000UL;
-    if (width > maxPNGSize || height > maxPNGSize) {
-        longjmp(JMPBUF(png), 1);
-        return;
-    }
+    // Only set the size of the image once. Since single frames also use this
+    // method, we don't want them to override the size to their frame rect.
+    if (!isDecodedSizeAvailable()) {
+        // Protect against large PNGs. See http://bugzil.la/251381 for more details.
+        const unsigned long maxPNGSize = 1000000UL;
+        if (width > maxPNGSize || height > maxPNGSize) {
+            longjmp(JMPBUF(png), 1);
+            return;
+        }
 
-    // Set the image size now that the image header is available.
-    if (!setSize(width, height)) {
-        longjmp(JMPBUF(png), 1);
-        return;
+        // Set the image size now that the image header is available.
+        if (!setSize(width, height)) {
+            longjmp(JMPBUF(png), 1);
+            return;
+        }
     }
 
     int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
     png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
 
     // The options we set here match what Mozilla does.
 
     // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
     if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
         png_set_expand(png);
@@ skipping 58 matching lines @@
     // Tell libpng to send us rows for interlaced pngs.
     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);
-
-    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
-    }
 }
 
 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int)
 {
+
     if (m_frameBufferCache.isEmpty())
         return;
 
     // Initialize the framebuffer if needed.
-    ImageFrame& buffer = m_frameBufferCache[0];
+    ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
     if (buffer.getStatus() == ImageFrame::FrameEmpty) {
         png_structp png = m_reader->pngPtr();
         if (!buffer.setSizeAndColorProfile(size().width(), size().height(), colorProfile())) {
             longjmp(JMPBUF(png), 1);
             return;
         }
 
         unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
         if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr())) {
             m_reader->createInterlaceBuffer(colorChannels * size().width() * size().height());
             if (!m_reader->interlaceBuffer()) {
                 longjmp(JMPBUF(png), 1);
                 return;
             }
         }
 
 #if USE(QCMSLIB)
         if (colorTransform()) {
             m_reader->createRowBuffer(colorChannels * size().width());
             if (!m_reader->rowBuffer()) {
                 longjmp(JMPBUF(png), 1);
                 return;
             }
         }
 #endif
         buffer.setStatus(ImageFrame::FramePartial);
         buffer.setHasAlpha(false);
+    }
 
-        // For PNGs, the frame always fills the entire image.
-        buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
-    }
+    // This frameRect is already clipped, so that it fits within the size of the
+    // image. This is done in initializeNewFrame() after a frameCount() call.
+    const IntRect& frameRect = buffer.originalFrameRect();
 
     /* libpng comments (here to explain what follows).
      *
      * this function is called for every row in the image. If the
      * image is interlacing, and you turned on the interlace handler,
      * this function will be called for every row in every pass.
      * Some of these rows will not be changed from the previous pass.
      * When the row is not changed, the new_row variable will be NULL.
      * The rows and passes are called in order, so you don't really
      * need the row_num and pass, but I'm supplying them because it
      * may make your life easier.
      */
 
     // Nothing to do if the row is unchanged, or the row is outside
     // the image bounds: libpng may send extra rows, ignore them to
     // make our lives easier.
     if (!rowBuffer)
         return;
-    int y = rowIndex;
-    if (y < 0 || y >= size().height())
+    int y = rowIndex + frameRect.y();
+    if (y >= size().height())

[scroggo_chromium, 2016/10/28 14:20:32]

Since you removed the check for y < 0, please add an ASSERT.

[joostouwerling, 2016/10/28 18:41:25]

Done.

         return;
 
     /* libpng comments (continued).
      *
      * For the non-NULL rows of interlaced images, you must call
      * png_progressive_combine_row() passing in the row and the
      * old row.  You can call this function for NULL rows (it will
      * just return) and for non-interlaced images (it just does the
      * memcpy for you) if it will make the code easier. Thus, you
      * can just do this for all cases:
@@ skipping 19 matching lines @@
 
 #if USE(QCMSLIB)
     if (qcms_transform* transform = colorTransform()) {
         qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width());
         row = m_reader->rowBuffer();
     }
 #endif
 
     // 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);
+    ImageFrame::PixelData* address = buffer.getAddr(frameRect.x(), 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) {
+            for (int x = frameRect.x(); x < frameRect.maxX(); ++x, pixel += 4) {
                 buffer.setRGBAPremultiply(address++, pixel[0], pixel[1], pixel[2], pixel[3]);
                 alphaMask &= pixel[3];
             }
         } else {
-            for (int x = 0; x < width; ++x, pixel += 4) {
+            for (int x = frameRect.x(); x < frameRect.maxX(); ++x, pixel += 4) {
                 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], pixel[3]);
                 alphaMask &= pixel[3];
             }
         }
     } else {
-        for (int x = 0; x < width; ++x, pixel += 3) {
+        for (int x = frameRect.x(); x < frameRect.maxX(); ++x, pixel += 3) {
             buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], 255);
         }
     }
 
     if (alphaMask != 255 && !buffer.hasAlpha())
         buffer.setHasAlpha(true);
 
     buffer.setPixelsChanged(true);
 }
 
+bool PNGImageDecoder::frameIsCompleteAtIndex(size_t index) const
+{
+    // @TODO(joostouwerling): show complete frames even if a later frame fails.
+    if (failed())
+        return false;
+    if (index >= m_frameBufferCache.size())
+        return false;
+    if (index == 0)
+        return ImageDecoder::frameIsCompleteAtIndex(index);
+    return true;
+}
+
+float PNGImageDecoder::frameDurationAtIndex(size_t index) const
+{
+    return (index < m_frameBufferCache.size() ? 
+                m_frameBufferCache[index].duration() : 0);
+}
+
 void PNGImageDecoder::complete()
 {
     if (m_frameBufferCache.isEmpty())
         return;
-
-    m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete);
-}
-
-inline bool isComplete(const PNGImageDecoder* decoder)
-{
-    return decoder->frameIsCompleteAtIndex(0);
-}
-
-void PNGImageDecoder::decode(bool onlySize)
-{
-    if (failed())
-        return;
-
-    if (!m_reader)
-        m_reader = wrapUnique(new PNGImageReader(this, m_offset));
-
-    // If we couldn't decode the image but have received all the data, decoding
-    // 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.reset();
+    m_frameBufferCache[m_currentFrame].setStatus(ImageFrame::FrameComplete);
 }
 
 } // namespace blink