Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(480)

Side by Side Diff: third_party/WebKit/Source/platform/image-decoders/png/PNGImageReader.cpp

Issue 2386453003: WIP: Implement APNG (Closed)
Patch Set: Revisit ImageFrame alpha setting. Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
1 /*
2 * Copyright (C) 2006 Apple Computer, Inc.
3 * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
4 *
5 * Portions are Copyright (C) 2001 mozilla.org
6 *
7 * Other contributors:
8 * Stuart Parmenter <stuart@mozilla.com>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 US A
23 *
24 * Alternatively, the contents of this file may be used under the terms
25 * of either the Mozilla Public License Version 1.1, found at
26 * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
27 * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
28 * (the "GPL"), in which case the provisions of the MPL or the GPL are
29 * applicable instead of those above. If you wish to allow use of your
30 * version of this file only under the terms of one of those two
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
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.
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.
37 */
38
39 #include "platform/image-decoders/png/PNGImageReader.h"
40
41 #include "platform/image-decoders/png/PNGImageDecoder.h"
42 #include "platform/image-decoders/FastSharedBufferReader.h"
43 #include "png.h"
44 #include "wtf/PtrUtil.h"
45 #include <memory>
46
47 #if !defined(PNG_LIBPNG_VER_MAJOR) || !defined(PNG_LIBPNG_VER_MINOR)
48 #error version error: compile against a versioned libpng.
49 #endif
50 #if USE(QCMSLIB)
51 #include "qcms.h"
52 #endif
53
54 #if PNG_LIBPNG_VER_MAJOR > 1 || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MIN OR >= 4)
55 #define JMPBUF(png_ptr) png_jmpbuf(png_ptr)
56 #else
57 #define JMPBUF(png_ptr) png_ptr->jmpbuf
58 #endif
59
60 namespace {
61
62 inline blink::PNGImageDecoder* imageDecoder(png_structp png)
63 {
64 return static_cast<blink::PNGImageDecoder*>(png_get_progressive_ptr(png));
65 }
66
67 void PNGAPI pngHeaderAvailable(png_structp png, png_infop)
68 {
69 imageDecoder(png)->headerAvailable();
70 }
71
72 void PNGAPI pngRowAvailable(png_structp png, png_bytep row,
73 png_uint_32 rowIndex, int state)
74 {
75 imageDecoder(png)->rowAvailable(row, rowIndex, state);
76 }
77
78 void PNGAPI pngComplete(png_structp png, png_infop)
79 {
80 imageDecoder(png)->complete();
81 }
82
83 void PNGAPI pngFailed(png_structp png, png_const_charp err)
84 {
85 longjmp(JMPBUF(png), 1);
86 }
87
88 } // namespace
89
90 namespace blink {
91
92 // This is the callback function for unknown PNG chunks, which is used to
93 // extract the animation chunks.
94 static int readAnimationChunk(png_structp png_ptr, png_unknown_chunkp chunk)
95 {
96 PNGImageReader* reader = (PNGImageReader*) png_get_user_chunk_ptr(png_ptr);
97 reader->parseAnimationChunk((const char*) chunk->name, chunk->data,
98 chunk->size);
99 return 1;
100 }
101
102 PNGImageReader::PNGImageReader(PNGImageDecoder* decoder, size_t initialOffset)
103 : m_decoder(decoder)
104 , m_initialOffset(initialOffset)
105 , m_readOffset(initialOffset)
106 , m_progressiveDecodeOffset(0)
107 , m_idatOffset(0)
108 , m_idatIsPartOfAnimation(false)
109 , m_isAnimated(false)
110 , m_parsedSignature(false)
111 , m_parseCompleted(false)
112 #if USE(QCMSLIB)
113 , m_rowBuffer()
114 #endif
115 {
116 m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0);
117 m_info = png_create_info_struct(m_png);
118 png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable,
119 pngRowAvailable, pngComplete);
120
121 // Keep the chunks which are of interest for APNG. We don't need to keep
122 // the fdAT chunks, since they are converted to IDAT's by the frame decoder.
123 png_byte apngChunks[] = {"acTL\0fcTL\0"};
124 png_set_keep_unknown_chunks(m_png, PNG_HANDLE_CHUNK_NEVER, apngChunks, 2);
125 png_set_read_user_chunk_fn(m_png, (png_voidp) this, readAnimationChunk);
126 }
127
128 PNGImageReader::~PNGImageReader()
129 {
130 png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
131 ASSERT(!m_png && !m_info);
132 }
133
134 // This method reads from the FastSharedBufferReader, starting at offset,
135 // and returns |length| bytes in the form of a pointer to a const png_byte*.
136 // This function is used to make it easy to access data from the reader in a
137 // png friendly way, and pass it to libpng for decoding.
138 //
139 // Pre-conditions before using this:
140 // - |reader|.size() >= |readOffset| + |length|
141 // - |buffer|.size() >= |length|
142 // - |length| <= |kBufferSize|
143 //
144 // The reason for the last two precondition is that currently the png signature
145 // plus IHDR chunk (8B + 25B = 33B) is the largest chunk that is read using this
146 // method. If the data is not consecutive, it is stored in |buffer|, which must
147 // have the size of (at least) |length|, but there's no need for it to be larger
148 // than |kBufferSize|.
149 static constexpr size_t kBufferSize = 33;
150 const png_byte* readAsConstPngBytep(const FastSharedBufferReader& reader,
151 size_t readOffset, size_t length,
152 char* buffer)
153 {
154 ASSERT(length <= kBufferSize);
155 return reinterpret_cast<const png_byte*>(
156 reader.getConsecutiveData(readOffset, length, buffer));
157 }
158
159 // This is used as a value for the byteLength of a frameInfo struct to
160 // indicate that it is the first frame, and we still need to set byteLength
161 // to the correct value as soon as the parser knows it. 1 is a safe value
162 // since the byteLength field of a frame is at least 12, in the case of an
163 // empty fdAT or IDAT chunk.
164 static constexpr size_t kFirstFrameIndicator = 1;
165
166 void PNGImageReader::decode(SegmentReader& data, size_t index)
167 {
168 if (index >= m_frameInfo.size())
169 return;
170
171 // When decoding by libpng fails in either the non-animated branch or the
172 // animated branch, the decoder needs to be set to the failed state.
173 if (setjmp(JMPBUF(m_png))) {
174 m_decoder->setFailed();
175 return;
176 }
177
178 // For non animated PNGs, resume decoding where we left off in parse(), at
179 // the beginning of the IDAT chunk. Recreating a png struct would either
180 // result in wasted work, by reprocessing all header bytes, or decoding the
181 // wrong data.
182 if (!m_isAnimated) {
183 m_progressiveDecodeOffset += processData(
184 data, m_frameInfo[0].startOffset + m_progressiveDecodeOffset, 0);
185 return;
186 }
187
188 // Progressive decoding is only done if both of the following are true:
189 // - It is the first frame, thus |index| == 0, AND
190 // - The byteLength of the first frame is not yet known, *or* it is known
191 // but we're only partway in a progressive decode, started earlier.
192 bool firstFrameLengthKnown = m_frameInfo[0].byteLength
193 != kFirstFrameIndicator;
194 bool progressiveDecodingAlreadyStarted = m_progressiveDecodeOffset > 0;
195 bool progressiveDecode = (index == 0
196 && (!firstFrameLengthKnown || progressiveDecodingAlreadyStarted));
197
198 // Initialize a new png struct for this frame. For a progressive decode of
199 // the first frame, we only need to do this once.
200 // @FIXME(joostouwerling) check if the existing png struct can be reused.
201 if (!progressiveDecode || !progressiveDecodingAlreadyStarted)
202 startFrameDecoding(data, index);
203
204 bool decodedFrameCompletely;
205 if (progressiveDecode) {
206 decodedFrameCompletely = progressivelyDecodeFirstFrame(data);
207 // If progressive decoding processed all data for this frame, reset
208 // |m_progressiveDecodeOffset|, so |progressiveDecodingAlreadyStarted|
209 // will be false for later calls to decode frame 0.
210 if (decodedFrameCompletely)
211 m_progressiveDecodeOffset = 0;
212 } else {
213 decodeFrame(data, index);
214 // For a non-progressive decode, we already have all the data we are
215 // going to get, so consider the frame complete.
216 decodedFrameCompletely = true;
217 }
218
219 // Send the IEND chunk if the frame is completely decoded, so the complete
220 // callback in |m_decoder| will be called.
221 if (decodedFrameCompletely)
222 endFrameDecoding();
223 }
224
225 void PNGImageReader::startFrameDecoding(SegmentReader& data, size_t index)
226 {
227 // Each frame is processed as if it were a complete, single frame png image.
228 // To accomplish this, destroy the current |m_png| and |m_info| structs and
229 // create new ones. CRC errors are ignored, so fdAT chunks can be processed
230 // as IDATs without recalculating the CRC value.
231 png_destroy_read_struct(m_png ? &m_png : 0, m_info ? &m_info : 0, 0);
232 m_png = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, pngFailed, 0);
233 m_info = png_create_info_struct(m_png);
234 png_set_crc_action(m_png, PNG_CRC_QUIET_USE, PNG_CRC_QUIET_USE);
235 png_set_progressive_read_fn(m_png, m_decoder, pngHeaderAvailable,
236 pngRowAvailable, pngComplete);
237
238 // If the frame is the size of the whole image, we don't need to modify any
239 // data in the IHDR chunk. This means it suffices to re-process all header
240 // data up to the first frame, for mimicking a png image.
241 const IntRect& frameRect = m_frameInfo[index].frameRect;
242 if (frameRect.location() == IntPoint()
243 && frameRect.size() == m_decoder->size()) {
244 processData(data, m_initialOffset, m_idatOffset);
245 return;
246 }
247
248 // Process the IHDR chunk, but change the width and height so it reflects
249 // the frame's width and height. Image Decoder will apply the x,y offset.
250 // This step is omitted if the width and height are equal to the image size,
251 // which is done in the block above.
252 FastSharedBufferReader reader(&data);
253 char readBuffer[kBufferSize];
254
255 // |headerSize| is equal to |kBufferSize|, but adds more semantic insight.
256 constexpr size_t headerSize = 33;
257 png_byte header[headerSize];
258 const png_byte* chunk = readAsConstPngBytep(reader, m_initialOffset,
259 headerSize, readBuffer);
260 memcpy(header, chunk, headerSize);
261
262 // Write the unclipped width and height. Clipping happens in the decoder.
263 png_save_uint_32(header + 16, frameRect.width());
264 png_save_uint_32(header + 20, frameRect.height());
265 png_process_data(m_png, m_info, header, headerSize);
266
267 // Process the rest of the header chunks. Start after the PNG signature and
268 // IHDR chunk, 33B, and process up to the first data chunk. The number of
269 // bytes up to the first data chunk is stored in |m_idatOffset|.
270 processData(data, m_initialOffset + headerSize, m_idatOffset - headerSize);
271 }
272
273 // Determine if the bytes 4 to 7 of |chunk| indicate that it is a |tag| chunk.
274 // - The length of |chunk| must be >= 8
275 // - The length of |tag| must be = 4
276 static inline bool isChunk(const png_byte* chunk, const char* tag)
277 {
278 return memcmp(chunk + 4, tag, 4) == 0;
279 }
280
281 bool PNGImageReader::progressivelyDecodeFirstFrame(SegmentReader& data)
282 {
283 FastSharedBufferReader reader(&data);
284 char readBuffer[8]; // large enough to identify a chunk.
285 size_t offset = m_frameInfo[0].startOffset;
286
287 // Loop while there is enough data to do progressive decoding.
288 while (data.size() >= offset + 8) {
289
290 // At the beginning of each loop, the offset is at the start of a chunk.
291 const png_byte* chunk = readAsConstPngBytep(reader, offset, 8,
292 readBuffer);
293 const png_uint_32 length = png_get_uint_32(chunk);
294
295 // When an fcTL or IEND chunk is encountered, the frame data has ended.
296 // Return true, since all frame data is decoded.
297 if (isChunk(chunk, "fcTL") || isChunk(chunk, "IEND"))
298 return true;
299
300 // If this chunk was already decoded, move on to the next.
301 if (m_progressiveDecodeOffset >= offset + length + 12) {
302 offset += length + 12;
303 continue;
304 }
305
306 // At this point, three scenarios are possible:
307 // 1) Some bytes of this chunk were already decoded in a previous call,
308 // so we need to continue from there.
309 // 2) This is an fdAT chunk, so we need to convert it to an IDAT chunk
310 // before we can decode it.
311 // 3) This is any other chunk, most likely an IDAT chunk.
312 //
313 // In each scenario, we want to decode as much data as possible. In each
314 // one, do the scenario specific work and set |offset| to where decoding
315 // needs to continue. From there, decode until the end of the chunk, if
316 // possible. If the whole chunk is decoded, continue to the next loop.
317 // Otherwise, store how far we've come in |m_progressiveDecodeOffset| and
318 // return false to indicate to the caller that the frame is partially
319 // decoded.
320
321 size_t endOffsetChunk = offset + length + 12;
322
323 // Scenario 1: |m_progressiveDecodeOffset| is ahead of the chunk tag.
324 if (m_progressiveDecodeOffset >= offset + 8) {
325 offset = m_progressiveDecodeOffset;
326
327 // Scenario 2: we need to convert the fdAT to an IDAT chunk. For an
328 // explanation of the numbers, see the comments in decodeFrame().
329 } else if (isChunk(chunk, "fdAT")) {
330 png_byte chunkIDAT[] = {0, 0, 0, 0, 'I', 'D', 'A', 'T'};
331 png_save_uint_32(chunkIDAT, length - 4);
332 png_process_data(m_png, m_info, chunkIDAT, 8);
333 // Skip the sequence number
334 offset += 12;
335
336 // Scenario 3: for any other chunk type, process the first 8 bytes.
337 } else {
338 png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
339 offset += 8;
340 }
341
342 size_t bytesLeftInChunk = endOffsetChunk - offset;
343 size_t bytesDecoded = processData(data, offset, bytesLeftInChunk);
344 m_progressiveDecodeOffset = offset + bytesDecoded;
345 if (bytesDecoded < bytesLeftInChunk)
346 return false;
347 offset += bytesDecoded;
348 }
349
350 return false;
351 }
352
353 void PNGImageReader::decodeFrame(SegmentReader& data, size_t index)
354 {
355 // From the frame info that was gathered during parsing, it is known at
356 // what offset the frame data starts and how many bytes are in the stream
357 // before the frame ends. Using this, we process all chunks that fall in
358 // this interval. We catch every fdAT chunk and transform it to an IDAT
359 // chunk, so libpng will decode it like a non-animated PNG image.
360 size_t offset = m_frameInfo[index].startOffset;
361 size_t endOffset = offset + m_frameInfo[index].byteLength;
362 char readBuffer[8];
363 FastSharedBufferReader reader(&data);
364
365 while (offset < endOffset) {
366 const png_byte* chunk = readAsConstPngBytep(reader, offset, 8, readBuffer);
367 const png_uint_32 length = png_get_uint_32(chunk);
368 if (isChunk(chunk, "fdAT")) {
369 // An fdAT chunk is build up as follows:
370 // - |length| (4B)
371 // - fdAT tag (4B)
372 // - sequence number (4B)
373 // - frame data (|length| - 4B)
374 // - CRC (4B)
375 // Thus, to reformat this into an IDAT chunk, we need to:
376 // - write |length| - 4 as the new length, since the sequence number
377 // must be removed.
378 // - change the tag to IDAT.
379 // - omit the sequence number from the data part of the chunk.
380 png_byte chunkIDAT[] = {0, 0, 0, 0, 'I', 'D', 'A', 'T'};
381 png_save_uint_32(chunkIDAT, length - 4);
382 png_process_data(m_png, m_info, chunkIDAT, 8);
383 // The frame data and the CRC span |length| bytes, so skip the
384 // sequence number and process |length| bytes to decode the frame.
385 processData(data, offset + 12, length);
386 } else {
387 png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
388 processData(data, offset + 8, length + 4);
389 }
390 offset += 12 + length;
391 }
392 }
393
394 void PNGImageReader::endFrameDecoding()
395 {
396 png_byte IEND[12] = {0, 0, 0, 0, 'I', 'E', 'N', 'D', 174, 66, 96, 130};
397 png_process_data(m_png, m_info, IEND, 12);
398 }
399
400 bool PNGImageReader::parse(SegmentReader& data,
401 PNGImageDecoder::PNGParseQuery query)
402 {
403 if (m_parseCompleted)
404 return true;
405
406 if (setjmp(JMPBUF(m_png)))
407 return m_decoder->setFailed();
408
409 // If the size has not been parsed, do that first, since it's necessary
410 // for both the Size and MetaData query. If parseSize returns false,
411 // it failed because of a lack of data so we can return false at this point.
412 if (!m_decoder->isDecodedSizeAvailable() && !parseSize(data))
413 return false;
414
415 if (query == PNGImageDecoder::PNGParseQuery::PNGSizeQuery)
416 return m_decoder->isDecodedSizeAvailable();
417
418 // For non animated images (identified by no acTL chunk before the IDAT),
419 // we create one frame. This saves some processing time since we don't need
420 // to go over the stream to find chunks.
421 if (!m_isAnimated) {
422 if (m_frameInfo.isEmpty()) {
423 FrameInfo frame;
424 // This needs to be plus 8 since the first 8 bytes of the IDAT chunk
425 // are already processed in parseSize().
426 frame.startOffset = m_readOffset + 8;
427 frame.frameRect = IntRect(IntPoint(), m_decoder->size());
428 frame.duration = 0;
429 frame.alphaBlend = ImageFrame::AlphaBlendSource::BlendAtopBgcolor;
430 frame.disposalMethod = ImageFrame::DisposalMethod::DisposeNotSpecified;
431 m_frameInfo.append(frame);
432 // When the png is not animated, no extra parsing is necessary.
433 m_parseCompleted = true;
434 }
435 return true;
436 }
437
438 FastSharedBufferReader reader(&data);
439 char readBuffer[kBufferSize];
440
441 // At this point, the query is FrameMetaDataQuery. Loop over the data and
442 // register all frames we can find. A frame is registered on the next fcTL
443 // chunk or when the IEND chunk is found. This ensures that only complete
444 // frames are reported, unless there is an error in the stream.
445 while (reader.size() >= m_readOffset + 8) {
446 const png_byte* chunk = readAsConstPngBytep(reader, m_readOffset, 8,
447 readBuffer);
448 const size_t length = png_get_uint_32(chunk);
449
450 // When we find an IDAT chunk (when the IDAT is part of the animation),
451 // or an fdAT chunk, and the readOffset field of the newFrame is 0,
452 // we have found the beginning of a new block of frame data.
453 const bool isFrameData = isChunk(chunk, "fdAT")
454 || (isChunk(chunk, "IDAT") && m_idatIsPartOfAnimation);
455 if (m_newFrame.startOffset == 0 && isFrameData) {
456 m_newFrame.startOffset = m_readOffset;
457
458 // When the |frameInfo| vector is empty, the first frame needs to be
459 // reported as soon as possible, even before all frame data is in
460 // |data|, so the first frame can be decoded progressively.
461 if (m_frameInfo.isEmpty()) {
462 m_newFrame.byteLength = kFirstFrameIndicator;
463 m_frameInfo.append(m_newFrame);
464 }
465
466 // An fcTL or IEND marks the end of the previous frame. Thus, the
467 // FrameInfo data in m_newFrame is submitted to the m_frameInfo vector.
468 //
469 // Furthermore, an fcTL chunk indicates a new frame is coming,
470 // so the m_newFrame variable is prepared accordingly by setting the
471 // readOffset field to 0, which indicates that the frame control info
472 // is available but that we haven't seen any frame data yet.
473 } else if (isChunk(chunk, "fcTL") || isChunk(chunk, "IEND")) {
474 if (m_newFrame.startOffset != 0) {
475 m_newFrame.byteLength = m_readOffset - m_newFrame.startOffset;
476 if (m_frameInfo[0].byteLength == kFirstFrameIndicator)
477 m_frameInfo[0].byteLength = m_newFrame.byteLength;
478 else
479 m_frameInfo.append(m_newFrame);
480
481 m_newFrame.startOffset = 0;
482 }
483
484 if (reader.size() < m_readOffset + 12 + length)
485 return false;
486
487 if (isChunk(chunk, "IEND")) {
488 // The PNG image ends at the IEND chunk, so all parsing is completed.
489 m_parseCompleted = true;
490 return true;
491 }
492
493 // At this point, we're dealing with an fcTL chunk, since the above
494 // statement already returns on IEND chunks.
495
496 // If the fcTL chunk is not 26 bytes long, we can't process it.
497 if (length != 26)
498 return m_decoder->setFailed();
499
500 chunk = readAsConstPngBytep(reader, m_readOffset + 8, length, readBuffer);
501 parseFrameInfo(chunk);
502
503 }
504 m_readOffset += 12 + length;
505 }
506 return false;
507 }
508
509 // If |length| == 0, read until the stream ends.
510 // @return: number of bytes processed.
511 size_t PNGImageReader::processData(SegmentReader& data, size_t offset,
512 size_t length)
513 {
514 const char* segment;
515 size_t totalProcessedBytes = 0;
516 while (size_t segmentLength = data.getSomeData(segment, offset)) {
517 if (length > 0 && segmentLength + totalProcessedBytes > length)
518 segmentLength = length - totalProcessedBytes;
519
520 png_process_data(m_png, m_info,
521 reinterpret_cast<png_byte*>(const_cast<char*>(segment)),
522 segmentLength);
523 offset += segmentLength;
524 totalProcessedBytes += segmentLength;
525 if (totalProcessedBytes == length)
526 return length;
527 }
528 return totalProcessedBytes;
529 }
530
531 // This methods reads through the stream until it has parsed the image size.
532 // @return true when it succeeds in parsing the size.
533 // false when:
534 // A) not enough data is provided
535 // B) decoding by libpng fails. In the this case, it will also call
536 // setFailed on m_decoder.
537 bool PNGImageReader::parseSize(SegmentReader& data)
538 {
539 FastSharedBufferReader reader(&data);
540 char readBuffer[kBufferSize];
541
542 // Process the PNG signature and the IHDR with libpng, such that this code
543 // does not need to be bothered with parsing the contents. This also enables
544 // the reader to use the existing headerAvailable callback in the decoder.
545 //
546 // When we already have decoded the signature, we don't need to do it again.
547 // By setting a flag for this we allow for byte by byte parsing.
548 if (!m_parsedSignature) {
549 if (reader.size() < m_readOffset + 8)
550 return false;
551
552 const png_byte* chunk = readAsConstPngBytep(reader, m_readOffset, 8,
553 readBuffer);
554 png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
555 m_readOffset += 8;
556 m_parsedSignature = true;
557 // Initialize the newFrame by setting the readOffset to 0.
558 m_newFrame.startOffset = 0;
559 }
560
561 // This loop peeks at the chunk tag until the IDAT chunk is found. When
562 // a different tag is encountered, pass it on to libpng for general parsing.
563 // We can peek at chunks by looking at the first 8 bytes, which contain the
564 // length and the chunk tag.
565 //
566 // When an fcTL (frame control) is encountered before the IDAT, the frame
567 // data in the IDAT chunk is part of the animation. This case is flagged
568 // and the frame info is stored by parsing the fcTL chunk.
569 while (reader.size() >= m_readOffset + 8) {
570 const png_byte* chunk = readAsConstPngBytep(reader, m_readOffset, 8,
571 readBuffer);
572 const png_uint_32 length = png_get_uint_32(chunk);
573
574 // If we encounter the IDAT chunk, we're done with the png header
575 // chunks. Indicate this to libpng by sending the beginning of the IDAT
576 // chunk, which will trigger libpng to call the headerAvailable
577 // callback on m_decoder. This provides the size to the decoder.
578 if (isChunk(chunk, "IDAT")) {
579 m_idatOffset = m_readOffset;
580 png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
581 return true;
582 }
583
584 // Consider the PNG image animated if an acTL chunk of the correct
585 // length is present. Parsing the acTL content is done by
586 // parseAnimationControl, called by libpng's png_process_data.
587 if (isChunk(chunk, "acTL") && length == 8)
588 m_isAnimated = true;
589
590 // We don't need to check for |length| here, because the decoder will
591 // fail later on for invalid fcTL chunks.
592 if (isChunk(chunk, "fcTL"))
593 m_idatIsPartOfAnimation = true;
594
595 // 12 is the length, tag and crc part of the chunk, which are all 4B.
596 if (reader.size() < m_readOffset + length + 12)
597 break;
598
599 png_process_data(m_png, m_info, const_cast<png_byte*>(chunk), 8);
600 processData(data, m_readOffset + 8, length + 4);
601 m_readOffset += length + 12;
602 }
603
604 // If we end up here, not enough data was available for the IDAT chunk
605 // So libpng would not have called headerAvailable yet.
606 return false;
607 }
608
609
610 void PNGImageReader::parseAnimationChunk(const char tag[],
611 const void* data_chunk,
612 size_t length)
613 {
614 const png_byte* data = static_cast<const png_byte*>(data_chunk);
615
616 // The number of frames as indicated in the animation control chunk (acTL)
617 // is ignored, and the number of frames that are actually present is used.
618 // For now, when the number of indicated frames is different from the
619 // number of supplied frames, the number of supplied frames is what is
620 // provided to the decoder. Therefore, it does not add any benefit of
621 // looking at the value of the indicated framecount. A note here is that
622 // there may be optimisations available, for example, prescaling vectors.
623 if (strcmp(tag, "acTL") == 0 && length == 8) {
624 png_uint_32 repetitionCount = png_get_uint_32(data + 4);
625 m_decoder->setRepetitionCount(repetitionCount);
626
627 // For fcTL, decoding fails if it does not have the correct length. It is
628 // impossible to make a guess about the frame if not all data is available.
629 // Use longjmp to get back to parse(), which is necessary since this method
630 // is called by a libpng callback.
631 } else if (strcmp(tag, "fcTL") == 0) {
632 if (length != 26)
633 longjmp(JMPBUF(m_png), 1);
634 parseFrameInfo(data);
635 }
636 }
637
638 void PNGImageReader::clearDecodeState(size_t frameIndex) {
639 if (frameIndex == 0)
640 m_progressiveDecodeOffset = 0;
641 }
642
643 size_t PNGImageReader::frameCount() const
644 {
645 return m_frameInfo.size();
646 }
647
648 const PNGImageReader::FrameInfo& PNGImageReader::frameInfo(size_t index) const
649 {
650 ASSERT(index < m_frameInfo.size());
651 return m_frameInfo[index];
652 }
653
654 // Extract the frame control info and store it in m_newFrame. The length check
655 // on the data chunk has been done in parseAnimationChunk.
656 // The fcTL specification used can be found at:
657 // https://wiki.mozilla.org/APNG_Specification#.60fcTL.60:_The_Frame_Control_Chu nk
658 void PNGImageReader::parseFrameInfo(const png_byte* data)
659 {
660 png_uint_32 width, height, xOffset, yOffset;
661 png_uint_16 delayNumerator, delayDenominator;
662 width = png_get_uint_32(data + 4);
663 height = png_get_uint_32(data + 8);
664 xOffset = png_get_uint_32(data + 12);
665 yOffset = png_get_uint_32(data + 16);
666 delayNumerator = png_get_uint_16(data + 20);
667 delayDenominator = png_get_uint_16(data + 22);
668
669 m_newFrame.duration = (delayDenominator == 0) ? delayNumerator * 10
670 : delayNumerator * 1000 / delayDenominator;
671 m_newFrame.frameRect = IntRect(xOffset, yOffset, width, height);
672 m_newFrame.disposalMethod = data[24];
673 m_newFrame.alphaBlend = data[25];
674 }
675
676 }; // namespace blink
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698