17c570766efee41930167623cfa157c9ecb1df9b
[WebKit-https.git] / Source / WebCore / platform / image-decoders / png / PNGImageDecoder.cpp
1 /*
2  * Copyright (C) 2006 Apple Inc.
3  * Copyright (C) 2007-2009 Torch Mobile, Inc.
4  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
5  *
6  * Portions are Copyright (C) 2001 mozilla.org
7  *
8  * Other contributors:
9  *   Stuart Parmenter <stuart@mozilla.com>
10  *   Max Stepin <maxstepin@gmail.com>
11  *
12  * This library is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * This library is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with this library; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
25  *
26  * Alternatively, the contents of this file may be used under the terms
27  * of either the Mozilla Public License Version 1.1, found at
28  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
29  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
30  * (the "GPL"), in which case the provisions of the MPL or the GPL are
31  * applicable instead of those above.  If you wish to allow use of your
32  * version of this file only under the terms of one of those two
33  * licenses (the MPL or the GPL) and not to allow others to use your
34  * version of this file under the LGPL, indicate your decision by
35  * deletingthe provisions above and replace them with the notice and
36  * other provisions required by the MPL or the GPL, as the case may be.
37  * If you do not delete the provisions above, a recipient may use your
38  * version of this file under any of the LGPL, the MPL or the GPL.
39  */
40
41 #include "config.h"
42 #include "PNGImageDecoder.h"
43
44 #include "Color.h"
45 #include <png.h>
46 #include <wtf/StdLibExtras.h>
47
48 #if defined(PNG_LIBPNG_VER_MAJOR) && defined(PNG_LIBPNG_VER_MINOR) && (PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 4))
49 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
50 #else
51 #define JMPBUF(png_ptr) png_ptr->jmpbuf
52 #endif
53
54 namespace WebCore {
55
56 // Gamma constants.
57 const double cMaxGamma = 21474.83;
58 const double cDefaultGamma = 2.2;
59 const double cInverseGamma = 0.45455;
60
61 // Protect against large PNGs. See Mozilla's bug #251381 for more info.
62 const unsigned long cMaxPNGSize = 1000000UL;
63
64 // Called if the decoding of the image fails.
65 static void PNGAPI decodingFailed(png_structp png, png_const_charp)
66 {
67     longjmp(JMPBUF(png), 1);
68 }
69
70 // Callbacks given to the read struct.  The first is for warnings (we want to
71 // treat a particular warning as an error, which is why we have to register this
72 // callback).
73 static void PNGAPI decodingWarning(png_structp png, png_const_charp warningMsg)
74 {
75     // Mozilla did this, so we will too.
76     // Convert a tRNS warning to be an error (see
77     // http://bugzilla.mozilla.org/show_bug.cgi?id=251381 )
78     if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24))
79         png_error(png, warningMsg);
80 }
81
82 // Called when we have obtained the header information (including the size).
83 static void PNGAPI headerAvailable(png_structp png, png_infop)
84 {
85     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable();
86 }
87
88 // Called when a row is ready.
89 static void PNGAPI rowAvailable(png_structp png, png_bytep rowBuffer, png_uint_32 rowIndex, int interlacePass)
90 {
91     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->rowAvailable(rowBuffer, rowIndex, interlacePass);
92 }
93
94 // Called when we have completely finished decoding the image.
95 static void PNGAPI pngComplete(png_structp png, png_infop)
96 {
97     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete();
98 }
99
100 #if ENABLE(APNG)
101 // Called when we have the frame header.
102 static void PNGAPI frameHeader(png_structp png, png_infop)
103 {
104     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->frameHeader();
105 }
106
107 // Called when we found user chunks.
108 static int PNGAPI readChunks(png_structp png, png_unknown_chunkp chunk)
109 {
110     static_cast<PNGImageDecoder*>(png_get_user_chunk_ptr(png))->readChunks(chunk);
111     return 1;
112 }
113 #endif
114
115 class PNGImageReader {
116     WTF_MAKE_FAST_ALLOCATED;
117 public:
118     PNGImageReader(PNGImageDecoder* decoder)
119         : m_readOffset(0)
120         , m_currentBufferSize(0)
121         , m_decodingSizeOnly(false)
122         , m_hasAlpha(false)
123         , m_interlaceBuffer(0)
124     {
125         m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, decodingFailed, decodingWarning);
126         m_info = png_create_info_struct(m_png);
127         png_set_progressive_read_fn(m_png, decoder, headerAvailable, rowAvailable, pngComplete);
128 #if ENABLE(APNG)
129         png_byte apngChunks[]= {"acTL\0fcTL\0fdAT\0"};
130         png_set_keep_unknown_chunks(m_png, 1, apngChunks, 3);
131         png_set_read_user_chunk_fn(m_png, static_cast<png_voidp>(decoder), readChunks);
132         decoder->init();
133 #endif
134     }
135
136     ~PNGImageReader()
137     {
138         close();
139     }
140
141     void close()
142     {
143         if (m_png && m_info)
144             // This will zero the pointers.
145             png_destroy_read_struct(&m_png, &m_info, 0);
146         delete[] m_interlaceBuffer;
147         m_interlaceBuffer = 0;
148         m_readOffset = 0;
149     }
150
151     bool decode(const SharedBuffer& data, bool sizeOnly, unsigned haltAtFrame)
152     {
153         m_decodingSizeOnly = sizeOnly;
154         PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));
155
156         // We need to do the setjmp here. Otherwise bad things will happen.
157         if (setjmp(JMPBUF(m_png)))
158             return decoder->setFailed();
159
160         auto bytesToSkip = m_readOffset;
161         for (const auto& segment : data) {
162             if (bytesToSkip > segment->size()) {
163                 bytesToSkip -= segment->size();
164                 continue;
165             }
166             auto bytesToUse = segment->size() - bytesToSkip;
167             m_readOffset += bytesToUse;
168             m_currentBufferSize = m_readOffset;
169             png_process_data(m_png, m_info, reinterpret_cast<png_bytep>(const_cast<char*>(segment->data() + bytesToSkip)), bytesToUse);
170             bytesToSkip = 0;
171             // We explicitly specify the superclass encodedDataStatus() because we
172             // merely want to check if we've managed to set the size, not
173             // (recursively) trigger additional decoding if we haven't.
174             if (sizeOnly ? decoder->ImageDecoder::encodedDataStatus() >= EncodedDataStatus::SizeAvailable : decoder->isCompleteAtIndex(haltAtFrame))
175                 return true;
176         }
177         return false;
178     }
179
180     png_structp pngPtr() const { return m_png; }
181     png_infop infoPtr() const { return m_info; }
182
183     void setReadOffset(unsigned offset) { m_readOffset = offset; }
184     unsigned currentBufferSize() const { return m_currentBufferSize; }
185     bool decodingSizeOnly() const { return m_decodingSizeOnly; }
186     void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
187     bool hasAlpha() const { return m_hasAlpha; }
188
189     png_bytep interlaceBuffer() const { return m_interlaceBuffer; }
190     void createInterlaceBuffer(int size) { m_interlaceBuffer = new png_byte[size]; }
191
192 private:
193     png_structp m_png;
194     png_infop m_info;
195     unsigned m_readOffset;
196     unsigned m_currentBufferSize;
197     bool m_decodingSizeOnly;
198     bool m_hasAlpha;
199     png_bytep m_interlaceBuffer;
200 };
201
202 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption gammaAndColorProfileOption)
203     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
204     , m_doNothingOnFailure(false)
205     , m_currentFrame(0)
206 #if ENABLE(APNG)
207     , m_png(nullptr)
208     , m_info(nullptr)
209     , m_isAnimated(false)
210     , m_frameInfo(false)
211     , m_frameIsHidden(false)
212     , m_hasInfo(false)
213     , m_gamma(45455)
214     , m_frameCount(1)
215     , m_playCount(0)
216     , m_totalFrames(0)
217     , m_sizePLTE(0)
218     , m_sizetRNS(0)
219     , m_sequenceNumber(0)
220     , m_width(0)
221     , m_height(0)
222     , m_xOffset(0)
223     , m_yOffset(0)
224     , m_delayNumerator(1)
225     , m_delayDenominator(1)
226     , m_dispose(0)
227     , m_blend(0)
228 #endif
229 {
230 }
231
232 PNGImageDecoder::~PNGImageDecoder()
233 {
234 }
235
236 #if ENABLE(APNG)
237 RepetitionCount PNGImageDecoder::repetitionCount() const
238 {
239     // APNG format uses 0 to indicate that an animation must play indefinitely. But
240     // the RepetitionCount enumeration uses RepetitionCountInfinite, so we need to adapt this.
241     if (!m_playCount)
242         return RepetitionCountInfinite;
243
244     return m_playCount;
245 }
246 #endif
247
248 bool PNGImageDecoder::setSize(const IntSize& size)
249 {
250     if (!ImageDecoder::setSize(size))
251         return false;
252
253     prepareScaleDataIfNecessary();
254     return true;
255 }
256
257 ImageFrame* PNGImageDecoder::frameBufferAtIndex(size_t index)
258 {
259 #if ENABLE(APNG)
260     if (ImageDecoder::encodedDataStatus() < EncodedDataStatus::SizeAvailable)
261         return nullptr;
262
263     if (index >= frameCount())
264         index = frameCount() - 1;
265 #else
266     if (index)
267         return nullptr;
268 #endif
269
270     if (m_frameBufferCache.isEmpty())
271         m_frameBufferCache.resize(1);
272
273     ImageFrame& frame = m_frameBufferCache[index];
274     if (!frame.isComplete())
275         decode(false, index, isAllDataReceived());
276     return &frame;
277 }
278
279 bool PNGImageDecoder::setFailed()
280 {
281     if (m_doNothingOnFailure)
282         return false;
283     m_reader = nullptr;
284     return ImageDecoder::setFailed();
285 }
286
287 void PNGImageDecoder::headerAvailable()
288 {
289     png_structp png = m_reader->pngPtr();
290     png_infop info = m_reader->infoPtr();
291     png_uint_32 width = png_get_image_width(png, info);
292     png_uint_32 height = png_get_image_height(png, info);
293
294     // Protect against large images.
295     if (width > cMaxPNGSize || height > cMaxPNGSize) {
296         longjmp(JMPBUF(png), 1);
297         return;
298     }
299
300     // We can fill in the size now that the header is available.  Avoid memory
301     // corruption issues by neutering setFailed() during this call; if we don't
302     // do this, failures will cause |m_reader| to be deleted, and our jmpbuf
303     // will cease to exist.  Note that we'll still properly set the failure flag
304     // in this case as soon as we longjmp().
305     m_doNothingOnFailure = true;
306     bool result = setSize(IntSize(width, height));
307     m_doNothingOnFailure = false;
308     if (!result) {
309         longjmp(JMPBUF(png), 1);
310         return;
311     }
312
313     int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
314     png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
315
316     // The options we set here match what Mozilla does.
317
318 #if ENABLE(APNG)
319     m_hasInfo = true;
320     if (m_isAnimated) {
321         png_save_uint_32(m_dataIHDR, 13);
322         memcpy(m_dataIHDR + 4, "IHDR", 4);
323         png_save_uint_32(m_dataIHDR + 8, width);
324         png_save_uint_32(m_dataIHDR + 12, height);
325         m_dataIHDR[16] = bitDepth;
326         m_dataIHDR[17] = colorType;
327         m_dataIHDR[18] = compressionType;
328         m_dataIHDR[19] = filterType;
329         m_dataIHDR[20] = interlaceType;
330     }
331 #endif
332
333     // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
334     if (colorType == PNG_COLOR_TYPE_PALETTE) {
335 #if ENABLE(APNG)
336         if (m_isAnimated) {
337             png_colorp palette;
338             int paletteSize = 0;
339             png_get_PLTE(png, info, &palette, &paletteSize);
340             paletteSize *= 3;
341             png_save_uint_32(m_dataPLTE, paletteSize);
342             memcpy(m_dataPLTE + 4, "PLTE", 4);
343             memcpy(m_dataPLTE + 8, palette, paletteSize);
344             m_sizePLTE = paletteSize + 12;
345         }
346 #endif
347         png_set_expand(png);
348     }
349
350     if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8)
351         png_set_expand(png);
352
353     png_bytep trns = 0;
354     int trnsCount = 0;
355     png_color_16p transValues;
356     if (png_get_valid(png, info, PNG_INFO_tRNS)) {
357         png_get_tRNS(png, info, &trns, &trnsCount, &transValues);
358 #if ENABLE(APNG)
359         if (m_isAnimated) {
360             if (colorType == PNG_COLOR_TYPE_RGB) {
361                 png_save_uint_16(m_datatRNS + 8, transValues->red);
362                 png_save_uint_16(m_datatRNS + 10, transValues->green);
363                 png_save_uint_16(m_datatRNS + 12, transValues->blue);
364                 trnsCount = 6;
365             } else if (colorType == PNG_COLOR_TYPE_GRAY) {
366                 png_save_uint_16(m_datatRNS + 8, transValues->gray);
367                 trnsCount = 2;
368             } else if (colorType == PNG_COLOR_TYPE_PALETTE)
369                 memcpy(m_datatRNS + 8, trns, trnsCount);
370
371             png_save_uint_32(m_datatRNS, trnsCount);
372             memcpy(m_datatRNS + 4, "tRNS", 4);
373             m_sizetRNS = trnsCount + 12;
374         }
375 #endif
376         png_set_expand(png);
377     }
378
379     if (bitDepth == 16)
380         png_set_strip_16(png);
381
382     if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
383         png_set_gray_to_rgb(png);
384
385     // Deal with gamma and keep it under our control.
386     double gamma;
387     if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) {
388         if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
389             gamma = cInverseGamma;
390             png_set_gAMA(png, info, gamma);
391         }
392         png_set_gamma(png, cDefaultGamma, gamma);
393 #if ENABLE(APNG)
394         m_gamma = static_cast<int>(gamma * 100000);
395 #endif
396     } else
397         png_set_gamma(png, cDefaultGamma, cInverseGamma);
398
399     // Tell libpng to send us rows for interlaced pngs.
400     if (interlaceType == PNG_INTERLACE_ADAM7)
401         png_set_interlace_handling(png);
402
403     // Update our info now.
404     png_read_update_info(png, info);
405     channels = png_get_channels(png, info);
406     ASSERT(channels == 3 || channels == 4);
407
408     m_reader->setHasAlpha(channels == 4);
409
410     if (m_reader->decodingSizeOnly()) {
411         // If we only needed the size, halt the reader.
412 #if defined(PNG_LIBPNG_VER_MAJOR) && defined(PNG_LIBPNG_VER_MINOR) && (PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 5))
413         // '0' argument to png_process_data_pause means: Do not cache unprocessed data.
414         m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0));
415 #else
416         m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
417         png->buffer_size = 0;
418 #endif
419     }
420 }
421
422 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int)
423 {
424     if (m_frameBufferCache.isEmpty())
425         return;
426
427     // Initialize the framebuffer if needed.
428 #if ENABLE(APNG)
429     if (m_currentFrame >= frameCount())
430         return;
431 #endif
432     ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
433     if (buffer.isEmpty()) {
434         png_structp png = m_reader->pngPtr();
435         if (!buffer.initialize(scaledSize(), m_premultiplyAlpha)) {
436             longjmp(JMPBUF(png), 1);
437             return;
438         }
439
440         unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
441         if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr())
442             || m_currentFrame) {
443             if (!m_reader->interlaceBuffer())
444                 m_reader->createInterlaceBuffer(colorChannels * size().width() * size().height());
445             if (!m_reader->interlaceBuffer()) {
446                 longjmp(JMPBUF(png), 1);
447                 return;
448             }
449         }
450
451         buffer.setDecoding(ImageFrame::Decoding::Partial);
452         buffer.setHasAlpha(false);
453
454 #if ENABLE(APNG)
455         if (m_currentFrame)
456             initFrameBuffer(m_currentFrame);
457 #endif
458     }
459
460     /* libpng comments (here to explain what follows).
461      *
462      * this function is called for every row in the image.  If the
463      * image is interlacing, and you turned on the interlace handler,
464      * this function will be called for every row in every pass.
465      * Some of these rows will not be changed from the previous pass.
466      * When the row is not changed, the new_row variable will be NULL.
467      * The rows and passes are called in order, so you don't really
468      * need the row_num and pass, but I'm supplying them because it
469      * may make your life easier.
470      */
471
472     // Nothing to do if the row is unchanged, or the row is outside
473     // the image bounds: libpng may send extra rows, ignore them to
474     // make our lives easier.
475     if (!rowBuffer)
476         return;
477     int y = !m_scaled ? rowIndex : scaledY(rowIndex);
478     if (y < 0 || y >= scaledSize().height())
479         return;
480
481     /* libpng comments (continued).
482      *
483      * For the non-NULL rows of interlaced images, you must call
484      * png_progressive_combine_row() passing in the row and the
485      * old row.  You can call this function for NULL rows (it will
486      * just return) and for non-interlaced images (it just does the
487      * memcpy for you) if it will make the code easier.  Thus, you
488      * can just do this for all cases:
489      *
490      *    png_progressive_combine_row(png_ptr, old_row, new_row);
491      *
492      * where old_row is what was displayed for previous rows.  Note
493      * that the first pass (pass == 0 really) will completely cover
494      * the old row, so the rows do not have to be initialized.  After
495      * the first pass (and only for interlaced images), you will have
496      * to pass the current row, and the function will combine the
497      * old row and the new row.
498      */
499
500     bool hasAlpha = m_reader->hasAlpha();
501     unsigned colorChannels = hasAlpha ? 4 : 3;
502     png_bytep row = rowBuffer;
503
504     if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
505         row = interlaceBuffer + (rowIndex * colorChannels * size().width());
506 #if ENABLE(APNG)
507         if (m_currentFrame) {
508             png_progressive_combine_row(m_png, row, rowBuffer);
509             return; // Only do incremental image display for the first frame.
510         }
511 #endif
512         png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
513     }
514
515     // Write the decoded row pixels to the frame buffer.
516     RGBA32* address = buffer.backingStore()->pixelAt(0, y);
517     int width = scaledSize().width();
518     unsigned char nonTrivialAlphaMask = 0;
519
520 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
521     if (m_scaled) {
522         for (int x = 0; x < width; ++x, ++address) {
523             png_bytep pixel = row + m_scaledColumns[x] * colorChannels;
524             unsigned alpha = hasAlpha ? pixel[3] : 255;
525             buffer.backingStore()->setPixel(address, pixel[0], pixel[1], pixel[2], alpha);
526             nonTrivialAlphaMask |= (255 - alpha);
527         }
528     } else
529 #endif
530     {
531         png_bytep pixel = row;
532         if (hasAlpha) {
533             for (int x = 0; x < width; ++x, pixel += 4, ++address) {
534                 unsigned alpha = pixel[3];
535                 buffer.backingStore()->setPixel(address, pixel[0], pixel[1], pixel[2], alpha);
536                 nonTrivialAlphaMask |= (255 - alpha);
537             }
538         } else {
539             for (int x = 0; x < width; ++x, pixel += 3, ++address)
540                 *address = makeRGB(pixel[0], pixel[1], pixel[2]);
541         }
542     }
543
544     if (nonTrivialAlphaMask && !buffer.hasAlpha())
545         buffer.setHasAlpha(true);
546 }
547
548 void PNGImageDecoder::pngComplete()
549 {
550 #if ENABLE(APNG)
551     if (m_isAnimated) {
552         if (!processingFinish() && m_frameCount == m_currentFrame)
553             return;
554
555         fallbackNotAnimated();
556     }
557 #endif
558     if (!m_frameBufferCache.isEmpty())
559         m_frameBufferCache.first().setDecoding(ImageFrame::Decoding::Complete);
560 }
561
562 void PNGImageDecoder::decode(bool onlySize, unsigned haltAtFrame, bool allDataReceived)
563 {
564     if (failed())
565         return;
566
567     if (!m_reader)
568         m_reader = std::make_unique<PNGImageReader>(this);
569
570     // If we couldn't decode the image but we've received all the data, decoding
571     // has failed.
572     if (!m_reader->decode(*m_data, onlySize, haltAtFrame) && allDataReceived)
573         setFailed();
574     // If we're done decoding the image, we don't need the PNGImageReader
575     // anymore.  (If we failed, |m_reader| has already been cleared.)
576     else if (isComplete())
577         m_reader = nullptr;
578 }
579
580 #if ENABLE(APNG)
581 void PNGImageDecoder::readChunks(png_unknown_chunkp chunk)
582 {
583     if (!memcmp(chunk->name, "acTL", 4) && chunk->size == 8) {
584         if (m_hasInfo || m_isAnimated)
585             return;
586
587         m_frameCount = png_get_uint_32(chunk->data);
588         m_playCount = png_get_uint_32(chunk->data + 4);
589
590         if (!m_frameCount || m_frameCount > PNG_UINT_31_MAX || m_playCount > PNG_UINT_31_MAX) {
591             fallbackNotAnimated();
592             return;
593         }
594
595         m_isAnimated = true;
596         if (!m_frameInfo)
597             m_frameIsHidden = true;
598
599         if (m_frameBufferCache.size() == m_frameCount)
600             return;
601
602         m_frameBufferCache.resize(m_frameCount);
603     } else if (!memcmp(chunk->name, "fcTL", 4) && chunk->size == 26) {
604         if (m_hasInfo && !m_isAnimated)
605             return;
606
607         m_frameInfo = false;
608
609         if (processingFinish()) {
610             fallbackNotAnimated();
611             return;
612         }
613
614         // At this point the old frame is done. Let's start a new one.
615         unsigned sequenceNumber = png_get_uint_32(chunk->data);
616         if (sequenceNumber != m_sequenceNumber++) {
617             fallbackNotAnimated();
618             return;
619         }
620
621         m_width = png_get_uint_32(chunk->data + 4);
622         m_height = png_get_uint_32(chunk->data + 8);
623         m_xOffset = png_get_uint_32(chunk->data + 12);
624         m_yOffset = png_get_uint_32(chunk->data + 16);
625         m_delayNumerator = png_get_uint_16(chunk->data + 20);
626         m_delayDenominator = png_get_uint_16(chunk->data + 22);
627         m_dispose = chunk->data[24];
628         m_blend = chunk->data[25];
629
630         png_structp png = m_reader->pngPtr();
631         png_infop info = m_reader->infoPtr();
632         png_uint_32 width = png_get_image_width(png, info);
633         png_uint_32 height = png_get_image_height(png, info);
634
635         if (m_width > cMaxPNGSize || m_height > cMaxPNGSize
636             || m_xOffset > cMaxPNGSize || m_yOffset > cMaxPNGSize
637             || m_xOffset + m_width > width
638             || m_yOffset + m_height > height
639             || m_dispose > 2 || m_blend > 1) {
640             fallbackNotAnimated();
641             return;
642         }
643
644         if (m_frameBufferCache.isEmpty())
645             m_frameBufferCache.resize(1);
646
647         if (m_currentFrame < m_frameBufferCache.size()) {
648             ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
649
650             if (!m_delayDenominator)
651                 buffer.setDuration(m_delayNumerator * 10);
652             else
653                 buffer.setDuration(m_delayNumerator * 1000 / m_delayDenominator);
654
655             if (m_dispose == 2)
656                 buffer.setDisposalMethod(ImageFrame::DisposalMethod::RestoreToPrevious);
657             else if (m_dispose == 1)
658                 buffer.setDisposalMethod(ImageFrame::DisposalMethod::RestoreToBackground);
659             else
660                 buffer.setDisposalMethod(ImageFrame::DisposalMethod::DoNotDispose);
661         }
662
663         m_frameInfo = true;
664         m_frameIsHidden = false;
665
666         if (processingStart(chunk)) {
667             fallbackNotAnimated();
668             return;
669         }
670     } else if (!memcmp(chunk->name, "fdAT", 4) && chunk->size >= 4) {
671         if (!m_frameInfo || !m_isAnimated)
672             return;
673
674         unsigned sequenceNumber = png_get_uint_32(chunk->data);
675         if (sequenceNumber != m_sequenceNumber++) {
676             fallbackNotAnimated();
677             return;
678         }
679
680         if (setjmp(JMPBUF(m_png))) {
681             fallbackNotAnimated();
682             return;
683         }
684
685         png_save_uint_32(chunk->data, chunk->size - 4);
686         png_process_data(m_png, m_info, chunk->data, 4);
687         memcpy(chunk->data, "IDAT", 4);
688         png_process_data(m_png, m_info, chunk->data, chunk->size);
689         png_process_data(m_png, m_info, chunk->data, 4);
690     }
691 }
692
693 void PNGImageDecoder::frameHeader()
694 {
695     int colorType = png_get_color_type(m_png, m_info);
696
697     if (colorType == PNG_COLOR_TYPE_PALETTE)
698         png_set_expand(m_png);
699
700     int bitDepth = png_get_bit_depth(m_png, m_info);
701     if (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8)
702         png_set_expand(m_png);
703
704     if (png_get_valid(m_png, m_info, PNG_INFO_tRNS))
705         png_set_expand(m_png);
706
707     if (bitDepth == 16)
708         png_set_strip_16(m_png);
709
710     if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
711         png_set_gray_to_rgb(m_png);
712
713     double gamma;
714     if (png_get_gAMA(m_png, m_info, &gamma))
715         png_set_gamma(m_png, cDefaultGamma, gamma);
716
717     png_set_interlace_handling(m_png);
718
719     png_read_update_info(m_png, m_info);
720 }
721
722 void PNGImageDecoder::init()
723 {
724     m_isAnimated = false;
725     m_frameInfo = false;
726     m_frameIsHidden = false;
727     m_hasInfo = false;
728     m_currentFrame = 0;
729     m_totalFrames = 0;
730     m_sequenceNumber = 0;
731 }
732
733 void PNGImageDecoder::clearFrameBufferCache(size_t clearBeforeFrame)
734 {
735     if (m_frameBufferCache.isEmpty())
736         return;
737
738     // See GIFImageDecoder for full explanation.
739     clearBeforeFrame = std::min(clearBeforeFrame, m_frameBufferCache.size() - 1);
740     const Vector<ImageFrame>::iterator end(m_frameBufferCache.begin() + clearBeforeFrame);
741
742     Vector<ImageFrame>::iterator i(end);
743     for (; (i != m_frameBufferCache.begin()) && (i->isEmpty() || (i->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious)); --i) {
744         if (i->isComplete() && (i != end))
745             i->clear();
746     }
747
748     // Now |i| holds the last frame we need to preserve; clear prior frames.
749     for (Vector<ImageFrame>::iterator j(m_frameBufferCache.begin()); j != i; ++j) {
750         ASSERT(!j->isPartial());
751         if (j->isEmpty())
752             j->clear();
753     }
754 }
755
756 void PNGImageDecoder::initFrameBuffer(size_t frameIndex)
757 {
758     if (frameIndex >= frameCount())
759         return;
760
761     ImageFrame& buffer = m_frameBufferCache[frameIndex];
762
763     // The starting state for this frame depends on the previous frame's
764     // disposal method.
765     //
766     // Frames that use the DisposalMethod::RestoreToPrevious method are effectively
767     // no-ops in terms of changing the starting state of a frame compared to
768     // the starting state of the previous frame, so skip over them.  (If the
769     // first frame specifies this method, it will get treated like
770     // DisposeOverwriteBgcolor below and reset to a completely empty image.)
771     const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
772     ImageFrame::DisposalMethod prevMethod = prevBuffer->disposalMethod();
773     while (frameIndex && (prevMethod == ImageFrame::DisposalMethod::RestoreToPrevious)) {
774         prevBuffer = &m_frameBufferCache[--frameIndex];
775         prevMethod = prevBuffer->disposalMethod();
776     }
777
778     png_structp png = m_reader->pngPtr();
779     ASSERT(prevBuffer->isComplete());
780
781     if (prevMethod == ImageFrame::DisposalMethod::DoNotDispose) {
782         // Preserve the last frame as the starting state for this frame.
783         if (!prevBuffer->backingStore() || !buffer.initialize(*prevBuffer->backingStore()))
784             longjmp(JMPBUF(png), 1);
785     } else {
786         // We want to clear the previous frame to transparent, without
787         // affecting pixels in the image outside of the frame.
788         IntRect prevRect = prevBuffer->backingStore()->frameRect();
789         if (!frameIndex || prevRect.contains(IntRect(IntPoint(), scaledSize()))) {
790             // Clearing the first frame, or a frame the size of the whole
791             // image, results in a completely empty image.
792             buffer.backingStore()->clear();
793             buffer.setHasAlpha(true);
794         } else {
795             // Copy the whole previous buffer, then clear just its frame.
796             if (!prevBuffer->backingStore() || !buffer.initialize(*prevBuffer->backingStore())) {
797                 longjmp(JMPBUF(png), 1);
798                 return;
799             }
800             buffer.backingStore()->clearRect(prevRect);
801             buffer.setHasAlpha(true);
802         }
803     }
804     
805     IntRect frameRect(m_xOffset, m_yOffset, m_width, m_height);
806
807     // Make sure the frameRect doesn't extend outside the buffer.
808     if (frameRect.maxX() > size().width())
809         frameRect.setWidth(size().width() - m_xOffset);
810     if (frameRect.maxY() > size().height())
811         frameRect.setHeight(size().height() - m_yOffset);
812
813     int left = upperBoundScaledX(frameRect.x());
814     int right = lowerBoundScaledX(frameRect.maxX(), left);
815     int top = upperBoundScaledY(frameRect.y());
816     int bottom = lowerBoundScaledY(frameRect.maxY(), top);
817     buffer.backingStore()->setFrameRect(IntRect(left, top, right - left, bottom - top));
818 }
819
820 void PNGImageDecoder::frameComplete()
821 {
822     if (m_frameIsHidden || m_currentFrame >= frameCount())
823         return;
824
825     ImageFrame& buffer = m_frameBufferCache[m_currentFrame];
826     buffer.setDecoding(ImageFrame::Decoding::Complete);
827
828     png_bytep interlaceBuffer = m_reader->interlaceBuffer();
829
830     if (m_currentFrame && interlaceBuffer) {
831         IntRect rect = buffer.backingStore()->frameRect();
832         bool hasAlpha = m_reader->hasAlpha();
833         unsigned colorChannels = hasAlpha ? 4 : 3;
834         bool nonTrivialAlpha = false;
835         if (m_blend && !hasAlpha)
836             m_blend = 0;
837
838 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
839         for (int y = 0; y < rect.maxY() - rect.y(); ++y) {
840             png_bytep row = interlaceBuffer + (m_scaled ? m_scaledRows[y] : y) * colorChannels * size().width();
841             RGBA32* address = buffer.backingStore()->pixelAt(rect.x(), y + rect.y());
842             for (int x = 0; x < rect.maxX() - rect.x(); ++x) {
843                 png_bytep pixel = row + (m_scaled ? m_scaledColumns[x] : x) * colorChannels;
844                 unsigned alpha = hasAlpha ? pixel[3] : 255;
845                 nonTrivialAlpha |= alpha < 255;
846                 if (!m_blend)
847                     buffer.backingStore()->setPixel(address++, pixel[0], pixel[1], pixel[2], alpha);
848                 else
849                     buffer.backingStore()->blendPixel(address++, pixel[0], pixel[1], pixel[2], alpha);
850             }
851         }
852 #else
853         ASSERT(!m_scaled);
854         png_bytep row = interlaceBuffer;
855         for (int y = rect.y(); y < rect.maxY(); ++y, row += colorChannels * size().width()) {
856             png_bytep pixel = row;
857             RGBA32* address = buffer.backingStore()->pixelAt(rect.x(), y);
858             for (int x = rect.x(); x < rect.maxX(); ++x, pixel += colorChannels) {
859                 unsigned alpha = hasAlpha ? pixel[3] : 255;
860                 nonTrivialAlpha |= alpha < 255;
861                 if (!m_blend)
862                     buffer.backingStore()->setPixel(address++, pixel[0], pixel[1], pixel[2], alpha);
863                 else
864                     buffer.backingStore()->blendPixel(address++, pixel[0], pixel[1], pixel[2], alpha);
865             }
866         }
867 #endif
868
869         if (!nonTrivialAlpha) {
870             IntRect rect = buffer.backingStore()->frameRect();
871             if (rect.contains(IntRect(IntPoint(), scaledSize())))
872                 buffer.setHasAlpha(false);
873             else {
874                 size_t frameIndex = m_currentFrame;
875                 const ImageFrame* prevBuffer = &m_frameBufferCache[--frameIndex];
876                 while (frameIndex && (prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToPrevious))
877                     prevBuffer = &m_frameBufferCache[--frameIndex];
878
879                 IntRect prevRect = prevBuffer->backingStore()->frameRect();
880                 if ((prevBuffer->disposalMethod() == ImageFrame::DisposalMethod::RestoreToBackground) && !prevBuffer->hasAlpha() && rect.contains(prevRect))
881                     buffer.setHasAlpha(false);
882             }
883         } else if (!m_blend && !buffer.hasAlpha())
884             buffer.setHasAlpha(nonTrivialAlpha);
885     }
886     m_currentFrame++;
887 }
888
889 int PNGImageDecoder::processingStart(png_unknown_chunkp chunk)
890 {
891     static png_byte dataPNG[8] = {137, 80, 78, 71, 13, 10, 26, 10};
892     static png_byte datagAMA[16] = {0, 0, 0, 4, 103, 65, 77, 65};
893
894     if (!m_hasInfo)
895         return 0;
896
897     m_totalFrames++;
898
899     m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, decodingFailed, 0);
900     m_info = png_create_info_struct(m_png);
901     if (setjmp(JMPBUF(m_png)))
902         return 1;
903
904     png_set_crc_action(m_png, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
905     png_set_progressive_read_fn(m_png, static_cast<png_voidp>(this),
906         WebCore::frameHeader, WebCore::rowAvailable, 0);
907
908     memcpy(m_dataIHDR + 8, chunk->data + 4, 8);
909     png_save_uint_32(datagAMA + 8, m_gamma);
910
911     png_process_data(m_png, m_info, dataPNG, 8);
912     png_process_data(m_png, m_info, m_dataIHDR, 25);
913     png_process_data(m_png, m_info, datagAMA, 16);
914     if (m_sizePLTE > 0)
915         png_process_data(m_png, m_info, m_dataPLTE, m_sizePLTE);
916     if (m_sizetRNS > 0)
917         png_process_data(m_png, m_info, m_datatRNS, m_sizetRNS);
918
919     return 0;
920 }
921
922 int PNGImageDecoder::processingFinish()
923 {
924     static png_byte dataIEND[12] = {0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130};
925
926     if (!m_hasInfo)
927         return 0;
928
929     if (m_totalFrames) {
930         if (setjmp(JMPBUF(m_png)))
931             return 1;
932
933         png_process_data(m_png, m_info, dataIEND, 12);
934         png_destroy_read_struct(&m_png, &m_info, 0);
935     }
936
937     frameComplete();
938     return 0;
939 }
940
941 void PNGImageDecoder::fallbackNotAnimated()
942 {
943     m_isAnimated = false;
944     m_playCount = 0;
945     m_currentFrame = 0;
946 }
947 #endif
948
949 } // namespace WebCore