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)
+    , m_decodedFrameCount(false)

[scroggo_chromium, 2016/10/25 14:59:05]

This variable is never read.

 {
 }
 
 PNGImageDecoder::~PNGImageDecoder()
 {
 }
 
+size_t PNGImageDecoder::decodeFrameCount()
+{
+    m_decodedFrameCount = true;
+    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_repititionCount to match other browsers.

[scroggo_chromium, 2016/10/25 14:59:06]

nit: m_repetitionCount

+// 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
+inline ImageFrame::DisposalMethod getDisposalMethod(uint8_t disposalMethod)

[scroggo_chromium, 2016/10/25 14:59:06]

nit: These inline methods should also be static (or in a namespace).

+{
+    switch (disposalMethod) {
+        case 0:

[scroggo_chromium, 2016/10/25 14:59:06]

I *think* this should line up with switch - pretty sure I've seen that elsewhere
in Blink, but I didn't see anything in the style guide. I'd say look for switch
statements in the surrounding code and match that.

[joostouwerling, 2016/10/26 15:44:16]

ImageDecoder.cpp and GIFImageDecoder.cpp both indent case statements.

+            return ImageFrame::DisposalMethod::DisposeKeep;
+        case 1:
+            return ImageFrame::DisposalMethod::DisposeOverwriteBgcolor;
+        case 2:
+            return ImageFrame::DisposalMethod::DisposeOverwritePrevious;

[scroggo_chromium, 2016/10/25 14:59:06]

There should be a default case here.

+    }
+    return ImageFrame::DisposalMethod::DisposeNotSpecified;

[scroggo_chromium, 2016/10/25 14:59:06]

Personally, I find it odd that we distinguish between DisposeNotSpecified and
DisposeKeep, since we appear to treat them the same. But this is how we do it in
GIF as well.

+}
+
+
+// These are mapped according to:
+// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+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.

[scroggo_chromium, 2016/10/25 14:59:06]

I assume this statement is no longer true?

-        buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
+        buffer.zeroFillPixelData();

[scroggo_chromium, 2016/10/25 14:59:06]

I assume we used to do this elsewhere? Can we remove a different call?

[joostouwerling, 2016/10/26 15:44:16]

This call will be superfluous when blending and disposing is applied. For now, I
used it as an insurance that I was working with a fully transparent black frame.

     }
+    const IntRect& rect = buffer.originalFrameRect();

[scroggo_chromium, 2016/10/25 14:59:06]

I suggest calling this frameRect. That makes a little clearer, several lines
below, when you refer to it again.

 
     /* 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;
+    int y = rowIndex + rect.y();

[scroggo_chromium, 2016/10/25 14:59:06]

Has the frameRect already been intersected with the image size? i.e. can
frameRect.y() be negative?

[joostouwerling, 2016/10/26 15:44:16]

Yes, intersection happens in initializeNewFrame(), which is called when the
frame count changes. This also answers the comments below. In this case, the row
index that is provided to the PNG callback in PNGImageReader is an png_uint_32,
so |y| can never be negative. However, the int-type is the best option here
since the comparison to size().height(), which returns an int, does not compile
with a size_t. The same holds for the |x|-values in the loops below. Another
option would be to cast the size().height() to a size_t but I don't think that's
better.

The check for |y| < 0 could be to detect overflow but I'm not sure if that is a
realistic scenario.

[scroggo_chromium, 2016/10/26 18:25:58]

Ok good. No need to check for y < 0. My concern was about rect.y() being
negative. If it's not, this will never be negative.

     if (y < 0 || y >= size().height())
         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
@@ skipping 20 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(rect.x(), y);

[scroggo_chromium, 2016/10/25 14:59:06]

Again, I could imagine that the frameRect has not been intersected with the
size, so x() could be negative.

     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 = rect.x(); x < rect.maxX(); ++x, pixel += 4) {

[scroggo_chromium, 2016/10/25 14:59:06]

Similarly, we need to make sure we do not go beyond the width of the image.

                 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 = rect.x(); x < rect.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 = rect.x(); x < rect.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
+{
+    if (failed())

[scroggo_chromium, 2016/10/25 14:59:06]

Maybe add a TODO here, regarding being able to show complete frames even if a
later frame fails.

+        return false;
+    if (index >= m_frameBufferCache.size())
+        return false;
+    if (index == 0)
+        return ImageDecoder::frameIsCompleteAtIndex(index);

[scroggo_chromium, 2016/10/25 14:59:05]

This is probably the right thing to do if it's non-animated, but for an animated
image, I think you want to know whether we've received all the data for this
frame - not whether we've fully decoded it.

(I'm on the record for disliking this method - it means different things
depending on whether it is an animated image versus a non-animated image. Sort
of ... GIF treats it the same for animated versus non-animated, but WEBP treats
them differently. ICO also uses what I think of as the animated version (is all
data received)).

[joostouwerling, 2016/10/26 15:44:16]

If GIF is able to get away (that is, since a decoded frame is a step further
down the road than having received all data) with returning true when it has
just received all data, for non-animated GIF's, does that not imply that is all
the client needs to know? As far as I can see in the call hierarchy of
frameIsCompleteAtIndex() it never depends on actually having decoded the frame
data. But I may be wrong in this since the call hierarchy is pretty deep and it
is used in several local variables, so please correct me if I'm wrong.

[scroggo_chromium, 2016/11/29 16:30:51]

Revisiting this because your test (VerifyFrameCompleteBehavior) checks that the
first frame only reports that it is complete when it is fully decoded, but I do
not think that's the right behavior, and your comment sounds like you agree:

On 2016/10/26 15:44:16, joostouwerling wrote:
I agree that this is all the client needs to know. But ImageDecoder's
implementation, which you call here, returns something else - whether it is
fully decoded.
No, I think you are correct.

FWIW, WEBPImageDecoder::frameIsCompleteAtIndex returns
ImageDecoder::frameIsCompleteAtIndex iff the image is not animated. This is
different from GIF and ICO, so I think you could go either way for a
non-animated PNG, but I do think it's more correct to return whether the (only)
frame is fully received. (It matches the comment [1], if not the name.
DeferredImageDecoder also queries m_actualDecoder [2], which is only used for
parsing, so it will never return true using the base class implementation. There
was a CL to correct the confusion in [3], but the author stopped working on it
and it never got submitted.)

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/image...
[2]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/graph...
[3] crrev.com/1962563002

+    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