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