WIP: Implement APNG

third_party/WebKit/Source/platform/image-decoders/png/PNGImageReader.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
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Alternatively, the contents of this file may be used under the terms
+ * of either the Mozilla Public License Version 1.1, found at
+ * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
+ * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
+ * (the "GPL"), in which case the provisions of the MPL or the GPL are
+ * applicable instead of those above.  If you wish to allow use of your
+ * version of this file only under the terms of one of those two
+ * 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/PNGImageReader.h"
+
+#include "platform/image-decoders/png/PNGImageDecoder.h"
+#include "platform/image-decoders/FastSharedBufferReader.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 err)
+{
+    longjmp(JMPBUF(png), 1);
+}
+
+} // namespace
+
+namespace blink {
+
+// This is the callback function for unknown PNG chunks, which is used to
+// extract the animation chunks.
+static int readAnimationChunk(png_structp png_ptr, png_unknown_chunkp chunk)
+{
+    PNGImageReader* reader = (PNGImageReader*) png_get_user_chunk_ptr(png_ptr);
+    reader->parseAnimationChunk((const char*) chunk->name, chunk->data,
+                                chunk->size);
+    return 1;
+}
+
+PNGImageReader::PNGImageReader(PNGImageDecoder* decoder, size_t initialOffset)
+    : m_decoder(decoder)
+    , m_initialOffset(initialOffset)
+    , m_readOffset(initialOffset)
+    , m_progressiveDecodeOffset(0)
+    , m_idatOffset(0)
+    , m_hasAlpha(false)
+    , m_idatIsPartOfAnimation(false)
+    , m_isAnimated(false)
+    , m_parsedSignature(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);
+
+    // Keep the chunks which are of interest for APNG. We don't need to keep
+    // the fdAT chunks, since they are converted to IDAT's by the frame decoder.
+    png_byte apngChunks[] = {"acTL\0fcTL\0"};
+    png_set_keep_unknown_chunks(m_png, PNG_HANDLE_CHUNK_NEVER, apngChunks, 2);
+    png_set_read_user_chunk_fn(m_png, (png_voidp) this, readAnimationChunk);
+}
+
+PNGImageReader::~PNGImageReader()
+{
+    png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
+    ASSERT(!m_png && !m_info);
+}
+
+// This method reads from the FastSharedBufferReader, starting at offset,
+// and returns |length| bytes in the form of a pointer to a const png_byte*.
+// This function is used to make it easy to access data from the reader in a
+// png friendly way, and pass it to libpng for decoding.
+//
+// Pre-conditions before using this:
+// - |reader|.size() >= |readOffset| + |length|
+// - |buffer|.size() >= |length|
+// - |length| <= |kBufferSize|
+//
+// The reason for the last two precondition is that currently the png signature
+// plus IHDR chunk (8B + 25B = 33B) is the largest chunk that is read using this
+// method. If the data is not consecutive, it is stored in |buffer|, which must
+// have the size of (at least) |length|, but there's no need for it to be larger
+// than |kBufferSize|.
+static constexpr size_t kBufferSize = 33;
+const png_byte* readAsConstPngBytep(const FastSharedBufferReader& reader,
+                                    size_t readOffset, size_t length,
+                                    char* buffer)
+{
+    ASSERT(length <= kBufferSize);
+    return reinterpret_cast<const png_byte*>(
+            reader.getConsecutiveData(readOffset, length, buffer));
+}
+
+// This is used as a value for the byteLength of a frameInfo struct to
+// indicate that it is the first frame, and we still need to set byteLength
+// to the correct value as soon as the parser knows it. 1 is a safe value
+// since the byteLength field of a frame is at least 12, in the case of an
+// empty fdAT or IDAT chunk.
+static constexpr size_t kFirstFrameIndicator = 1;
+
+void PNGImageReader::decode(SegmentReader& data, size_t index)
+{
+    if (index >= m_frameInfo.size())
+        return;
+
+    // When decoding by libpng fails in either the non-animated branch or the
+    // animated branch, the decoder needs to be set to the failed state.
+    if (setjmp(JMPBUF(m_png))) {
+        m_decoder->setFailed();
+        return;
+    }
+    
+    // For non animated PNGs, resume decoding where we left off in parse(), at
+    // the beginning of the IDAT chunk. Recreating a png struct would either
+    // result in wasted work, by reprocessing all header bytes, or decoding the
+    // wrong data.
+    if (!m_isAnimated) {
+        m_progressiveDecodeOffset += processData(
+            data, m_frameInfo[0].readOffset + m_progressiveDecodeOffset, 0);
+        return;
+    }
+
+    // Progressive decoding is only done if both of the following are true:
+    // - It is the first frame, thus |index| == 0, AND
+    // - The byteLength of the first frame is not yet known, *or* it is known
+    //   but we're only partway in a progressive decode, started earlier.
+    bool firstFrameLengthKnown = m_frameInfo[0].byteLength
+                                        != kFirstFrameIndicator;
+    bool progressiveDecodingAlreadyStarted = m_progressiveDecodeOffset > 0;
+    bool progressiveDecode = (index == 0
+            && (!firstFrameLengthKnown || progressiveDecodingAlreadyStarted));
+    
+    // Initialize a new png struct for this frame. For a progressive decode of
+    // the first frame, we only need to do this once.
+    if (!progressiveDecode || !progressiveDecodingAlreadyStarted)
+        startFrameDecoding(data, index);
+    
+    bool decodedFrameCompletely;
+    if (progressiveDecode) {
+        decodedFrameCompletely = progressivelyDecodeFirstFrame(data);
+        // If progressive decoding processed all data for this frame, reset
+        // |m_progressiveDecodeOffset|, so |progressiveDecodingAlreadyStarted|
+        // will be false for later calls to decode frame 0.
+        if (decodedFrameCompletely)
+            m_progressiveDecodeOffset = 0;
+    } else {
+        decodeFrame(data, index);
+        // For a non-progressive decode, we already have all the data we are
+        // going to get, so consider the frame complete.
+        decodedFrameCompletely = true;
+    }
+    
+    // Send the IEND chunk if the frame is completely decoded, so the complete
+    // callback in |m_decoder| will be called.
+    if (decodedFrameCompletely)
+        endFrameDecoding();
+}
+
+void PNGImageReader::startFrameDecoding(SegmentReader& data, size_t index)
+{
+    // Each frame is processed as if it were a complete, single frame png image.
+    // To accomplish this, destroy the current |m_png| and |m_info| structs and
+    // create new ones. CRC errors are ignored, so fdAT chunks can be processed
+    // as IDATs without recalculating the CRC value. 
+    png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
+    m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0);
+    m_info = png_create_info_struct(m_png);
+    png_set_crc_action(m_png, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
+    png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable,
+                                pngRowAvailable, pngComplete);
+   
+    // If the frame is the size of the whole image, we don't need to modify any
+    // data in the IHDR chunk. This means it suffices to re-process all header
+    // data up to the first frame, for mimicking a png image.
+    const IntRect& frameRect = m_frameInfo[index].frameRect;
+    if (frameRect.location() == IntPoint()
+        && frameRect.size() == m_decoder->size()) {
+        processData(data, m_initialOffset, m_idatOffset); 
+        return;
+    }
+
+    // Process the IHDR chunk, but change the width and height so it reflects
+    // the frame's width and height. Image Decoder will apply the x,y offset.
+    // This step is omitted if the width and height are equal to the image size,
+    // which is done in the block above.
+    FastSharedBufferReader reader(&data);
+    char readBuffer[kBufferSize];
+
+    // |headerSize| is equal to |kBufferSize|, but adds more semantic insight.
+    constexpr size_t headerSize = 33;
+    png_byte header[headerSize];
+    const png_byte* chunk = readAsConstPngBytep(reader, m_initialOffset,
+                                                headerSize, readBuffer);
+    memcpy(header, chunk, headerSize);
+    
+    // Write the unclipped width and height. Clipping happens in the decoder.
+    png_save_uint_32(header + 16, frameRect.width());
+    png_save_uint_32(header + 20, frameRect.height());
+    png_process_data(m_png, m_info, header, headerSize);
+
+    // Process the rest of the header chunks. Start after the PNG signature and
+    // IHDR chunk, 33B, and process up to the first data chunk. The number of 
+    // bytes up to the first data chunk is stored in |m_idatOffset|.
+    processData(data, m_initialOffset + headerSize, m_idatOffset - headerSize);
+}
+
+bool PNGImageReader::progressivelyDecodeFirstFrame(SegmentReader& data)
+{
+    FastSharedBufferReader reader(&data);
+    char readBuffer[8]; // large enough to identify a chunk.
+    size_t offset = m_frameInfo[0].readOffset;
+
+    // Loop while there is enough data to do progressive decoding.
+    while (data.size() >= offset + 8) {
+
+        // At the beginning of each loop, the offset is at the start of a chunk.
+        const png_byte* chunk = readAsConstPngBytep(reader, offset, 8,
+                                                    readBuffer);
+        const png_uint_32 length = png_get_uint_32(chunk);
+
+        // When an fcTL or IEND chunk is encountered, the frame data has ended.
+        // Return true, since all frame data is decoded.
+        if (memcmp(chunk, "fcTL", 4) == 0 || memcmp(chunk, "IEND", 0))
+            return true;
+        
+        // If this chunk was already decoded, move on to the next.
+        if (m_progressiveDecodeOffset >= offset + length + 12) {
+            offset += length + 12;
+            continue;
+        }
+
+        // At this point, three scenarios are possible:
+        // 1) Some bytes of this chunk were already decoded in a previous call,
+        //    so we need to continue from there.
+        // 2) This is an fdAT chunk, so we need to convert it to an IDAT chunk
+        //    before we can decode it.
+        // 3) This is any other chunk, most likely an IDAT chunk.
+        //
+        // In each scenario, we want to decode as much data as possible. In each
+        // one, do the scenario specific work and set |offset| to where decoding
+        // needs to continue. From there, decode until the end of the chunk, if
+        // possible. If the whole chunk is decoded, continue to the next loop.
+        // Otherwise, store how far we've came in |m_progressiveDecodeOffset| and return

[scroggo_chromium, 2016/10/31 13:35:12]

we've come*

[joostouwerling, 2016/10/31 18:40:19]

Done.

+        // false to indicate to the caller that the frame is partially decoded.
+
+        size_t endOffsetChunk = offset + length + 12;
+
+        // Scenario 1: |m_progressiveDecodeOffset| is ahead of the chunk tag.
+        if (m_progressiveDecodeOffset >= offset + 8) {
+            offset = m_progressiveDecodeOffset;
+        
+        // Scenario 2: we need to convert the fdAT to an IDAT chunk. For an
+        // explanation of the numbers, see the comments in decodeFrame().
+        } else if (memcmp(chunk, "fdAT", 4) == 0) {
+            png_byte chunkIDAT[] = {0, 0, 0, 0, 'I', 'D', 'A', 'T'};
+            png_save_uint_32(chunkIDAT, length - 4);
+            png_process_data(m_png, m_info, chunkIDAT, 8);
+            // Skip the sequence number
+            offset += 12;
+        
+        // Scenario 3: for any other chunk type, process the first 8 bytes.
+        } else {
+            png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
+            offset += 8;
+        }
+
+        size_t bytesLeftInChunk = endOffsetChunk - offset;
+        size_t bytesDecoded = processData(data, offset, bytesLeftInChunk);
+        m_progressiveDecodeOffset = offset + bytesDecoded;
+        if (bytesDecoded < bytesLeftInChunk)
+            return false;
+        offset += bytesDecoded;
+    }        
+
+    return false;
+}
+
+void PNGImageReader::decodeFrame(SegmentReader& data, size_t index)
+{
+    // From the frame info that was gathered during parsing, it is known at
+    // what offset the frame data starts and how many bytes are in the stream
+    // before the frame ends. Using this, we process all chunks that fall in
+    // this interval. We catch every fdAT chunk and transform it to an IDAT
+    // chunk, so libpng will decode it like a non-animated PNG image.
+    size_t offset = m_frameInfo[index].readOffset;
+    size_t endOffset = offset + m_frameInfo[index].byteLength;
+    char readBuffer[8];
+    FastSharedBufferReader reader(&data);
+
+    while (offset < endOffset) {
+        const png_byte* chunk = readAsConstPngBytep(reader, offset, 8, readBuffer);
+        const png_uint_32 length = png_get_uint_32(chunk);
+        if (memcmp(chunk + 4, "fdAT", 4) == 0) {
+            // An fdAT chunk is build up as follows: 
+            // - |length| (4B)
+            // - fdAT tag (4B)
+            // - sequence number (4B) 
+            // - frame data (|length| - 4B)
+            // - CRC (4B)
+            // Thus, to reformat this into an IDAT chunk, we need to:
+            // - write |length| - 4 as the new length, since the sequence number
+            //   must be removed.
+            // - change the tag to IDAT.
+            // - omit the sequence number from the data part of the chunk.
+            png_byte chunkIDAT[] = {0, 0, 0, 0, 'I', 'D', 'A', 'T'};
+            png_save_uint_32(chunkIDAT, length - 4);
+            png_process_data(m_png, m_info, chunkIDAT, 8);
+            // The frame data and the CRC span |length| bytes, so skip the
+            // sequence number and process |length| bytes to decode the frame.
+            processData(data, offset + 12, length);
+        } else {
+            png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
+            processData(data, offset + 8, length + 4);
+        }
+        offset += 12 + length; 
+    }
+}
+
+void PNGImageReader::endFrameDecoding()
+{
+    png_byte IEND[12] = {0, 0, 0, 0, 'I', 'E', 'N', 'D', 174, 66, 96, 130};
+    png_process_data(m_png, m_info, IEND, 12);
+}
+
+bool PNGImageReader::parse(SegmentReader& data,
+                           PNGImageDecoder::PNGParseQuery query)
+{
+    if (setjmp(JMPBUF(m_png)))
+        return m_decoder->setFailed();
+
+    // If the size has not been parsed, do that first, since it's necessary
+    // for both the Size and MetaData query. If parseSize returns false,
+    // it failed because of a lack of data so we can return false at this point.
+    if (!m_decoder->isDecodedSizeAvailable() && !parseSize(data))
+        return false;
+    
+    if (query == PNGImageDecoder::PNGParseQuery::PNGSizeQuery)
+        return m_decoder->isDecodedSizeAvailable();
+    
+    // For non animated images (identified by no acTL chunk before the IDAT), 
+    // we create one frame. This saves some processing time since we don't need
+    // to go over the stream to find chunks.
+    if (!m_isAnimated) {
+        if (m_frameInfo.isEmpty()) {
+            FrameInfo frame;
+            // This needs to be plus 8 since the first 8 bytes of the IDAT chunk
+            // are already processed in parseSize().
+            frame.readOffset = m_readOffset + 8;
+            frame.frameRect = IntRect(IntPoint(), m_decoder->size());
+            frame.duration = 0;
+            frame.alphaBlend = ImageFrame::AlphaBlendSource::BlendAtopBgcolor;
+            frame.disposalMethod = ImageFrame::DisposalMethod::DisposeNotSpecified;
+            m_frameInfo.append(frame);
+            m_decoder->setMetaDataDecoded();
+        }
+        return true;
+    }
+
+    FastSharedBufferReader reader(&data);
+    char readBuffer[kBufferSize];
+
+    // At this point, the query is FrameMetaDataQuery. Loop over the data and
+    // register all frames we can find. A frame is registered on the next fcTL
+    // chunk or when the IEND chunk is found. This ensures that only complete
+    // frames are reported, unless there is an error in the stream.
+    while (reader.size() >= m_readOffset + 8) {
+        const png_byte* chunk = readAsConstPngBytep(reader, m_readOffset, 8,
+                                                    readBuffer);
+        const size_t length = png_get_uint_32(chunk);
+        const bool isFCTLChunk = memcmp(chunk + 4, "fcTL", 4) == 0;
+        const bool isIENDChunk = memcmp(chunk + 4, "IEND", 4) == 0;
+        
+        // When we find an IDAT chunk (when the IDAT is part of the animation),
+        // or an fdAT chunk, and the readOffset field of the newFrame is 0,
+        // we have found the beginning of a new block of frame data.
+        const bool isFrameData = memcmp(chunk + 4, "fdAT", 4) == 0
+            || (memcmp(chunk + 4, "IDAT", 4) == 0 && m_idatIsPartOfAnimation);
+        if (m_newFrame.readOffset == 0 && isFrameData) {
+            m_newFrame.readOffset = m_readOffset;
+            
+            // When the |frameInfo| vector is empty, the first frame needs to be
+            // reported as soon as possible, even before all frame data is in
+            // |data|, so the first frame can be decoded progressively. 
+            if (m_frameInfo.isEmpty()) {
+                m_newFrame.byteLength = kFirstFrameIndicator;
+                m_frameInfo.append(m_newFrame); 
+            }
+
+        // An fcTL or IEND marks the end of the previous frame. Thus, the
+        // FrameInfo data in m_newFrame is submitted to the m_frameInfo vector.
+        //
+        // Furthermore, an fcTL chunk indicates a new frame is coming,
+        // so the m_newFrame variable is prepared accordingly by setting the 
+        // readOffset field to 0, which indicates that the frame control info
+        // is available but that we haven't seen any frame data yet.
+        } else if (isFCTLChunk || isIENDChunk) {
+            if (m_newFrame.readOffset != 0) {
+                m_newFrame.byteLength = m_readOffset - m_newFrame.readOffset;
+                if (m_frameInfo[0].byteLength == kFirstFrameIndicator)
+                    m_frameInfo[0].byteLength = m_newFrame.byteLength;
+                else
+                    m_frameInfo.append(m_newFrame);
+
+                m_newFrame.readOffset = 0;
+            }
+
+            if (reader.size() < m_readOffset + 12 + length)
+                return false;
+            
+            if (isIENDChunk) {
+                // Let the decoder know we've parsed all data, so it does not 
+                // need to query again.
+                m_decoder->setMetaDataDecoded();
+                return true;
+            }
+
+            // At this point, we're dealing with an fcTL chunk, since the above
+            // statement already returns on IEND chunks.
+            
+            // If the fcTL chunk is not 26 bytes long, we can't process it.
+            if (length != 26)
+                return m_decoder->setFailed();
+
+            chunk = readAsConstPngBytep(reader, m_readOffset + 8, length,
+                                        readBuffer);
+            parseFrameInfo(chunk);
+
+        }
+        m_readOffset += 12 + length;
+    }
+    return false; 
+}
+
+// If |length| == 0, read until the stream ends.
+// @return: number of bytes processed.
+size_t PNGImageReader::processData(SegmentReader& data, size_t offset,
+                                   size_t length)
+{
+    const char* segment;
+    size_t totalProcessedBytes = 0;
+    while (size_t segmentLength = data.getSomeData(segment, offset)) {
+        if (length > 0 && segmentLength + totalProcessedBytes > length)
+            segmentLength = length - totalProcessedBytes;
+        png_process_data(m_png, m_info,
+                         reinterpret_cast<png_byte*>(const_cast<char*>(segment)),
+                         segmentLength);
+        offset += segmentLength;
+        totalProcessedBytes += segmentLength;
+        if (totalProcessedBytes == length)
+            return length;
+    }
+    return totalProcessedBytes;
+}
+
+// This methods reads through the stream until it has parsed the image size.
+// @return true when it succeeds in parsing the size.
+//         false when:
+//         A) not enough data is provided
+//         B) decoding by libpng fails. In the this case, it will also call
+//            setFailed on m_decoder. 
+bool PNGImageReader::parseSize(SegmentReader &data)
+{
+    FastSharedBufferReader reader(&data);
+    char readBuffer[kBufferSize];
+
+    // Process the PNG signature and the IHDR with libpng, such that this code 
+    // does not need to be bothered with parsing the contents. This also enables
+    // the reader to use the existing headerAvailable callback in the decoder.
+    //
+    // When we already have decoded the signature, we don't need to do it again.
+    // By setting a flag for this we allow for byte by byte parsing.
+    if (!m_parsedSignature) {
+        if (reader.size() < m_readOffset + 8)
+            return false;
+        const png_byte* chunk = readAsConstPngBytep(reader, m_readOffset, 8,
+                                                    readBuffer);
+        png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
+        m_readOffset += 8;
+        m_parsedSignature = true;
+        // Initialize the newFrame by setting the readOffset to 0.
+        m_newFrame.readOffset = 0;
+    }
+
+    // This loop peeks at the chunk tag until the IDAT chunk is found. When
+    // a different tag is encountered, pass it on to libpng for general parsing.
+    // We can peek at chunks by looking at the first 8 bytes, which contain the
+    // length and the chunk tag.
+    //
+    // When an fcTL (frame control) is encountered before the IDAT, the frame
+    // data in the IDAT chunk is part of the animation. This case is flagged
+    // and the frame info is stored by parsing the fcTL chunk.
+    while (reader.size() >= m_readOffset + 8) {
+        const png_byte* chunk = readAsConstPngBytep(reader, m_readOffset, 8,
+                                                    readBuffer);
+        const png_uint_32 length = png_get_uint_32(chunk);
+
+        // If we encounter the IDAT chunk, we're done with the png header
+        // chunks. Indicate this to libpng by sending the beginning of the IDAT
+        // chunk, which will trigger libpng to call the headerAvailable
+        // callback on m_decoder. This provides the size to the decoder.
+        if (memcmp(chunk + 4, "IDAT", 4) == 0) {
+            m_idatOffset = m_readOffset;
+            png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
+            return true;
+        }
+
+        // Consider the PNG image animated if an acTL chunk of the correct
+        // length is present. Parsing the acTL content is done by 
+        // parseAnimationControl, called by libpng's png_process_data.
+        if (memcmp(chunk + 4, "acTL", 4) == 0 && length == 8)
+            m_isAnimated = true;
+
+        // We don't need to check for |length| here, because the decoder will
+        // fail later on for invalid fcTL chunks.
+        if (memcmp(chunk + 4, "fcTL", 4) == 0)
+            m_idatIsPartOfAnimation = true;
+        
+        // 12 is the length, tag and crc part of the chunk, which are all 4B.
+        if (reader.size() < m_readOffset + length + 12)
+            break;  
+
+        png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
+        processData(data, m_readOffset + 8, length + 4);
+        m_readOffset += length + 12;
+    }
+
+    // If we end up here, not enough data was available for the IDAT chunk
+    // So libpng would not have called headerAvailable yet.
+    return false;
+} 
+
+
+void PNGImageReader::parseAnimationChunk(const char tag[], const void* data_chunk, size_t length)
+{
+    const png_byte* data = static_cast<const png_byte*>(data_chunk);
+
+    // The number of frames as indicated in the animation control chunk (acTL) 
+    // is ignored, and the number of frames that are actually present is used.
+    // For now, when the number of indicated frames is different from the
+    // number of supplied frames, the number of supplied frames is what is
+    // provided to the decoder. Therefore, it does not add any benefit of
+    // looking at the value of the indicated framecount. A note here is that
+    // there may be optimisations available, for example, prescaling vectors.
+    if (strcmp(tag, "acTL") == 0 && length == 8) {
+        png_uint_32 repetitionCount = png_get_uint_32(data + 4);
+        m_decoder->setRepetitionCount(repetitionCount);
+    
+    // For fcTL, decoding fails if it does not have the correct length. It is
+    // impossible to make a guess about the frame if not all data is available.
+    // Use longjmp to get back to parse(), which is necessary since this method
+    // is called by a libpng callback.
+    } else if (strcmp(tag, "fcTL") == 0) {
+        if (length != 26)
+            longjmp(JMPBUF(m_png), 1);
+        parseFrameInfo(data);
+    }
+
+}
+
+size_t PNGImageReader::frameCount() const
+{
+    return m_frameInfo.size();
+}
+
+const PNGImageReader::FrameInfo& PNGImageReader::frameInfo(size_t index) const
+{
+    ASSERT(index < m_frameInfo.size());
+    return m_frameInfo[index];
+}
+
+// Extract the frame control info and store it in m_newFrame. The length check
+// on the data chunk has been done in parseAnimationChunk.
+// The fcTL specification used can be found at:
+// https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chunk
+void PNGImageReader::parseFrameInfo(const png_byte* data)
+{
+    png_uint_32 width, height, xOffset, yOffset;
+    png_uint_16 delayNumerator, delayDenominator;
+    width               = png_get_uint_32(data + 4);
+    height              = png_get_uint_32(data + 8);
+    xOffset             = png_get_uint_32(data + 12);
+    yOffset             = png_get_uint_32(data + 16);
+    delayNumerator      = png_get_uint_16(data + 20);
+    delayDenominator    = png_get_uint_16(data + 22);
+
+    m_newFrame.duration         = (delayDenominator == 0) ? delayNumerator * 10
+                                    : delayNumerator * 1000 / delayDenominator;
+    m_newFrame.frameRect        = IntRect(xOffset, yOffset, width, height);
+    m_newFrame.disposalMethod   = data[24];
+    m_newFrame.alphaBlend       = data[25];
+    
+}
+
+}; // namespace blink