OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (C) 2006 Apple Computer, Inc. | 2 * Copyright (C) 2006 Apple Computer, Inc. |
3 * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved. | 3 * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved. |
4 * | 4 * |
5 * Portions are Copyright (C) 2001 mozilla.org | 5 * Portions are Copyright (C) 2001 mozilla.org |
6 * | 6 * |
7 * Other contributors: | 7 * Other contributors: |
8 * Stuart Parmenter <stuart@mozilla.com> | 8 * Stuart Parmenter <stuart@mozilla.com> |
9 * | 9 * |
10 * This library is free software; you can redistribute it and/or | 10 * This library is free software; you can redistribute it and/or |
(...skipping 20 matching lines...) Expand all Loading... | |
31 * licenses (the MPL or the GPL) and not to allow others to use your | 31 * licenses (the MPL or the GPL) and not to allow others to use your |
32 * version of this file under the LGPL, indicate your decision by | 32 * version of this file under the LGPL, indicate your decision by |
33 * deletingthe provisions above and replace them with the notice and | 33 * deletingthe provisions above and replace them with the notice and |
34 * other provisions required by the MPL or the GPL, as the case may be. | 34 * other provisions required by the MPL or the GPL, as the case may be. |
35 * If you do not delete the provisions above, a recipient may use your | 35 * If you do not delete the provisions above, a recipient may use your |
36 * version of this file under any of the LGPL, the MPL or the GPL. | 36 * version of this file under any of the LGPL, the MPL or the GPL. |
37 */ | 37 */ |
38 | 38 |
39 #include "platform/image-decoders/png/PNGImageDecoder.h" | 39 #include "platform/image-decoders/png/PNGImageDecoder.h" |
40 | 40 |
41 #include "platform/image-decoders/png/PNGImageReader.h" | |
41 #include "png.h" | 42 #include "png.h" |
42 #include "wtf/PtrUtil.h" | |
43 #include <memory> | 43 #include <memory> |
44 | 44 |
45 | |
45 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR) | 46 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR) |
46 #error version error: compile against a versioned libpng. | 47 #error version error: compile against a versioned libpng. |
47 #endif | 48 #endif |
48 #if USE(QCMSLIB) | 49 #if USE(QCMSLIB) |
49 #include "qcms.h" | 50 #include "qcms.h" |
50 #endif | 51 #endif |
51 | 52 |
52 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MIN OR >= 4) | 53 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MIN OR >= 4) |
53 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr) | 54 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr) |
54 #else | 55 #else |
55 #define JMPBUF(png_ptr) png_ptr->jmpbuf | 56 #define JMPBUF(png_ptr) png_ptr->jmpbuf |
56 #endif | 57 #endif |
57 | 58 |
58 namespace { | |
59 | |
60 inline blink::PNGImageDecoder* imageDecoder(png_structp png) | |
61 { | |
62 return static_cast<blink::PNGImageDecoder*>(png_get_progressive_ptr(png)); | |
63 } | |
64 | |
65 void PNGAPI pngHeaderAvailable(png_structp png, png_infop) | |
66 { | |
67 imageDecoder(png)->headerAvailable(); | |
68 } | |
69 | |
70 void PNGAPI pngRowAvailable(png_structp png, png_bytep row, png_uint_32 rowIndex , int state) | |
71 { | |
72 imageDecoder(png)->rowAvailable(row, rowIndex, state); | |
73 } | |
74 | |
75 void PNGAPI pngComplete(png_structp png, png_infop) | |
76 { | |
77 imageDecoder(png)->complete(); | |
78 } | |
79 | |
80 void PNGAPI pngFailed(png_structp png, png_const_charp) | |
81 { | |
82 longjmp(JMPBUF(png), 1); | |
83 } | |
84 | |
85 } // namespace | |
86 | 59 |
87 namespace blink { | 60 namespace blink { |
88 | 61 |
89 class PNGImageReader final { | |
90 USING_FAST_MALLOC(PNGImageReader); | |
91 WTF_MAKE_NONCOPYABLE(PNGImageReader); | |
92 public: | |
93 PNGImageReader(PNGImageDecoder* decoder, size_t readOffset) | |
94 : m_decoder(decoder) | |
95 , m_readOffset(readOffset) | |
96 , m_currentBufferSize(0) | |
97 , m_decodingSizeOnly(false) | |
98 , m_hasAlpha(false) | |
99 #if USE(QCMSLIB) | |
100 , m_rowBuffer() | |
101 #endif | |
102 { | |
103 m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0); | |
104 m_info = png_create_info_struct(m_png); | |
105 png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable, pngRow Available, pngComplete); | |
106 } | |
107 | |
108 ~PNGImageReader() | |
109 { | |
110 png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0); | |
111 ASSERT(!m_png && !m_info); | |
112 | |
113 m_readOffset = 0; | |
114 } | |
115 | |
116 bool decode(const SegmentReader& data, bool sizeOnly) | |
117 { | |
118 m_decodingSizeOnly = sizeOnly; | |
119 | |
120 // We need to do the setjmp here. Otherwise bad things will happen. | |
121 if (setjmp(JMPBUF(m_png))) | |
122 return m_decoder->setFailed(); | |
123 | |
124 const char* segment; | |
125 while (size_t segmentLength = data.getSomeData(segment, m_readOffset)) { | |
126 m_readOffset += segmentLength; | |
127 m_currentBufferSize = m_readOffset; | |
128 png_process_data(m_png, m_info, reinterpret_cast<png_bytep>(const_ca st<char*>(segment)), segmentLength); | |
129 if (sizeOnly ? m_decoder->isDecodedSizeAvailable() : m_decoder->fram eIsCompleteAtIndex(0)) | |
130 return true; | |
131 } | |
132 | |
133 return false; | |
134 } | |
135 | |
136 png_structp pngPtr() const { return m_png; } | |
137 png_infop infoPtr() const { return m_info; } | |
138 | |
139 size_t getReadOffset() const { return m_readOffset; } | |
140 void setReadOffset(size_t offset) { m_readOffset = offset; } | |
141 size_t currentBufferSize() const { return m_currentBufferSize; } | |
142 bool decodingSizeOnly() const { return m_decodingSizeOnly; } | |
143 void setHasAlpha(bool hasAlpha) { m_hasAlpha = hasAlpha; } | |
144 bool hasAlpha() const { return m_hasAlpha; } | |
145 | |
146 png_bytep interlaceBuffer() const { return m_interlaceBuffer.get(); } | |
147 void createInterlaceBuffer(int size) { m_interlaceBuffer = wrapArrayUnique(n ew png_byte[size]); } | |
148 #if USE(QCMSLIB) | |
149 png_bytep rowBuffer() const { return m_rowBuffer.get(); } | |
150 void createRowBuffer(int size) { m_rowBuffer = wrapArrayUnique(new png_byte[ size]); } | |
151 #endif | |
152 | |
153 private: | |
154 png_structp m_png; | |
155 png_infop m_info; | |
156 PNGImageDecoder* m_decoder; | |
157 size_t m_readOffset; | |
158 size_t m_currentBufferSize; | |
159 bool m_decodingSizeOnly; | |
160 bool m_hasAlpha; | |
161 std::unique_ptr<png_byte[]> m_interlaceBuffer; | |
162 #if USE(QCMSLIB) | |
163 std::unique_ptr<png_byte[]> m_rowBuffer; | |
164 #endif | |
165 }; | |
166 | |
167 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp tion colorOptions, size_t maxDecodedBytes, size_t offset) | 62 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp tion colorOptions, size_t maxDecodedBytes, size_t offset) |
168 : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes) | 63 : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes) |
169 , m_offset(offset) | 64 , m_offset(offset) |
65 , m_metaDataDecoded(false) | |
66 , m_frameCount(0) | |
67 , m_repetitionCount(cAnimationNone) | |
170 { | 68 { |
171 } | 69 } |
172 | 70 |
173 PNGImageDecoder::~PNGImageDecoder() | 71 PNGImageDecoder::~PNGImageDecoder() |
174 { | 72 { |
175 } | 73 } |
176 | 74 |
75 size_t PNGImageDecoder::decodeFrameCount() | |
76 { | |
77 if (m_metaDataDecoded) | |
78 return m_frameCount; | |
scroggo_chromium
2016/10/11 20:13:09
If we failed, does this get set to m_frame_bufferC
joostouwerling
2016/10/12 20:49:46
I'm not sure this answers completely what you're g
joostouwerling
2016/10/13 18:50:22
Now that I've been thinking about his, I don't thi
| |
79 | |
80 parse(PNGParseQuery::PNGMetaDataQuery); | |
81 // If decoding fails, we don't return 0 but we return the existing number | |
82 // of frames. This prevents us from reporting zero frames when decoding | |
83 // fails halfway through the image. | |
84 return failed() ? m_frameBufferCache.size() : m_frameCount; | |
85 } | |
86 | |
87 void PNGImageDecoder::decode(size_t index) | |
88 { | |
89 m_reader->decode(*m_data, index); | |
scroggo_chromium
2016/10/11 20:13:09
Are we guaranteed to have an m_reader here?
joostouwerling
2016/10/12 20:49:46
m_reader is not deleted by the decoder anymore.
T
scroggo_chromium
2016/10/13 13:49:32
I believe that is correct, but it is fragile. Note
| |
90 } | |
91 | |
92 void PNGImageDecoder::parse(PNGParseQuery query) | |
93 { | |
94 if (failed()) | |
95 return; | |
96 | |
97 if (!m_reader) | |
98 m_reader = wrapUnique(new PNGImageReader(this, m_offset)); | |
99 | |
100 if (!m_reader->parse(*m_data, query) && isAllDataReceived()) | |
101 { | |
scroggo_chromium
2016/10/11 20:13:09
Curly braces go on their own line for methods, but
joostouwerling
2016/10/12 20:49:46
Ack, that was due to debugging.
| |
102 SkDebugf("Setting failed in PNGImageDecoder::parse"); | |
scroggo_chromium
2016/10/11 20:13:09
You'll need to remove this before submitting.
| |
103 setFailed(); | |
104 } | |
105 | |
106 if (query == PNGParseQuery::PNGMetaDataQuery) | |
107 m_frameCount = m_reader->frameCount(); | |
108 } | |
109 | |
110 void PNGImageDecoder::setRepetitionCount(size_t repetitionCount) | |
111 { | |
112 m_repetitionCount = (repetitionCount == 0) ? cAnimationLoopInfinite | |
113 : repetitionCount; | |
114 } | |
115 | |
116 // FIXME(joostouwerling): crbug.com/267883 | |
scroggo_chromium
2016/10/11 20:13:09
It is good to have the bug as a reference, but it
| |
117 int PNGImageDecoder::repetitionCount() const | |
118 { | |
119 return failed() ? cAnimationLoopOnce : m_repetitionCount; | |
120 } | |
121 | |
122 void PNGImageDecoder::initializeNewFrame(size_t index) | |
123 { | |
124 const auto& frameInfo = m_reader->frameInfo(index); | |
scroggo_chromium
2016/10/11 20:13:09
I'm not convinced using "auto" here helps readabil
| |
125 auto buffer = &m_frameBufferCache[index]; | |
scroggo_chromium
2016/10/11 20:13:09
If we use "auto" here, I think it should be "auto*
| |
126 | |
127 IntRect frameRect(frameInfo.offset, frameInfo.size); | |
128 IntRect frameRectWithinSize = intersection(frameRect, {IntPoint(), size()}); | |
129 buffer->setOriginalFrameRect(frameRectWithinSize); | |
130 buffer->setDuration(frameInfo.duration); | |
131 buffer->setDisposalMethod(frameInfo.disposalMethod); | |
132 buffer->setAlphaBlendSource(frameInfo.alphaBlend); | |
133 } | |
134 | |
177 void PNGImageDecoder::headerAvailable() | 135 void PNGImageDecoder::headerAvailable() |
178 { | 136 { |
179 png_structp png = m_reader->pngPtr(); | 137 png_structp png = m_reader->pngPtr(); |
180 png_infop info = m_reader->infoPtr(); | 138 png_infop info = m_reader->infoPtr(); |
181 png_uint_32 width = png_get_image_width(png, info); | 139 png_uint_32 width = png_get_image_width(png, info); |
182 png_uint_32 height = png_get_image_height(png, info); | 140 png_uint_32 height = png_get_image_height(png, info); |
183 | 141 |
184 // Protect against large PNGs. See http://bugzil.la/251381 for more details. | 142 // Protect against large PNGs. See http://bugzil.la/251381 for more details. |
185 const unsigned long maxPNGSize = 1000000UL; | 143 const unsigned long maxPNGSize = 1000000UL; |
186 if (width > maxPNGSize || height > maxPNGSize) { | 144 if (width > maxPNGSize || height > maxPNGSize) { |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
263 // Tell libpng to send us rows for interlaced pngs. | 221 // Tell libpng to send us rows for interlaced pngs. |
264 if (interlaceType == PNG_INTERLACE_ADAM7) | 222 if (interlaceType == PNG_INTERLACE_ADAM7) |
265 png_set_interlace_handling(png); | 223 png_set_interlace_handling(png); |
266 | 224 |
267 // Update our info now. | 225 // Update our info now. |
268 png_read_update_info(png, info); | 226 png_read_update_info(png, info); |
269 channels = png_get_channels(png, info); | 227 channels = png_get_channels(png, info); |
270 ASSERT(channels == 3 || channels == 4); | 228 ASSERT(channels == 3 || channels == 4); |
271 | 229 |
272 m_reader->setHasAlpha(channels == 4); | 230 m_reader->setHasAlpha(channels == 4); |
273 | |
274 if (m_reader->decodingSizeOnly()) { | |
275 // If we only needed the size, halt the reader. | |
276 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MIN OR >= 5) | |
277 // '0' argument to png_process_data_pause means: Do not cache unprocesse d data. | |
278 m_reader->setReadOffset(m_reader->currentBufferSize() - png_process_data _pause(png, 0)); | |
279 #else | |
280 m_reader->setReadOffset(m_reader->currentBufferSize() - png->buffer_size ); | |
281 png->buffer_size = 0; | |
282 #endif | |
283 } | |
284 } | 231 } |
285 | 232 |
286 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int) | 233 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex, int) |
287 { | 234 { |
235 | |
288 if (m_frameBufferCache.isEmpty()) | 236 if (m_frameBufferCache.isEmpty()) |
289 return; | 237 return; |
290 | 238 |
291 // Initialize the framebuffer if needed. | 239 // Initialize the framebuffer if needed. |
292 ImageFrame& buffer = m_frameBufferCache[0]; | 240 ImageFrame& buffer = m_frameBufferCache[0]; |
293 if (buffer.getStatus() == ImageFrame::FrameEmpty) { | 241 if (buffer.getStatus() == ImageFrame::FrameEmpty) { |
294 png_structp png = m_reader->pngPtr(); | 242 png_structp png = m_reader->pngPtr(); |
295 if (!buffer.setSizeAndColorProfile(size().width(), size().height(), colo rProfile())) { | 243 if (!buffer.setSizeAndColorProfile(size().width(), size().height(), colo rProfile())) { |
296 longjmp(JMPBUF(png), 1); | 244 longjmp(JMPBUF(png), 1); |
297 return; | 245 return; |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
402 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], 255); | 350 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], 255); |
403 } | 351 } |
404 } | 352 } |
405 | 353 |
406 if (alphaMask != 255 && !buffer.hasAlpha()) | 354 if (alphaMask != 255 && !buffer.hasAlpha()) |
407 buffer.setHasAlpha(true); | 355 buffer.setHasAlpha(true); |
408 | 356 |
409 buffer.setPixelsChanged(true); | 357 buffer.setPixelsChanged(true); |
410 } | 358 } |
411 | 359 |
412 void PNGImageDecoder::complete() | 360 void PNGImageDecoder::complete() |
scroggo_chromium
2016/10/11 20:13:09
This method does nothing now. Does it still get ca
| |
413 { | 361 { |
414 if (m_frameBufferCache.isEmpty()) | 362 if (m_frameBufferCache.isEmpty()) |
415 return; | 363 return; |
416 | |
417 m_frameBufferCache[0].setStatus(ImageFrame::FrameComplete); | |
418 } | |
419 | |
420 inline bool isComplete(const PNGImageDecoder* decoder) | |
421 { | |
422 return decoder->frameIsCompleteAtIndex(0); | |
423 } | |
424 | |
425 void PNGImageDecoder::decode(bool onlySize) | |
426 { | |
427 if (failed()) | |
428 return; | |
429 | |
430 if (!m_reader) | |
431 m_reader = wrapUnique(new PNGImageReader(this, m_offset)); | |
432 | |
433 // If we couldn't decode the image but have received all the data, decoding | |
434 // has failed. | |
435 if (!m_reader->decode(*m_data, onlySize) && isAllDataReceived()) | |
436 setFailed(); | |
437 | |
438 // If decoding is done or failed, we don't need the PNGImageReader anymore. | |
439 if (isComplete(this) || failed()) | |
440 m_reader.reset(); | |
441 } | 364 } |
442 | 365 |
443 } // namespace blink | 366 } // namespace blink |
OLD | NEW |