[chromium] Use new-style tracing macros with explicit category
[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/OwnArrayPtr.h>
45 #include <wtf/PassOwnPtr.h>
46
47 #if PLATFORM(CHROMIUM)
48 #include "TraceEvent.h"
49 #endif
50
51 #if USE(QCMSLIB)
52 #include "qcms.h"
53 #endif
54
55 #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))
56 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
57 #else
58 #define JMPBUF(png_ptr) png_ptr->jmpbuf
59 #endif
60
61 namespace WebCore {
62
63 // Gamma constants.
64 const double cMaxGamma = 21474.83;
65 const double cDefaultGamma = 2.2;
66 const double cInverseGamma = 0.45455;
67
68 // Protect against large PNGs. See Mozilla's bug #251381 for more info.
69 const unsigned long cMaxPNGSize = 1000000UL;
70
71 // Called if the decoding of the image fails.
72 #if PLATFORM(QT)
73 static void PNGAPI decodingFailed(png_structp, png_const_charp) NO_RETURN;
74 #endif
75 static void PNGAPI decodingFailed(png_structp png, png_const_charp)
76 {
77     longjmp(JMPBUF(png), 1);
78 }
79
80 // Callbacks given to the read struct.  The first is for warnings (we want to
81 // treat a particular warning as an error, which is why we have to register this
82 // callback).
83 static void PNGAPI decodingWarning(png_structp png, png_const_charp warningMsg)
84 {
85     // Mozilla did this, so we will too.
86     // Convert a tRNS warning to be an error (see
87     // http://bugzilla.mozilla.org/show_bug.cgi?id=251381 )
88     if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24))
89         png_error(png, warningMsg);
90 }
91
92 // Called when we have obtained the header information (including the size).
93 static void PNGAPI headerAvailable(png_structp png, png_infop)
94 {
95     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable();
96 }
97
98 // Called when a row is ready.
99 static void PNGAPI rowAvailable(png_structp png, png_bytep rowBuffer, png_uint_32 rowIndex, int interlacePass)
100 {
101     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->rowAvailable(rowBuffer, rowIndex, interlacePass);
102 }
103
104 // Called when we have completely finished decoding the image.
105 static void PNGAPI pngComplete(png_structp png, png_infop)
106 {
107     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete();
108 }
109
110 class PNGImageReader
111 {
112 public:
113     PNGImageReader(PNGImageDecoder* decoder)
114         : m_readOffset(0)
115         , m_currentBufferSize(0)
116         , m_decodingSizeOnly(false)
117         , m_hasAlpha(false)
118         , m_interlaceBuffer(0)
119 #if USE(QCMSLIB)
120         , m_transform(0)
121         , m_rowBuffer()
122 #endif
123     {
124         m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, decodingFailed, decodingWarning);
125         m_info = png_create_info_struct(m_png);
126         png_set_progressive_read_fn(m_png, decoder, headerAvailable, rowAvailable, pngComplete);
127     }
128
129     ~PNGImageReader()
130     {
131         close();
132     }
133
134     void close()
135     {
136         if (m_png && m_info)
137             // This will zero the pointers.
138             png_destroy_read_struct(&m_png, &m_info, 0);
139 #if USE(QCMSLIB)
140         if (m_transform)
141             qcms_transform_release(m_transform);
142         m_transform = 0;
143 #endif
144         delete[] m_interlaceBuffer;
145         m_interlaceBuffer = 0;
146         m_readOffset = 0;
147     }
148
149     bool decode(const SharedBuffer& data, bool sizeOnly)
150     {
151         m_decodingSizeOnly = sizeOnly;
152         PNGImageDecoder* decoder = static_cast<PNGImageDecoder*>(png_get_progressive_ptr(m_png));
153
154         // We need to do the setjmp here. Otherwise bad things will happen.
155         if (setjmp(JMPBUF(m_png)))
156             return decoder->setFailed();
157
158         const char* segment;
159         while (unsigned segmentLength = data.getSomeData(segment, m_readOffset)) {
160             m_readOffset += segmentLength;
161             m_currentBufferSize = m_readOffset;
162             png_process_data(m_png, m_info, reinterpret_cast<png_bytep>(const_cast<char*>(segment)), segmentLength);
163             // We explicitly specify the superclass isSizeAvailable() because we
164             // merely want to check if we've managed to set the size, not
165             // (recursively) trigger additional decoding if we haven't.
166             if (sizeOnly ? decoder->ImageDecoder::isSizeAvailable() : decoder->isComplete())
167                 return true;
168         }
169         return false;
170     }
171
172     png_structp pngPtr() const { return m_png; }
173     png_infop infoPtr() const { return m_info; }
174
175     void setReadOffset(unsigned offset) { m_readOffset = offset; }
176     unsigned currentBufferSize() const { return m_currentBufferSize; }
177     bool decodingSizeOnly() const { return m_decodingSizeOnly; }
178     void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; }
179     bool hasAlpha() const { return m_hasAlpha; }
180
181     png_bytep interlaceBuffer() const { return m_interlaceBuffer; }
182     void createInterlaceBuffer(int size) { m_interlaceBuffer = new png_byte[size]; }
183 #if USE(QCMSLIB)
184     png_bytep rowBuffer() const { return m_rowBuffer.get(); }
185     void createRowBuffer(int size) { m_rowBuffer = adoptArrayPtr(new png_byte[size]); }
186     qcms_transform* colorTransform() const { return m_transform; }
187
188     void createColorTransform(const ColorProfile& colorProfile, bool hasAlpha)
189     {
190         if (m_transform)
191             qcms_transform_release(m_transform);
192         m_transform = 0;
193
194         if (colorProfile.isEmpty())
195             return;
196         qcms_profile* deviceProfile = ImageDecoder::qcmsOutputDeviceProfile();
197         if (!deviceProfile)
198             return;
199         qcms_profile* inputProfile = qcms_profile_from_memory(colorProfile.data(), colorProfile.size());
200         if (!inputProfile)
201             return;
202         // We currently only support color profiles for RGB and RGBA images.
203         ASSERT(icSigRgbData == qcms_profile_get_color_space(inputProfile));
204         qcms_data_type dataFormat = hasAlpha ? QCMS_DATA_RGBA_8 : QCMS_DATA_RGB_8;
205         // FIXME: Don't force perceptual intent if the image profile contains an intent.
206         m_transform = qcms_transform_create(inputProfile, dataFormat, deviceProfile, dataFormat, QCMS_INTENT_PERCEPTUAL);
207         qcms_profile_release(inputProfile);
208     }
209 #endif
210
211 private:
212     png_structp m_png;
213     png_infop m_info;
214     unsigned m_readOffset;
215     unsigned m_currentBufferSize;
216     bool m_decodingSizeOnly;
217     bool m_hasAlpha;
218     png_bytep m_interlaceBuffer;
219 #if USE(QCMSLIB)
220     qcms_transform* m_transform;
221     OwnArrayPtr<png_byte> m_rowBuffer;
222 #endif
223 };
224
225 PNGImageDecoder::PNGImageDecoder(ImageSource::AlphaOption alphaOption,
226                                  ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
227     : ImageDecoder(alphaOption, gammaAndColorProfileOption)
228     , m_doNothingOnFailure(false)
229 {
230 }
231
232 PNGImageDecoder::~PNGImageDecoder()
233 {
234 }
235
236 bool PNGImageDecoder::isSizeAvailable()
237 {
238     if (!ImageDecoder::isSizeAvailable())
239          decode(true);
240
241     return ImageDecoder::isSizeAvailable();
242 }
243
244 bool PNGImageDecoder::setSize(unsigned width, unsigned height)
245 {
246     if (!ImageDecoder::setSize(width, height))
247         return false;
248
249     prepareScaleDataIfNecessary();
250     return true;
251 }
252
253 ImageFrame* PNGImageDecoder::frameBufferAtIndex(size_t index)
254 {
255     if (index)
256         return 0;
257
258     if (m_frameBufferCache.isEmpty()) {
259         m_frameBufferCache.resize(1);
260         m_frameBufferCache[0].setPremultiplyAlpha(m_premultiplyAlpha);
261     }
262
263     ImageFrame& frame = m_frameBufferCache[0];
264     if (frame.status() != ImageFrame::FrameComplete)
265         decode(false);
266     return &frame;
267 }
268
269 bool PNGImageDecoder::setFailed()
270 {
271     if (m_doNothingOnFailure)
272         return false;
273     m_reader.clear();
274     return ImageDecoder::setFailed();
275 }
276
277 static void readColorProfile(png_structp png, png_infop info, ColorProfile& colorProfile)
278 {
279     ASSERT(colorProfile.isEmpty());
280
281 #ifdef PNG_iCCP_SUPPORTED
282     char* profileName;
283     int compressionType;
284 #if (PNG_LIBPNG_VER < 10500)
285     png_charp profile;
286 #else
287     png_bytep profile;
288 #endif
289     png_uint_32 profileLength;
290     if (!png_get_iCCP(png, info, &profileName, &compressionType, &profile, &profileLength))
291         return;
292
293     // Only accept RGB color profiles from input class devices.
294     bool ignoreProfile = false;
295     char* profileData = reinterpret_cast<char*>(profile);
296     if (profileLength < ImageDecoder::iccColorProfileHeaderLength)
297         ignoreProfile = true;
298     else if (!ImageDecoder::rgbColorProfile(profileData, profileLength))
299         ignoreProfile = true;
300     else if (!ImageDecoder::inputDeviceColorProfile(profileData, profileLength))
301         ignoreProfile = true;
302
303     if (!ignoreProfile)
304         colorProfile.append(profileData, profileLength);
305 #endif
306 }
307
308 void PNGImageDecoder::headerAvailable()
309 {
310     png_structp png = m_reader->pngPtr();
311     png_infop info = m_reader->infoPtr();
312     png_uint_32 width = png_get_image_width(png, info);
313     png_uint_32 height = png_get_image_height(png, info);
314
315     // Protect against large images.
316     if (width > cMaxPNGSize || height > cMaxPNGSize) {
317         longjmp(JMPBUF(png), 1);
318         return;
319     }
320
321     // We can fill in the size now that the header is available.  Avoid memory
322     // corruption issues by neutering setFailed() during this call; if we don't
323     // do this, failures will cause |m_reader| to be deleted, and our jmpbuf
324     // will cease to exist.  Note that we'll still properly set the failure flag
325     // in this case as soon as we longjmp().
326     m_doNothingOnFailure = true;
327     bool result = setSize(width, height);
328     m_doNothingOnFailure = false;
329     if (!result) {
330         longjmp(JMPBUF(png), 1);
331         return;
332     }
333
334     int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
335     png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceType, &compressionType, &filterType);
336
337     if ((colorType == PNG_COLOR_TYPE_RGB || colorType == PNG_COLOR_TYPE_RGB_ALPHA) && !m_ignoreGammaAndColorProfile) {
338         // We currently support color profiles only for RGB and RGBA PNGs.  Supporting
339         // color profiles for gray-scale images is slightly tricky, at least using the
340         // CoreGraphics ICC library, because we expand gray-scale images to RGB but we
341         // don't similarly transform the color profile.  We'd either need to transform
342         // the color profile or we'd need to decode into a gray-scale image buffer and
343         // hand that to CoreGraphics.
344         readColorProfile(png, info, m_colorProfile);
345 #if USE(QCMSLIB)
346         m_reader->createColorTransform(m_colorProfile, colorType & PNG_COLOR_MASK_ALPHA);
347         m_colorProfile.clear();
348 #endif
349     }
350
351     // The options we set here match what Mozilla does.
352
353     // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
354     if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
355         png_set_expand(png);
356
357     png_bytep trns = 0;
358     int trnsCount = 0;
359     if (png_get_valid(png, info, PNG_INFO_tRNS)) {
360         png_get_tRNS(png, info, &trns, &trnsCount, 0);
361         png_set_expand(png);
362     }
363
364     if (bitDepth == 16)
365         png_set_strip_16(png);
366
367     if (colorType == PNG_COLOR_TYPE_GRAY || colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
368         png_set_gray_to_rgb(png);
369
370     // Deal with gamma and keep it under our control.
371     double gamma;
372     if (!m_ignoreGammaAndColorProfile && png_get_gAMA(png, info, &gamma)) {
373         if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
374             gamma = cInverseGamma;
375             png_set_gAMA(png, info, gamma);
376         }
377         png_set_gamma(png, cDefaultGamma, gamma);
378     } else
379         png_set_gamma(png, cDefaultGamma, cInverseGamma);
380
381     // Tell libpng to send us rows for interlaced pngs.
382     if (interlaceType == PNG_INTERLACE_ADAM7)
383         png_set_interlace_handling(png);
384
385     // Update our info now.
386     png_read_update_info(png, info);
387     channels = png_get_channels(png, info);
388     ASSERT(channels == 3 || channels == 4);
389
390     m_reader->setHasAlpha(channels == 4);
391
392     if (m_reader->decodingSizeOnly()) {
393         // If we only needed the size, halt the reader.
394 #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))
395         // '0' argument to png_process_data_pause means: Do not cache unprocessed data.
396         m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data_pause(png, 0));
397 #else
398         m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size);
399         png->buffer_size = 0;
400 #endif
401     }
402 }
403
404 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int interlacePass)
405 {
406     if (m_frameBufferCache.isEmpty())
407         return;
408
409     // Initialize the framebuffer if needed.
410     ImageFrame& buffer = m_frameBufferCache[0];
411     if (buffer.status() == ImageFrame::FrameEmpty) {
412         png_structp png = m_reader->pngPtr();
413         if (!buffer.setSize(scaledSize().width(), scaledSize().height())) {
414             longjmp(JMPBUF(png), 1);
415             return;
416         }
417
418         unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3;
419         if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr())) {
420             m_reader->createInterlaceBuffer(colorChannels * size().width() * size().height());
421             if (!m_reader->interlaceBuffer()) {
422                 longjmp(JMPBUF(png), 1);
423                 return;
424             }
425         }
426
427 #if USE(QCMSLIB)
428         if (m_reader->colorTransform()) {
429             m_reader->createRowBuffer(colorChannels * size().width());
430             if (!m_reader->rowBuffer()) {
431                 longjmp(JMPBUF(png), 1);
432                 return;
433             }
434         }
435 #endif
436         buffer.setStatus(ImageFrame::FramePartial);
437         buffer.setHasAlpha(false);
438         buffer.setColorProfile(m_colorProfile);
439
440         // For PNGs, the frame always fills the entire image.
441         buffer.setOriginalFrameRect(IntRect(IntPoint(), size()));
442     }
443
444     /* libpng comments (here to explain what follows).
445      *
446      * this function is called for every row in the image.  If the
447      * image is interlacing, and you turned on the interlace handler,
448      * this function will be called for every row in every pass.
449      * Some of these rows will not be changed from the previous pass.
450      * When the row is not changed, the new_row variable will be NULL.
451      * The rows and passes are called in order, so you don't really
452      * need the row_num and pass, but I'm supplying them because it
453      * may make your life easier.
454      */
455
456     // Nothing to do if the row is unchanged, or the row is outside
457     // the image bounds: libpng may send extra rows, ignore them to
458     // make our lives easier.
459     if (!rowBuffer)
460         return;
461     int y = !m_scaled ? rowIndex : scaledY(rowIndex);
462     if (y < 0 || y >= scaledSize().height())
463         return;
464
465     /* libpng comments (continued).
466      *
467      * For the non-NULL rows of interlaced images, you must call
468      * png_progressive_combine_row() passing in the row and the
469      * old row.  You can call this function for NULL rows (it will
470      * just return) and for non-interlaced images (it just does the
471      * memcpy for you) if it will make the code easier.  Thus, you
472      * can just do this for all cases:
473      *
474      *    png_progressive_combine_row(png_ptr, old_row, new_row);
475      *
476      * where old_row is what was displayed for previous rows.  Note
477      * that the first pass (pass == 0 really) will completely cover
478      * the old row, so the rows do not have to be initialized.  After
479      * the first pass (and only for interlaced images), you will have
480      * to pass the current row, and the function will combine the
481      * old row and the new row.
482      */
483
484     bool hasAlpha = m_reader->hasAlpha();
485     unsigned colorChannels = hasAlpha ? 4 : 3;
486     png_bytep row = rowBuffer;
487
488     if (png_bytep interlaceBuffer = m_reader->interlaceBuffer()) {
489         row = interlaceBuffer + (rowIndex * colorChannels * size().width());
490         png_progressive_combine_row(m_reader->pngPtr(), row, rowBuffer);
491     }
492
493 #if USE(QCMSLIB)
494     if (qcms_transform* transform = m_reader->colorTransform()) {
495         qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width());
496         row = m_reader->rowBuffer();
497     }
498 #endif
499
500     // Write the decoded row pixels to the frame buffer.
501     int width = scaledSize().width();
502     bool nonTrivialAlpha = false;
503
504 #if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
505     for (int x = 0; x < width; ++x) {
506         png_bytep pixel = row + (m_scaled ? m_scaledColumns[x] : x) * colorChannels;
507         unsigned alpha = hasAlpha ? pixel[3] : 255;
508         buffer.setRGBA(x, y, pixel[0], pixel[1], pixel[2], alpha);
509         nonTrivialAlpha |= alpha < 255;
510     }
511 #else
512     ASSERT(!m_scaled);
513     png_bytep pixel = row;
514     for (int x = 0; x < width; ++x, pixel += colorChannels) {
515         unsigned alpha = hasAlpha ? pixel[3] : 255;
516         buffer.setRGBA(x, y, pixel[0], pixel[1], pixel[2], alpha);
517         nonTrivialAlpha |= alpha < 255;
518     }
519 #endif
520
521     if (nonTrivialAlpha && !buffer.hasAlpha())
522         buffer.setHasAlpha(nonTrivialAlpha);
523 }
524
525 void PNGImageDecoder::pngComplete()
526 {
527     if (!m_frameBufferCache.isEmpty())
528         m_frameBufferCache.first().setStatus(ImageFrame::FrameComplete);
529 }
530
531 void PNGImageDecoder::decode(bool onlySize)
532 {
533 #if PLATFORM(CHROMIUM)
534     TRACE_EVENT0("webkit", "PNGImageDecoder::decode");
535 #endif
536     if (failed())
537         return;
538
539     if (!m_reader)
540         m_reader = adoptPtr(new PNGImageReader(this));
541
542     // If we couldn't decode the image but we've received all the data, decoding
543     // has failed.
544     if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived())
545         setFailed();
546     // If we're done decoding the image, we don't need the PNGImageReader
547     // anymore.  (If we failed, |m_reader| has already been cleared.)
548     else if (isComplete())
549         m_reader.clear();
550 }
551
552 } // namespace WebCore