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 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR) | 45 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR) |
46 #error version error: compile against a versioned libpng. | 46 #error version error: compile against a versioned libpng. |
47 #endif | 47 #endif |
48 #if USE(QCMSLIB) | 48 #if USE(QCMSLIB) |
49 #include "qcms.h" | 49 #include "qcms.h" |
50 #endif | 50 #endif |
51 | 51 |
52 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MIN
OR >= 4) | 52 #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) | 53 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr) |
54 #else | 54 #else |
55 #define JMPBUF(png_ptr) png_ptr->jmpbuf | 55 #define JMPBUF(png_ptr) png_ptr->jmpbuf |
56 #endif | 56 #endif |
57 | 57 |
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 | 58 |
87 namespace blink { | 59 namespace blink { |
88 | 60 |
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) | 61 PNGImageDecoder::PNGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOp
tion colorOptions, size_t maxDecodedBytes, size_t offset) |
168 : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes) | 62 : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes) |
169 , m_offset(offset) | 63 , m_offset(offset) |
| 64 , m_metaDataDecoded(false) |
| 65 , m_frameCount(0) |
| 66 , m_currentFrame(0) |
| 67 , m_repetitionCount(cAnimationLoopOnce) |
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 parse(PNGParseQuery::PNGMetaDataQuery); |
| 79 return m_frameCount; |
| 80 } |
| 81 |
| 82 inline bool frameComplete(ImageFrame& frame) |
| 83 { |
| 84 return frame.getStatus() == ImageFrame::FrameComplete; |
| 85 } |
| 86 |
| 87 void PNGImageDecoder::decode(size_t index) |
| 88 { |
| 89 m_currentFrame = index; |
| 90 m_reader->decode(*m_data, index); |
| 91 } |
| 92 |
| 93 void PNGImageDecoder::parse(PNGParseQuery query) |
| 94 { |
| 95 if (failed()) |
| 96 return; |
| 97 |
| 98 if (!m_reader) |
| 99 m_reader = wrapUnique(new PNGImageReader(this, m_offset)); |
| 100 |
| 101 if (!m_reader->parse(*m_data, query) && isAllDataReceived()) |
| 102 setFailed(); |
| 103 |
| 104 if (query == PNGParseQuery::PNGMetaDataQuery) |
| 105 m_frameCount = m_reader->frameCount(); |
| 106 } |
| 107 |
| 108 void PNGImageDecoder::setRepetitionCount(size_t repetitionCount) |
| 109 { |
| 110 m_repetitionCount = (repetitionCount == 0) ? cAnimationLoopInfinite |
| 111 : repetitionCount; |
| 112 } |
| 113 |
| 114 // This matches the existing behavior to loop once if decoding fails, but this |
| 115 // should be changed to stick with m_repetitionCount to match other browsers. |
| 116 // See crbug.com/267883 |
| 117 int PNGImageDecoder::repetitionCount() const |
| 118 { |
| 119 if (m_metaDataDecoded && isAllDataReceived() && m_reader->frameCount() == 1) |
| 120 return cAnimationNone; |
| 121 return failed() ? cAnimationLoopOnce : m_repetitionCount; |
| 122 } |
| 123 |
| 124 // These are mapped according to: |
| 125 // https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chu
nk |
| 126 static inline ImageFrame::DisposalMethod getDisposalMethod(uint8_t disposalMetho
d) |
| 127 { |
| 128 switch (disposalMethod) { |
| 129 case 0: |
| 130 return ImageFrame::DisposalMethod::DisposeKeep; |
| 131 case 1: |
| 132 return ImageFrame::DisposalMethod::DisposeOverwriteBgcolor; |
| 133 case 2: |
| 134 return ImageFrame::DisposalMethod::DisposeOverwritePrevious; |
| 135 default: |
| 136 return ImageFrame::DisposalMethod::DisposeNotSpecified; |
| 137 } |
| 138 } |
| 139 |
| 140 |
| 141 // These are mapped according to: |
| 142 // https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chu
nk |
| 143 static inline ImageFrame::AlphaBlendSource getAlphaBlend(uint8_t alphaBlend) |
| 144 { |
| 145 if (alphaBlend == 1) |
| 146 return ImageFrame::AlphaBlendSource::BlendAtopPreviousFrame; |
| 147 return ImageFrame::AlphaBlendSource::BlendAtopBgcolor; |
| 148 } |
| 149 |
| 150 void PNGImageDecoder::initializeNewFrame(size_t index) |
| 151 { |
| 152 const PNGImageReader::FrameInfo& frameInfo = m_reader->frameInfo(index); |
| 153 ImageFrame* buffer = &m_frameBufferCache[index]; |
| 154 |
| 155 IntRect frameRectWithinSize = intersection(frameInfo.frameRect, |
| 156 {IntPoint(), size()}); |
| 157 buffer->setOriginalFrameRect(frameRectWithinSize); |
| 158 buffer->setDuration(frameInfo.duration); |
| 159 buffer->setDisposalMethod(getDisposalMethod(frameInfo.disposalMethod)); |
| 160 buffer->setAlphaBlendSource(getAlphaBlend(frameInfo.alphaBlend)); |
| 161 } |
| 162 |
177 void PNGImageDecoder::headerAvailable() | 163 void PNGImageDecoder::headerAvailable() |
178 { | 164 { |
179 png_structp png = m_reader->pngPtr(); | 165 png_structp png = m_reader->pngPtr(); |
180 png_infop info = m_reader->infoPtr(); | 166 png_infop info = m_reader->infoPtr(); |
181 png_uint_32 width = png_get_image_width(png, info); | 167 png_uint_32 width = png_get_image_width(png, info); |
182 png_uint_32 height = png_get_image_height(png, info); | 168 png_uint_32 height = png_get_image_height(png, info); |
183 | 169 |
184 // Protect against large PNGs. See http://bugzil.la/251381 for more details. | 170 // Only set the size of the image once. Since single frames also use this |
185 const unsigned long maxPNGSize = 1000000UL; | 171 // method, we don't want them to override the size to their frame rect. |
186 if (width > maxPNGSize || height > maxPNGSize) { | 172 if (!isDecodedSizeAvailable()) { |
187 longjmp(JMPBUF(png), 1); | 173 // Protect against large PNGs. See http://bugzil.la/251381 for more deta
ils. |
188 return; | 174 const unsigned long maxPNGSize = 1000000UL; |
189 } | 175 if (width > maxPNGSize || height > maxPNGSize) { |
| 176 longjmp(JMPBUF(png), 1); |
| 177 return; |
| 178 } |
190 | 179 |
191 // Set the image size now that the image header is available. | 180 // Set the image size now that the image header is available. |
192 if (!setSize(width, height)) { | 181 if (!setSize(width, height)) { |
193 longjmp(JMPBUF(png), 1); | 182 longjmp(JMPBUF(png), 1); |
194 return; | 183 return; |
| 184 } |
195 } | 185 } |
196 | 186 |
197 int bitDepth, colorType, interlaceType, compressionType, filterType, channel
s; | 187 int bitDepth, colorType, interlaceType, compressionType, filterType, channel
s; |
198 png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceTy
pe, &compressionType, &filterType); | 188 png_get_IHDR(png, info, &width, &height, &bitDepth, &colorType, &interlaceTy
pe, &compressionType, &filterType); |
199 | 189 |
200 // The options we set here match what Mozilla does. | 190 // The options we set here match what Mozilla does. |
201 | 191 |
202 // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA. | 192 // Expand to ensure we use 24-bit for RGB and 32-bit for RGBA. |
203 if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY
&& bitDepth < 8)) | 193 if (colorType == PNG_COLOR_TYPE_PALETTE || (colorType == PNG_COLOR_TYPE_GRAY
&& bitDepth < 8)) |
204 png_set_expand(png); | 194 png_set_expand(png); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
263 // Tell libpng to send us rows for interlaced pngs. | 253 // Tell libpng to send us rows for interlaced pngs. |
264 if (interlaceType == PNG_INTERLACE_ADAM7) | 254 if (interlaceType == PNG_INTERLACE_ADAM7) |
265 png_set_interlace_handling(png); | 255 png_set_interlace_handling(png); |
266 | 256 |
267 // Update our info now. | 257 // Update our info now. |
268 png_read_update_info(png, info); | 258 png_read_update_info(png, info); |
269 channels = png_get_channels(png, info); | 259 channels = png_get_channels(png, info); |
270 ASSERT(channels == 3 || channels == 4); | 260 ASSERT(channels == 3 || channels == 4); |
271 | 261 |
272 m_reader->setHasAlpha(channels == 4); | 262 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 } | 263 } |
285 | 264 |
286 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex,
int) | 265 void PNGImageDecoder::rowAvailable(unsigned char* rowBuffer, unsigned rowIndex,
int) |
287 { | 266 { |
| 267 |
288 if (m_frameBufferCache.isEmpty()) | 268 if (m_frameBufferCache.isEmpty()) |
289 return; | 269 return; |
290 | 270 |
291 // Initialize the framebuffer if needed. | 271 // Initialize the framebuffer if needed. |
292 ImageFrame& buffer = m_frameBufferCache[0]; | 272 ImageFrame& buffer = m_frameBufferCache[m_currentFrame]; |
293 if (buffer.getStatus() == ImageFrame::FrameEmpty) { | 273 if (buffer.getStatus() == ImageFrame::FrameEmpty) { |
294 png_structp png = m_reader->pngPtr(); | 274 png_structp png = m_reader->pngPtr(); |
295 if (!buffer.setSizeAndColorProfile(size().width(), size().height(), colo
rProfile())) { | 275 if (!buffer.setSizeAndColorProfile(size().width(), size().height(), colo
rProfile())) { |
296 longjmp(JMPBUF(png), 1); | 276 longjmp(JMPBUF(png), 1); |
297 return; | 277 return; |
298 } | 278 } |
299 | 279 |
300 unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3; | 280 unsigned colorChannels = m_reader->hasAlpha() ? 4 : 3; |
301 if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr
())) { | 281 if (PNG_INTERLACE_ADAM7 == png_get_interlace_type(png, m_reader->infoPtr
())) { |
302 m_reader->createInterlaceBuffer(colorChannels * size().width() * siz
e().height()); | 282 m_reader->createInterlaceBuffer(colorChannels * size().width() * siz
e().height()); |
303 if (!m_reader->interlaceBuffer()) { | 283 if (!m_reader->interlaceBuffer()) { |
304 longjmp(JMPBUF(png), 1); | 284 longjmp(JMPBUF(png), 1); |
305 return; | 285 return; |
306 } | 286 } |
307 } | 287 } |
308 | 288 |
309 #if USE(QCMSLIB) | 289 #if USE(QCMSLIB) |
310 if (colorTransform()) { | 290 if (colorTransform()) { |
311 m_reader->createRowBuffer(colorChannels * size().width()); | 291 m_reader->createRowBuffer(colorChannels * size().width()); |
312 if (!m_reader->rowBuffer()) { | 292 if (!m_reader->rowBuffer()) { |
313 longjmp(JMPBUF(png), 1); | 293 longjmp(JMPBUF(png), 1); |
314 return; | 294 return; |
315 } | 295 } |
316 } | 296 } |
317 #endif | 297 #endif |
318 buffer.setStatus(ImageFrame::FramePartial); | 298 buffer.setStatus(ImageFrame::FramePartial); |
319 buffer.setHasAlpha(false); | 299 buffer.setHasAlpha(false); |
| 300 } |
320 | 301 |
321 // For PNGs, the frame always fills the entire image. | 302 // This frameRect is already clipped, so that it fits within the size of the |
322 buffer.setOriginalFrameRect(IntRect(IntPoint(), size())); | 303 // image. This is done in initializeNewFrame() after a frameCount() call. |
323 } | 304 const IntRect& frameRect = buffer.originalFrameRect(); |
324 | 305 |
325 /* libpng comments (here to explain what follows). | 306 /* libpng comments (here to explain what follows). |
326 * | 307 * |
327 * this function is called for every row in the image. If the | 308 * this function is called for every row in the image. If the |
328 * image is interlacing, and you turned on the interlace handler, | 309 * image is interlacing, and you turned on the interlace handler, |
329 * this function will be called for every row in every pass. | 310 * this function will be called for every row in every pass. |
330 * Some of these rows will not be changed from the previous pass. | 311 * Some of these rows will not be changed from the previous pass. |
331 * When the row is not changed, the new_row variable will be NULL. | 312 * When the row is not changed, the new_row variable will be NULL. |
332 * The rows and passes are called in order, so you don't really | 313 * The rows and passes are called in order, so you don't really |
333 * need the row_num and pass, but I'm supplying them because it | 314 * need the row_num and pass, but I'm supplying them because it |
334 * may make your life easier. | 315 * may make your life easier. |
335 */ | 316 */ |
336 | 317 |
337 // Nothing to do if the row is unchanged, or the row is outside | 318 // Nothing to do if the row is unchanged, or the row is outside |
338 // the image bounds: libpng may send extra rows, ignore them to | 319 // the image bounds: libpng may send extra rows, ignore them to |
339 // make our lives easier. | 320 // make our lives easier. |
340 if (!rowBuffer) | 321 if (!rowBuffer) |
341 return; | 322 return; |
342 int y = rowIndex; | 323 int y = rowIndex + frameRect.y(); |
343 if (y < 0 || y >= size().height()) | 324 if (y < 0 || y >= size().height()) |
344 return; | 325 return; |
345 | 326 |
346 /* libpng comments (continued). | 327 /* libpng comments (continued). |
347 * | 328 * |
348 * For the non-NULL rows of interlaced images, you must call | 329 * For the non-NULL rows of interlaced images, you must call |
349 * png_progressive_combine_row() passing in the row and the | 330 * png_progressive_combine_row() passing in the row and the |
350 * old row. You can call this function for NULL rows (it will | 331 * old row. You can call this function for NULL rows (it will |
351 * just return) and for non-interlaced images (it just does the | 332 * just return) and for non-interlaced images (it just does the |
352 * memcpy for you) if it will make the code easier. Thus, you | 333 * memcpy for you) if it will make the code easier. Thus, you |
(...skipping 20 matching lines...) Expand all Loading... |
373 | 354 |
374 #if USE(QCMSLIB) | 355 #if USE(QCMSLIB) |
375 if (qcms_transform* transform = colorTransform()) { | 356 if (qcms_transform* transform = colorTransform()) { |
376 qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width(
)); | 357 qcms_transform_data(transform, row, m_reader->rowBuffer(), size().width(
)); |
377 row = m_reader->rowBuffer(); | 358 row = m_reader->rowBuffer(); |
378 } | 359 } |
379 #endif | 360 #endif |
380 | 361 |
381 // Write the decoded row pixels to the frame buffer. The repetitive | 362 // Write the decoded row pixels to the frame buffer. The repetitive |
382 // form of the row write loops is for speed. | 363 // form of the row write loops is for speed. |
383 ImageFrame::PixelData* address = buffer.getAddr(0, y); | 364 ImageFrame::PixelData* address = buffer.getAddr(frameRect.x(), y); |
384 unsigned alphaMask = 255; | 365 unsigned alphaMask = 255; |
385 int width = size().width(); | |
386 | 366 |
387 png_bytep pixel = row; | 367 png_bytep pixel = row; |
388 if (hasAlpha) { | 368 if (hasAlpha) { |
389 if (buffer.premultiplyAlpha()) { | 369 if (buffer.premultiplyAlpha()) { |
390 for (int x = 0; x < width; ++x, pixel += 4) { | 370 for (int x = frameRect.x(); x < frameRect.maxX(); ++x, pixel += 4) { |
391 buffer.setRGBAPremultiply(address++, pixel[0], pixel[1], pixel[2
], pixel[3]); | 371 buffer.setRGBAPremultiply(address++, pixel[0], pixel[1], pixel[2
], pixel[3]); |
392 alphaMask &= pixel[3]; | 372 alphaMask &= pixel[3]; |
393 } | 373 } |
394 } else { | 374 } else { |
395 for (int x = 0; x < width; ++x, pixel += 4) { | 375 for (int x = frameRect.x(); x < frameRect.maxX(); ++x, pixel += 4) { |
396 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], pixel
[3]); | 376 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], pixel
[3]); |
397 alphaMask &= pixel[3]; | 377 alphaMask &= pixel[3]; |
398 } | 378 } |
399 } | 379 } |
400 } else { | 380 } else { |
401 for (int x = 0; x < width; ++x, pixel += 3) { | 381 for (int x = frameRect.x(); x < frameRect.maxX(); ++x, pixel += 3) { |
402 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], 255); | 382 buffer.setRGBARaw(address++, pixel[0], pixel[1], pixel[2], 255); |
403 } | 383 } |
404 } | 384 } |
405 | 385 |
406 if (alphaMask != 255 && !buffer.hasAlpha()) | 386 if (alphaMask != 255 && !buffer.hasAlpha()) |
407 buffer.setHasAlpha(true); | 387 buffer.setHasAlpha(true); |
408 | 388 |
409 buffer.setPixelsChanged(true); | 389 buffer.setPixelsChanged(true); |
410 } | 390 } |
411 | 391 |
| 392 bool PNGImageDecoder::frameIsCompleteAtIndex(size_t index) const |
| 393 { |
| 394 // @TODO(joostouwerling): show complete frames even if a later frame fails. |
| 395 if (failed()) |
| 396 return false; |
| 397 if (index >= m_frameBufferCache.size()) |
| 398 return false; |
| 399 if (index == 0) |
| 400 return ImageDecoder::frameIsCompleteAtIndex(index); |
| 401 return true; |
| 402 } |
| 403 |
| 404 float PNGImageDecoder::frameDurationAtIndex(size_t index) const |
| 405 { |
| 406 return (index < m_frameBufferCache.size() ? |
| 407 m_frameBufferCache[index].duration() : 0); |
| 408 } |
| 409 |
412 void PNGImageDecoder::complete() | 410 void PNGImageDecoder::complete() |
413 { | 411 { |
414 if (m_frameBufferCache.isEmpty()) | 412 if (m_frameBufferCache.isEmpty()) |
415 return; | 413 return; |
416 | 414 m_frameBufferCache[m_currentFrame].setStatus(ImageFrame::FrameComplete); |
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 } | 415 } |
442 | 416 |
443 } // namespace blink | 417 } // namespace blink |
OLD | NEW |