2009-01-23 Darin Fisher <darin@chromium.org>
[WebKit-https.git] / WebCore / platform / image-decoders / skia / PNGImageDecoder.cpp
1 /*
2  * Copyright (C) 2006 Apple Computer, Inc.
3  *
4  * Portions are Copyright (C) 2001 mozilla.org
5  *
6  * Other contributors:
7  *   Stuart Parmenter <stuart@mozilla.com>
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
22  *
23  * Alternatively, the contents of this file may be used under the terms
24  * of either the Mozilla Public License Version 1.1, found at
25  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
26  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
27  * (the "GPL"), in which case the provisions of the MPL or the GPL are
28  * applicable instead of those above.  If you wish to allow use of your
29  * version of this file only under the terms of one of those two
30  * licenses (the MPL or the GPL) and not to allow others to use your
31  * version of this file under the LGPL, indicate your decision by
32  * deletingthe provisions above and replace them with the notice and
33  * other provisions required by the MPL or the GPL, as the case may be.
34  * If you do not delete the provisions above, a recipient may use your
35  * version of this file under any of the LGPL, the MPL or the GPL.
36  */
37
38 #include "config.h"
39 #include "PNGImageDecoder.h"
40 #include "png.h"
41 #include "assert.h"
42
43 #if PLATFORM(CAIRO) || PLATFORM(QT) || PLATFORM(WX)
44
45 #if COMPILER(MSVC)
46 // Remove warnings from warning level 4.
47 #pragma warning(disable : 4611) // warning C4611: interaction between '_setjmp' and C++ object destruction is non-portable
48 #endif
49
50 namespace WebCore {
51
52 // Gamma constants.
53 const double cMaxGamma = 21474.83;
54 const double cDefaultGamma = 2.2;
55 const double cInverseGamma = 0.45455;
56
57 // Protect against large PNGs. See Mozilla's bug #251381 for more info.
58 const long cMaxPNGSize = 1000000L;
59
60 // Called if the decoding of the image fails.
61 static void PNGAPI decodingFailed(png_structp png_ptr, png_const_charp error_msg);
62
63 // Callbacks given to the read struct.  The first is for warnings (we want to treat a particular warning
64 // as an error, which is why we have to register this callback.
65 static void PNGAPI decodingWarning(png_structp png_ptr, png_const_charp warning_msg);
66
67 // Called when we have obtained the header information (including the size).
68 static void PNGAPI headerAvailable(png_structp png_ptr, png_infop info_ptr);
69
70 // Called when a row is ready.
71 static void PNGAPI rowAvailable(png_structp png_ptr, png_bytep new_row,
72                                 png_uint_32 row_num, int pass);
73
74 // Called when we have completely finished decoding the image.
75 static void PNGAPI pngComplete(png_structp png_ptr, png_infop info_ptr);
76
77 class PNGImageReader
78 {
79 public:
80     PNGImageReader(PNGImageDecoder* decoder)
81     : m_readOffset(0), m_decodingSizeOnly(false), m_interlaceBuffer(0), m_hasAlpha(0)
82     {
83         m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, decodingFailed, decodingWarning);
84         m_info = png_create_info_struct(m_png);
85         png_set_progressive_read_fn(m_png, decoder, headerAvailable, rowAvailable, pngComplete);
86     }
87
88     ~PNGImageReader()
89     {
90         close();
91     }
92
93     void close() {
94         if (m_png && m_info)
95             png_destroy_read_struct(&m_png, &m_info, 0);
96         delete []m_interlaceBuffer;
97         m_readOffset = 0;
98     }
99
100     void decode(const Vector<char>& data, bool sizeOnly)
101     {
102         m_decodingSizeOnly = sizeOnly;
103
104         // We need to do the setjmp here. Otherwise bad things will happen
105         if (setjmp(m_png->jmpbuf)) {
106             close();
107             return;
108         }
109
110         // Go ahead and assume we consumed all the data.  If we consume less, the
111         // callback will adjust our read offset accordingly.  Do not attempt to adjust the
112         // offset after png_process_data returns.
113         unsigned offset = m_readOffset;
114         unsigned remaining = data.size() - m_readOffset;
115         m_readOffset = data.size();
116         png_process_data(m_png, m_info, (png_bytep)(data.data()) + offset, remaining);
117     }
118
119     bool decodingSizeOnly() const { return m_decodingSizeOnly; }
120     png_structp pngPtr() const { return m_png; }
121     png_infop infoPtr() const { return m_info; }
122     png_bytep interlaceBuffer() const { return m_interlaceBuffer; }
123     bool hasAlpha() const { return m_hasAlpha; }
124
125     void setReadOffset(unsigned offset) { m_readOffset = offset; }
126     void setHasAlpha(bool b) { m_hasAlpha = b; }
127
128     void createInterlaceBuffer(int size) {
129         m_interlaceBuffer = new png_byte[size];
130     }
131
132 private:
133     unsigned m_readOffset;
134     bool m_decodingSizeOnly;
135     png_structp m_png;
136     png_infop m_info;
137     png_bytep m_interlaceBuffer;
138     bool m_hasAlpha;
139 };
140
141 PNGImageDecoder::PNGImageDecoder()
142 : m_reader(0)
143 {
144     m_frameBufferCache.resize(1);
145 }
146
147 PNGImageDecoder::~PNGImageDecoder()
148 {
149     delete m_reader;
150 }
151
152 // Take the data and store it.
153 void PNGImageDecoder::setData(SharedBuffer* data, bool allDataReceived)
154 {
155     if (m_failed)
156         return;
157
158     // Cache our new data.
159     ImageDecoder::setData(data, allDataReceived);
160
161     // Create the PNG reader.
162     if (!m_reader && !m_failed)
163         m_reader = new PNGImageReader(this);
164 }
165
166 // Whether or not the size information has been decoded yet.
167 bool PNGImageDecoder::isSizeAvailable() const
168 {
169     // If we have pending data to decode, send it to the PNG reader now.
170     if (!m_sizeAvailable && m_reader) {
171         if (m_failed)
172             return false;
173
174         // The decoder will go ahead and aggressively consume everything up until the
175         // size is encountered.
176         decode(true);
177     }
178
179     return m_sizeAvailable;
180 }
181
182 RGBA32Buffer* PNGImageDecoder::frameBufferAtIndex(size_t index)
183 {
184     if (index)
185         return 0;
186
187     RGBA32Buffer& frame = m_frameBufferCache[0];
188     if (frame.status() != RGBA32Buffer::FrameComplete && m_reader)
189         // Decode this frame.
190         decode();
191     return &frame;
192 }
193
194 // Feed data to the PNG reader.
195 void PNGImageDecoder::decode(bool sizeOnly) const
196 {
197     if (m_failed)
198         return;
199
200     m_reader->decode(m_data->buffer(), sizeOnly);
201     
202     if (m_failed || (m_frameBufferCache[0].status() == RGBA32Buffer::FrameComplete)) {
203         delete m_reader;
204         m_reader = 0;
205     }
206 }
207
208 void decodingFailed(png_structp png, png_const_charp errorMsg)
209 {
210     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->decodingFailed();
211     longjmp(png->jmpbuf, 1);
212 }
213
214 void decodingWarning(png_structp png, png_const_charp warningMsg)
215 {
216   // Mozilla did this, so we will too.
217   // Convert a tRNS warning to be an error (documented in bugzilla.mozilla.org bug #251381)
218   if (!strncmp(warningMsg, "Missing PLTE before tRNS", 24))
219       png_error(png, warningMsg);
220 }
221
222 void headerAvailable(png_structp png, png_infop info)
223 {
224     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->headerAvailable();
225 }
226
227 void PNGImageDecoder::headerAvailable()
228 {
229     png_structp png = reader()->pngPtr();
230     png_infop info = reader()->infoPtr();
231     png_uint_32 width = png->width;
232     png_uint_32 height = png->height;
233     
234     // Protect against large images.
235     if (png->width > cMaxPNGSize || png->height > cMaxPNGSize) {
236         m_failed = true;
237         longjmp(png->jmpbuf, 1);
238         return;
239     }
240     
241     // We can fill in the size now that the header is available.
242     if (!m_sizeAvailable) {
243         m_sizeAvailable = true;
244         m_size = IntSize(width, height);
245     }
246
247     int bitDepth, colorType, interlaceType, compressionType, filterType, channels;
248     png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType,
249                  &interlaceType, &compressionType, &filterType);
250
251     // The options we set here match what Mozilla does.
252
253     // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA.
254     if (colorType == PNG_COLOR_TYPE_PALETTE ||
255         (colorType == PNG_COLOR_TYPE_GRAY && bitDepth < 8))
256         png_set_expand(png);
257     
258     png_bytep trns = 0;
259     int trnsCount = 0;
260     if (png_get_valid(png, info, PNG_INFO_tRNS)) {
261         png_get_tRNS(png, info, &trns, &trnsCount, 0);
262         png_set_expand(png);
263     }
264
265     if (bitDepth == 16)
266         png_set_strip_16(png);
267
268     if (colorType == PNG_COLOR_TYPE_GRAY ||
269         colorType == PNG_COLOR_TYPE_GRAY_ALPHA)
270         png_set_gray_to_rgb(png);
271
272     // Deal with gamma and keep it under our control.
273     double gamma;
274     if (png_get_gAMA(png, info, &gamma)) {
275         if ((gamma <= 0.0) || (gamma > cMaxGamma)) {
276             gamma = cInverseGamma;
277             png_set_gAMA(png, info, gamma);
278         }
279         png_set_gamma(png, cDefaultGamma, gamma);
280     }
281     else
282         png_set_gamma(png, cDefaultGamma, cInverseGamma);
283
284     // Tell libpng to send us rows for interlaced pngs.
285     if (interlaceType == PNG_INTERLACE_ADAM7)
286         png_set_interlace_handling(png);
287
288     // Update our info now
289     png_read_update_info(png, info);
290     channels = png_get_channels(png, info);
291     assert(channels == 3 || channels == 4);
292
293     reader()->setHasAlpha(channels == 4);
294
295     if (reader()->decodingSizeOnly()) {
296         // If we only needed the size, halt the reader.     
297         reader()->setReadOffset(m_data->size() - png->buffer_size);
298         png->buffer_size = 0;
299     }
300 }
301
302 void rowAvailable(png_structp png, png_bytep rowBuffer,
303                   png_uint_32 rowIndex, int interlacePass)
304 {
305     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->rowAvailable(rowBuffer, rowIndex, interlacePass);
306 }
307
308 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int interlacePass)
309 {
310     // Resize to the width and height of the image.
311     RGBA32Buffer& buffer = m_frameBufferCache[0];
312     if (buffer.status() == RGBA32Buffer::FrameEmpty) {
313         // Let's resize our buffer now to the correct width/height.
314         RGBA32Array& bytes = buffer.bytes();
315         bytes.resize(m_size.width() * m_size.height());
316
317         // Update our status to be partially complete.
318         buffer.setStatus(RGBA32Buffer::FramePartial);
319
320         // For PNGs, the frame always fills the entire image.
321         buffer.setRect(IntRect(0, 0, m_size.width(), m_size.height()));
322
323         if (reader()->pngPtr()->interlaced)
324             reader()->createInterlaceBuffer((reader()->hasAlpha() ? 4 : 3) * m_size.width() * m_size.height());
325     }
326
327     if (rowBuffer == 0)
328         return;
329
330    /* libpng comments (pasted in here to explain what follows)
331     *
332     * this function is called for every row in the image.  If the
333     * image is interlacing, and you turned on the interlace handler,
334     * this function will be called for every row in every pass.
335     * Some of these rows will not be changed from the previous pass.
336     * When the row is not changed, the new_row variable will be NULL.
337     * The rows and passes are called in order, so you don't really
338     * need the row_num and pass, but I'm supplying them because it
339     * may make your life easier.
340     *
341     * For the non-NULL rows of interlaced images, you must call
342     * png_progressive_combine_row() passing in the row and the
343     * old row.  You can call this function for NULL rows (it will
344     * just return) and for non-interlaced images (it just does the
345     * memcpy for you) if it will make the code easier.  Thus, you
346     * can just do this for all cases:
347     *
348     *    png_progressive_combine_row(png_ptr, old_row, new_row);
349     *
350     * where old_row is what was displayed for previous rows.  Note
351     * that the first pass (pass == 0 really) will completely cover
352     * the old row, so the rows do not have to be initialized.  After
353     * the first pass (and only for interlaced images), you will have
354     * to pass the current row, and the function will combine the
355     * old row and the new row.
356     */
357     
358     png_structp png = reader()->pngPtr();
359     bool hasAlpha = reader()->hasAlpha();
360     unsigned colorChannels = hasAlpha ? 4 : 3;
361     png_bytep row;
362     png_bytep interlaceBuffer = reader()->interlaceBuffer();
363     if (interlaceBuffer) {
364         row = interlaceBuffer + (rowIndex * colorChannels * m_size.width());
365         png_progressive_combine_row(png, row, rowBuffer);
366     }
367     else
368         row = rowBuffer;
369
370     // Copy the data into our buffer.
371     int width = m_size.width();
372     unsigned* dst = buffer.bytes().data() + rowIndex * width;
373     bool sawAlpha = false;
374     for (int i = 0; i < width; i++) {
375         unsigned red = *row++;
376         unsigned green = *row++;
377         unsigned blue = *row++;
378         unsigned alpha = (hasAlpha ? *row++ : 255);
379         RGBA32Buffer::setRGBA(*dst++, red, green, blue, alpha);
380         if (!sawAlpha && alpha < 255) {
381             sawAlpha = true;
382             buffer.setHasAlpha(true);
383         }
384     }
385
386     buffer.ensureHeight(rowIndex + 1);
387 }
388
389 void pngComplete(png_structp png, png_infop info)
390 {
391     static_cast<PNGImageDecoder*>(png_get_progressive_ptr(png))->pngComplete();
392 }
393
394 void PNGImageDecoder::pngComplete()
395 {
396     // Hand back an appropriately sized buffer, even if the image ended up being empty.
397     RGBA32Buffer& buffer = m_frameBufferCache[0];
398     buffer.setStatus(RGBA32Buffer::FrameComplete);
399 }
400
401 }
402
403 #endif // PLATFORM(CAIRO)