Unreviewed, rolling out r120485 and r120582.
[WebKit-https.git] / Source / WebCore / platform / image-decoders / png / PNGImageDecoder.cpp
1 /*
2  * Copyright (C) 2006 Apple Computer, 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  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with this library; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
24  *
25  * Alternatively, the contents of this file may be used under the terms
26  * of either the Mozilla Public License Version 1.1, found at
27  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
28  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
29  * (the "GPL"), in which case the provisions of the MPL or the GPL are
30  * applicable instead of those above.  If you wish to allow use of your
31  * version of this file only under the terms of one of those two
32  * licenses (the MPL or the GPL) and not to allow others to use your
33  * version of this file under the LGPL, indicate your decision by
34  * deletingthe provisions above and replace them with the notice and
35  * other provisions required by the MPL or the GPL, as the case may be.
36  * If you do not delete the provisions above, a recipient may use your
37  * version of this file under any of the LGPL, the MPL or the GPL.
38  */
39
40 #include "config.h"
41 #include "PNGImageDecoder.h"
42
43 #include "png.h"
44 #include <wtf/PassOwnPtr.h>
45
46 #if PLATFORM(CHROMIUM)
47 #include "TraceEvent.h"
48 #endif
49
50 #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))
51 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
52 #else
53 #define JMPBUF(png_ptr) png_ptr->jmpbuf
54 #endif
55
56 namespace WebCore {
57
58 // Gamma constants.
59 const double cMaxGamma = 21474.83;
60 const double cDefaultGamma = 2.2;
61 const double cInverseGamma = 0.45455;
62
63 // Protect against large PNGs. See Mozilla's bug #251381 for more info.
64 const unsigned long cMaxPNGSize = 1000000UL;
65
66 // Called if the decoding of the image fails.
67 #if PLATFORM(QT)
68 static void PNGAPI decodingFailed(png_structp, png_const_charp) NO_RETURN;
69 #endif
70 static void PNGAPI decodingFailed(png_structp png, png_const_charp)
71 {
72     longjmp(JMPBUF(png), 1);
73 }
74
75 // Callbacks given to the read struct.  The first is for warnings (we want to
76 // treat a particular warning as an error, which is why we have to register this
77 // callback).
78 static void PNGAPI decodingWarning(png_structp png, png_const_charp warningMsg)
79 {
80     // Mozilla did this, so we will too.
81     // Convert a tRNS warning to be an error (see
82     // http://bugzilla.mozilla.org/show_bug.cgi?id=251381 )
83     if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24))
84         png_error(png, warningMsg);
85 }
86
87 // Called when we have obtained the header information (including the size).
88 static void PNGAPI headerAvailable(png_structp png, png_infop)
89 {
90     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable();
91 }
92
93 // Called when a row is ready.
94 static void PNGAPI rowAvailable(png_structp png, png_bytep rowBuffer, png_uint_32 rowIndex, int interlacePass)
95 {
96     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->rowAvailable(rowBuffer, rowIndex, interlacePass);
97 }
98
99 // Called when we have completely finished decoding the image.
100 static void PNGAPI pngComplete(png_structp png, png_infop)
101 {
102     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete();
103 }
104
105 class PNGImageReader
106 {
107 public:
108     PNGImageReader(PNGImageDecoder* decoder)
109         : m_readOffset(0)
110         , m_decodingSizeOnly(false)
111         , m_interlaceBuffer(0)
112         , m_hasAlpha(false)
113         , m_currentBufferSize(0)
114     {
115         m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, decodingFailed, decodingWarning);
116         m_info = png_create_info_struct(m_png);
117         png_set_progressive_read_fn(m_png, decoder, headerAvailable, rowAvailable, pngComplete);
118     }
119
120     ~PNGImageReader()
121     {
122         close();
123     }
124
125     void close()
126     {
127         if (m_png && m_info)
128             // This will zero the pointers.
129             png_destroy_read_struct(&m_png, &m_info, 0);
130         delete[] m_interlaceBuffer;
131         m_interlaceBuffer = 0;
132         m_readOffset = 0;
133     }
134
135     unsigned currentBufferSize() const { return m_currentBufferSize; }
136
137     bool decode(const SharedBuffer& data, bool sizeOnly)
138     {
139         m_decodingSizeOnly = sizeOnly;
140         PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));
141
142         // We need to do the setjmp here. Otherwise bad things will happen.
143         if (setjmp(JMPBUF(m_png)))
144             return decoder->setFailed();
145
146         const char* segment;
147         while (unsigned segmentLength = data.getSomeData(segment, m_readOffset)) {
148             m_readOffset += segmentLength;
149             m_currentBufferSize = m_readOffset;
150             png_process_data(m_png, m_info, reinterpret_cast<png_bytep>(const_cast<char*>(segment)), segmentLength);
151             // We explicitly specify the superclass isSizeAvailable() because we
152             // merely want to check if we've managed to set the size, not
153             // (recursively) trigger additional decoding if we haven't.
154             if (sizeOnly ? decoder->ImageDecoder::isSizeAvailable() : decoder->isComplete())
155                 return true;
156         }
157         return false;
158     }
159
160     bool decodingSizeOnly() const { return m_decodingSizeOnly; }
161     png_structp pngPtr() const { return m_png; }
162     png_infop infoPtr() const { return m_info; }
163     png_bytep interlaceBuffer() const { return m_interlaceBuffer; }
164     bool hasAlpha() const { return m_hasAlpha; }
165
166     void setReadOffset(unsigned offset) { m_readOffset = offset; }
167     void setHasAlpha(bool b) { m_hasAlpha = b; }
168
169     void createInterlaceBuffer(int size) { m_interlaceBuffer = new png_byte[size]; }
170
171 private:
172     unsigned m_readOffset;
173     bool m_decodingSizeOnly;
174     png_structp m_png;
175     png_infop m_info;
176     png_bytep m_interlaceBuffer;
177     bool m_hasAlpha;
178     unsigned m_currentBufferSize;
179 };
180
181 PNGImageDecoder::PNGImageDecoder(ImageSource::AlphaOption alphaOption,
182                                  ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
183     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
184     , m_doNothingOnFailure(false)
185 {
186 }
187
188 PNGImageDecoder::~PNGImageDecoder()
189 {
190 }
191
192 bool PNGImageDecoder::isSizeAvailable()
193 {
194     if (!ImageDecoder::isSizeAvailable())
195          decode(true);
196
197     return ImageDecoder::isSizeAvailable();
198 }
199
200 bool PNGImageDecoder::setSize(unsigned width, unsigned height)
201 {
202     if (!ImageDecoder::setSize(width, height))
203         return false;
204
205     prepareScaleDataIfNecessary();
206     return true;
207 }
208
209 ImageFrame* PNGImageDecoder::frameBufferAtIndex(size_t index)
210 {
211     if (index)
212         return 0;
213
214     if (m_frameBufferCache.isEmpty()) {
215         m_frameBufferCache.resize(1);
216         m_frameBufferCache[0].setPremultiplyAlpha(m_premultiplyAlpha);
217     }
218
219     ImageFrame& frame = m_frameBufferCache[0];
220     if (frame.status() != ImageFrame::FrameComplete)
221         decode(false);
222     return &frame;
223 }
224
225 bool PNGImageDecoder::setFailed()
226 {
227     if (m_doNothingOnFailure)
228         return false;
229     m_reader.clear();
230     return ImageDecoder::setFailed();
231 }
232
233 static void readColorProfile(png_structp png, png_infop info, ColorProfile& colorProfile)
234 {
235     ASSERT(colorProfile.isEmpty());
236
237 #ifdef PNG_iCCP_SUPPORTED
238     char* profileName;
239     int compressionType;
240 #if (PNG_LIBPNG_VER < 10500)
241     png_charp profile;
242 #else
243     png_bytep profile;
244 #endif
245     png_uint_32 profileLength;
246     if (!png_get_iCCP(png, info, &profileName, &compressionType, &profile, &profileLength))
247         return;
248
249     // Only accept RGB color profiles from input class devices.
250     bool ignoreProfile = false;
251     char* profileData = reinterpret_cast<char*>(profile);
252     if (profileLength < ImageDecoder::iccColorProfileHeaderLength)
253         ignoreProfile = true;
254     else if (!ImageDecoder::rgbColorProfile(profileData, profileLength))
255         ignoreProfile = true;
256     else if (!ImageDecoder::inputDeviceColorProfile(profileData, profileLength))
257         ignoreProfile = true;
258
259     if (!ignoreProfile)
260         colorProfile.append(profileData, profileLength);
261 #endif
262 }
263
264 void PNGImageDecoder::headerAvailable()
265 {
266     png_structp png = m_reader->pngPtr();
267     png_infop info = m_reader->infoPtr();
268     png_uint_32 width = png_get_image_width(png, info);
269     png_uint_32 height = png_get_image_height(png, info);
270
271     // Protect against large images.
272     if (width > cMaxPNGSize || height > cMaxPNGSize) {
273         longjmp(JMPBUF(png), 1);
274         return;
275     }
276
277     // We can fill in the size now that the header is available.  Avoid memory
278     // corruption issues by neutering setFailed() during this call; if we don't
279     // do this, failures will cause |m_reader| to be deleted, and our jmpbuf
280     // will cease to exist.  Note that we'll still properly set the failure flag
281     // in this case as soon as we longjmp().
282     m_doNothingOnFailure = true;
283     bool result = setSize(width, height);
284     m_doNothingOnFailure = false;
285     if (!result) {
286         longjmp(JMPBUF(png), 1);
287         return;
288     }
289
290     int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
291     png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
292
293     if ((colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) && !m_ignoreGammaAndColorProfile) {
294         // We currently support color profiles only for RGB and RGBA PNGs.  Supporting
295         // color profiles for gray-scale images is slightly tricky, at least using the
296         // CoreGraphics ICC library, because we expand gray-scale images to RGB but we
297         // don't similarly transform the color profile.  We'd either need to transform
298         // the color profile or we'd need to decode into a gray-scale image buffer and
299         // hand that to CoreGraphics.
300         readColorProfile(png, info, m_colorProfile);
301     }
302
303     // The options we set here match what Mozilla does.
304
305     // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
306     if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
307         png_set_expand(png);
308
309     png_bytep trns = 0;
310     int trnsCount = 0;
311     if (png_get_valid(png, info, PNG_INFO_tRNS)) {
312         png_get_tRNS(png, info, &trns, &trnsCount, 0);
313         png_set_expand(png);
314     }
315
316     if (bitDepth == 16)
317         png_set_strip_16(png);
318
319     if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
320         png_set_gray_to_rgb(png);
321
322     // Deal with gamma and keep it under our control.
323     double gamma;
324     if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) {
325         if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
326             gamma = cInverseGamma;
327             png_set_gAMA(png, info, gamma);
328         }
329         png_set_gamma(png, cDefaultGamma, gamma);
330     } else
331         png_set_gamma(png, cDefaultGamma, cInverseGamma);
332
333     // Tell libpng to send us rows for interlaced pngs.
334     if (interlaceType == PNG_INTERLACE_ADAM7)
335         png_set_interlace_handling(png);
336
337     // Update our info now.
338     png_read_update_info(png, info);
339     channels = png_get_channels(png, info);
340     ASSERT(channels == 3 || channels == 4);
341
342     m_reader->setHasAlpha(channels == 4);
343
344     if (m_reader->decodingSizeOnly()) {
345         // If we only needed the size, halt the reader.
346 #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))
347         // '0' argument to png_process_data_pause means: Do not cache unprocessed data.
348         m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0));
349 #else
350         m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
351         png->buffer_size = 0;
352 #endif
353     }
354 }
355
356 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int interlacePass)
357 {
358     if (m_frameBufferCache.isEmpty())
359         return;
360
361     // Initialize the framebuffer if needed.
362     ImageFrame& buffer = m_frameBufferCache[0];
363     if (buffer.status() == ImageFrame::FrameEmpty) {
364         png_structp png = m_reader->pngPtr();
365         if (!buffer.setSize(scaledSize().width(), scaledSize().height())) {
366             longjmp(JMPBUF(png), 1);
367             return;
368         }
369
370         if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr())) {
371             unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
372             m_reader->createInterlaceBuffer(colorChannels * size().width() * size().height());
373             if (!m_reader->interlaceBuffer()) {
374                 longjmp(JMPBUF(png), 1);
375                 return;
376             }
377         }
378
379         buffer.setStatus(ImageFrame::FramePartial);
380         buffer.setHasAlpha(false);
381         buffer.setColorProfile(m_colorProfile);
382
383         // For PNGs, the frame always fills the entire image.
384         buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
385     }
386
387     /* libpng comments (here to explain what follows).
388      *
389      * this function is called for every row in the image.  If the
390      * image is interlacing, and you turned on the interlace handler,
391      * this function will be called for every row in every pass.
392      * Some of these rows will not be changed from the previous pass.
393      * When the row is not changed, the new_row variable will be NULL.
394      * The rows and passes are called in order, so you don't really
395      * need the row_num and pass, but I'm supplying them because it
396      * may make your life easier.
397      */
398
399     // Nothing to do if the row is unchanged, or the row is outside
400     // the image bounds: libpng may send extra rows, ignore them to
401     // make our lives easier.
402     if (!rowBuffer)
403         return;
404     int y = !m_scaled ? rowIndex : scaledY(rowIndex);
405     if (y < 0 || y >= scaledSize().height())
406         return;
407
408     /* libpng comments (continued).
409      *
410      * For the non-NULL rows of interlaced images, you must call
411      * png_progressive_combine_row() passing in the row and the
412      * old row.  You can call this function for NULL rows (it will
413      * just return) and for non-interlaced images (it just does the
414      * memcpy for you) if it will make the code easier.  Thus, you
415      * can just do this for all cases:
416      *
417      *    png_progressive_combine_row(png_ptr, old_row, new_row);
418      *
419      * where old_row is what was displayed for previous rows.  Note
420      * that the first pass (pass == 0 really) will completely cover
421      * the old row, so the rows do not have to be initialized.  After
422      * the first pass (and only for interlaced images), you will have
423      * to pass the current row, and the function will combine the
424      * old row and the new row.
425      */
426
427     bool hasAlpha = m_reader->hasAlpha();
428     unsigned colorChannels = hasAlpha ? 4 : 3;
429     png_bytep row = rowBuffer;
430
431     if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
432         row = interlaceBuffer + (rowIndex * colorChannels * size().width());
433         png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
434     }
435
436     // Write the decoded row pixels to the frame buffer.
437     int width = scaledSize().width();
438     bool nonTrivialAlpha = false;
439
440 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
441     for (int x = 0; x < width; ++x) {
442         png_bytep pixel = row + (m_scaled ? m_scaledColumns[x] : x) * colorChannels;
443         unsigned alpha = hasAlpha ? pixel[3] : 255;
444         buffer.setRGBA(x, y, pixel[0], pixel[1], pixel[2], alpha);
445         nonTrivialAlpha |= alpha < 255;
446     }
447 #else
448     ASSERT(!m_scaled);
449     png_bytep pixel = row;
450     for (int x = 0; x < width; ++x, pixel += colorChannels) {
451         unsigned alpha = hasAlpha ? pixel[3] : 255;
452         buffer.setRGBA(x, y, pixel[0], pixel[1], pixel[2], alpha);
453         nonTrivialAlpha |= alpha < 255;
454     }
455 #endif
456
457     if (nonTrivialAlpha && !buffer.hasAlpha())
458         buffer.setHasAlpha(nonTrivialAlpha);
459 }
460
461 void PNGImageDecoder::pngComplete()
462 {
463     if (!m_frameBufferCache.isEmpty())
464         m_frameBufferCache.first().setStatus(ImageFrame::FrameComplete);
465 }
466
467 void PNGImageDecoder::decode(bool onlySize)
468 {
469 #if PLATFORM(CHROMIUM)
470     TRACE_EVENT("PNGImageDecoder::decode", this, 0);
471 #endif
472     if (failed())
473         return;
474
475     if (!m_reader)
476         m_reader = adoptPtr(new PNGImageReader(this));
477
478     // If we couldn't decode the image but we've received all the data, decoding
479     // has failed.
480     if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
481         setFailed();
482     // If we're done decoding the image, we don't need the PNGImageReader
483     // anymore.  (If we failed, |m_reader| has already been cleared.)
484     else if (isComplete())
485         m_reader.clear();
486 }
487
488 } // namespace WebCore