OLD | NEW |
| (Empty) |
1 /* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ | |
2 /* ***** BEGIN LICENSE BLOCK ***** | |
3 * Version: MPL 1.1/GPL 2.0/LGPL 2.1 | |
4 * | |
5 * The contents of this file are subject to the Mozilla Public License Version | |
6 * 1.1 (the "License"); you may not use this file except in compliance with | |
7 * the License. You may obtain a copy of the License at | |
8 * http://www.mozilla.org/MPL/ | |
9 * | |
10 * Software distributed under the License is distributed on an "AS IS" basis, | |
11 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License | |
12 * for the specific language governing rights and limitations under the | |
13 * License. | |
14 * | |
15 * The Original Code is mozilla.org code. | |
16 * | |
17 * The Initial Developer of the Original Code is | |
18 * Netscape Communications Corporation. | |
19 * Portions created by the Initial Developer are Copyright (C) 1998 | |
20 * the Initial Developer. All Rights Reserved. | |
21 * | |
22 * Contributor(s): | |
23 * Chris Saari <saari@netscape.com> | |
24 * Apple Computer | |
25 * | |
26 * Alternatively, the contents of this file may be used under the terms of | |
27 * either the GNU General Public License Version 2 or later (the "GPL"), or | |
28 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), | |
29 * in which case the provisions of the GPL or the LGPL are applicable instead | |
30 * of those above. If you wish to allow use of your version of this file only | |
31 * under the terms of either the GPL or the LGPL, and not to allow others to | |
32 * use your version of this file under the terms of the MPL, indicate your | |
33 * decision by deleting the provisions above and replace them with the notice | |
34 * and other provisions required by the GPL or the LGPL. If you do not delete | |
35 * the provisions above, a recipient may use your version of this file under | |
36 * the terms of any one of the MPL, the GPL or the LGPL. | |
37 * | |
38 * ***** END LICENSE BLOCK ***** */ | |
39 | |
40 /* | |
41 The Graphics Interchange Format(c) is the copyright property of CompuServe | |
42 Incorporated. Only CompuServe Incorporated is authorized to define, redefine, | |
43 enhance, alter, modify or change in any way the definition of the format. | |
44 | |
45 CompuServe Incorporated hereby grants a limited, non-exclusive, royalty-free | |
46 license for the use of the Graphics Interchange Format(sm) in computer | |
47 software; computer software utilizing GIF(sm) must acknowledge ownership of the | |
48 Graphics Interchange Format and its Service Mark by CompuServe Incorporated, in | |
49 User and Technical Documentation. Computer software utilizing GIF, which is | |
50 distributed or may be distributed without User or Technical Documentation must | |
51 display to the screen or printer a message acknowledging ownership of the | |
52 Graphics Interchange Format and the Service Mark by CompuServe Incorporated; in | |
53 this case, the acknowledgement may be displayed in an opening screen or leading | |
54 banner, or a closing screen or trailing banner. A message such as the following | |
55 may be used: | |
56 | |
57 "The Graphics Interchange Format(c) is the Copyright property of | |
58 CompuServe Incorporated. GIF(sm) is a Service Mark property of | |
59 CompuServe Incorporated." | |
60 | |
61 For further information, please contact : | |
62 | |
63 CompuServe Incorporated | |
64 Graphics Technology Department | |
65 5000 Arlington Center Boulevard | |
66 Columbus, Ohio 43220 | |
67 U. S. A. | |
68 | |
69 CompuServe Incorporated maintains a mailing list with all those individuals and | |
70 organizations who wish to receive copies of this document when it is corrected | |
71 or revised. This service is offered free of charge; please provide us with your | |
72 mailing address. | |
73 */ | |
74 | |
75 #include "GIFImageReader.h" | |
76 #include "SkColorPriv.h" | |
77 #include "SkGifCodec.h" | |
78 | |
79 #include <algorithm> | |
80 #include <string.h> | |
81 | |
82 | |
83 // GETN(n, s) requests at least 'n' bytes available from 'q', at start of state
's'. | |
84 // | |
85 // Note, the hold will never need to be bigger than 256 bytes to gather up in th
e hold, | |
86 // as each GIF block (except colormaps) can never be bigger than 256 bytes. | |
87 // Colormaps are directly copied in the resp. global_colormap or dynamically all
ocated local_colormap. | |
88 // So a fixed buffer in GIFImageReader is good enough. | |
89 // This buffer is only needed to copy left-over data from one GifWrite call to t
he next | |
90 #define GETN(n, s) \ | |
91 do { \ | |
92 m_bytesToConsume = (n); \ | |
93 m_state = (s); \ | |
94 } while (0) | |
95 | |
96 // Get a 16-bit value stored in little-endian format. | |
97 #define GETINT16(p) ((p)[1]<<8|(p)[0]) | |
98 | |
99 // Send the data to the display front-end. | |
100 bool GIFLZWContext::outputRow(const unsigned char* rowBegin) | |
101 { | |
102 int drowStart = irow; | |
103 int drowEnd = irow; | |
104 | |
105 // Haeberli-inspired hack for interlaced GIFs: Replicate lines while | |
106 // displaying to diminish the "venetian-blind" effect as the image is | |
107 // loaded. Adjust pixel vertical positions to avoid the appearance of the | |
108 // image crawling up the screen as successive passes are drawn. | |
109 if (m_frameContext->progressiveDisplay() && m_frameContext->interlaced() &&
ipass < 4) { | |
110 unsigned rowDup = 0; | |
111 unsigned rowShift = 0; | |
112 | |
113 switch (ipass) { | |
114 case 1: | |
115 rowDup = 7; | |
116 rowShift = 3; | |
117 break; | |
118 case 2: | |
119 rowDup = 3; | |
120 rowShift = 1; | |
121 break; | |
122 case 3: | |
123 rowDup = 1; | |
124 rowShift = 0; | |
125 break; | |
126 default: | |
127 break; | |
128 } | |
129 | |
130 drowStart -= rowShift; | |
131 drowEnd = drowStart + rowDup; | |
132 | |
133 // Extend if bottom edge isn't covered because of the shift upward. | |
134 if (((m_frameContext->height() - 1) - drowEnd) <= rowShift) | |
135 drowEnd = m_frameContext->height() - 1; | |
136 | |
137 // Clamp first and last rows to upper and lower edge of image. | |
138 if (drowStart < 0) | |
139 drowStart = 0; | |
140 | |
141 if ((unsigned)drowEnd >= m_frameContext->height()) | |
142 drowEnd = m_frameContext->height() - 1; | |
143 } | |
144 | |
145 // Protect against too much image data. | |
146 if ((unsigned)drowStart >= m_frameContext->height()) | |
147 return true; | |
148 | |
149 // CALLBACK: Let the client know we have decoded a row. | |
150 if (!m_client->haveDecodedRow(m_frameContext->frameId(), rowBegin, | |
151 drowStart, drowEnd - drowStart + 1, m_frameContext->progressiveDisplay()
&& m_frameContext->interlaced() && ipass > 1)) | |
152 return false; | |
153 | |
154 if (!m_frameContext->interlaced()) | |
155 irow++; | |
156 else { | |
157 do { | |
158 switch (ipass) { | |
159 case 1: | |
160 irow += 8; | |
161 if (irow >= m_frameContext->height()) { | |
162 ipass++; | |
163 irow = 4; | |
164 } | |
165 break; | |
166 | |
167 case 2: | |
168 irow += 8; | |
169 if (irow >= m_frameContext->height()) { | |
170 ipass++; | |
171 irow = 2; | |
172 } | |
173 break; | |
174 | |
175 case 3: | |
176 irow += 4; | |
177 if (irow >= m_frameContext->height()) { | |
178 ipass++; | |
179 irow = 1; | |
180 } | |
181 break; | |
182 | |
183 case 4: | |
184 irow += 2; | |
185 if (irow >= m_frameContext->height()) { | |
186 ipass++; | |
187 irow = 0; | |
188 } | |
189 break; | |
190 | |
191 default: | |
192 break; | |
193 } | |
194 } while (irow > (m_frameContext->height() - 1)); | |
195 } | |
196 return true; | |
197 } | |
198 | |
199 // Perform Lempel-Ziv-Welch decoding. | |
200 // Returns true if decoding was successful. In this case the block will have bee
n completely consumed and/or rowsRemaining will be 0. | |
201 // Otherwise, decoding failed; returns false in this case, which will always cau
se the GIFImageReader to set the "decode failed" flag. | |
202 bool GIFLZWContext::doLZW(const unsigned char* block, size_t bytesInBlock) | |
203 { | |
204 const size_t width = m_frameContext->width(); | |
205 | |
206 if (rowIter == rowBuffer.end()) | |
207 return true; | |
208 | |
209 for (const unsigned char* ch = block; bytesInBlock-- > 0; ch++) { | |
210 // Feed the next byte into the decoder's 32-bit input buffer. | |
211 datum += ((int) *ch) << bits; | |
212 bits += 8; | |
213 | |
214 // Check for underflow of decoder's 32-bit input buffer. | |
215 while (bits >= codesize) { | |
216 // Get the leading variable-length symbol from the data stream. | |
217 int code = datum & codemask; | |
218 datum >>= codesize; | |
219 bits -= codesize; | |
220 | |
221 // Reset the dictionary to its original state, if requested. | |
222 if (code == clearCode) { | |
223 codesize = m_frameContext->dataSize() + 1; | |
224 codemask = (1 << codesize) - 1; | |
225 avail = clearCode + 2; | |
226 oldcode = -1; | |
227 continue; | |
228 } | |
229 | |
230 // Check for explicit end-of-stream code. | |
231 if (code == (clearCode + 1)) { | |
232 // end-of-stream should only appear after all image data. | |
233 if (!rowsRemaining) | |
234 return true; | |
235 return false; | |
236 } | |
237 | |
238 const int tempCode = code; | |
239 unsigned short codeLength = 0; | |
240 if (code < avail) { | |
241 // This is a pre-existing code, so we already know what it | |
242 // encodes. | |
243 codeLength = suffixLength[code]; | |
244 rowIter += codeLength; | |
245 } else if (code == avail && oldcode != -1) { | |
246 // This is a new code just being added to the dictionary. | |
247 // It must encode the contents of the previous code, plus | |
248 // the first character of the previous code again. | |
249 codeLength = suffixLength[oldcode] + 1; | |
250 rowIter += codeLength; | |
251 *--rowIter = firstchar; | |
252 code = oldcode; | |
253 } else { | |
254 // This is an invalid code. The dictionary is just initialized | |
255 // and the code is incomplete. We don't know how to handle | |
256 // this case. | |
257 return false; | |
258 } | |
259 | |
260 while (code >= clearCode) { | |
261 *--rowIter = suffix[code]; | |
262 code = prefix[code]; | |
263 } | |
264 | |
265 *--rowIter = firstchar = suffix[code]; | |
266 | |
267 // Define a new codeword in the dictionary as long as we've read | |
268 // more than one value from the stream. | |
269 if (avail < MAX_DICTIONARY_ENTRIES && oldcode != -1) { | |
270 prefix[avail] = oldcode; | |
271 suffix[avail] = firstchar; | |
272 suffixLength[avail] = suffixLength[oldcode] + 1; | |
273 ++avail; | |
274 | |
275 // If we've used up all the codewords of a given length | |
276 // increase the length of codewords by one bit, but don't | |
277 // exceed the specified maximum codeword size. | |
278 if (!(avail & codemask) && avail < MAX_DICTIONARY_ENTRIES) { | |
279 ++codesize; | |
280 codemask += avail; | |
281 } | |
282 } | |
283 oldcode = tempCode; | |
284 rowIter += codeLength; | |
285 | |
286 // Output as many rows as possible. | |
287 unsigned char* rowBegin = rowBuffer.begin(); | |
288 for (; rowBegin + width <= rowIter; rowBegin += width) { | |
289 if (!outputRow(rowBegin)) | |
290 return false; | |
291 rowsRemaining--; | |
292 if (!rowsRemaining) | |
293 return true; | |
294 } | |
295 | |
296 if (rowBegin != rowBuffer.begin()) { | |
297 // Move the remaining bytes to the beginning of the buffer. | |
298 const size_t bytesToCopy = rowIter - rowBegin; | |
299 memcpy(&rowBuffer.front(), rowBegin, bytesToCopy); | |
300 rowIter = rowBuffer.begin() + bytesToCopy; | |
301 } | |
302 } | |
303 } | |
304 return true; | |
305 } | |
306 | |
307 sk_sp<SkColorTable> GIFColorMap::buildTable(SkColorType colorType, size_t transp
arentPixel) const | |
308 { | |
309 if (!m_isDefined) | |
310 return nullptr; | |
311 | |
312 const PackColorProc proc = choose_pack_color_proc(false, colorType); | |
313 if (m_table) { | |
314 if (transparentPixel > (unsigned) m_table->count() | |
315 || m_table->operator[](transparentPixel) == SK_ColorTRANSPARENT)
{ | |
316 if (proc == m_packColorProc) { | |
317 // This SkColorTable has already been built with the same transp
arent color and | |
318 // packing proc. Reuse it. | |
319 return m_table; | |
320 } | |
321 } | |
322 } | |
323 m_packColorProc = proc; | |
324 | |
325 SkASSERT(m_colors <= MAX_COLORS); | |
326 const uint8_t* srcColormap = m_rawData->bytes(); | |
327 SkPMColor colorStorage[MAX_COLORS]; | |
328 for (size_t i = 0; i < m_colors; i++) { | |
329 if (i == transparentPixel) { | |
330 colorStorage[i] = SK_ColorTRANSPARENT; | |
331 } else { | |
332 colorStorage[i] = proc(255, srcColormap[0], srcColormap[1], srcColor
map[2]); | |
333 } | |
334 srcColormap += BYTES_PER_COLORMAP_ENTRY; | |
335 } | |
336 for (size_t i = m_colors; i < MAX_COLORS; i++) { | |
337 colorStorage[i] = SK_ColorTRANSPARENT; | |
338 } | |
339 m_table = sk_sp<SkColorTable>(new SkColorTable(colorStorage, MAX_COLORS)); | |
340 return m_table; | |
341 } | |
342 | |
343 sk_sp<SkColorTable> GIFImageReader::getColorTable(SkColorType colorType, size_t
index) const { | |
344 if (index >= m_frames.size()) { | |
345 return nullptr; | |
346 } | |
347 | |
348 const GIFFrameContext* frameContext = m_frames[index].get(); | |
349 const GIFColorMap& localColorMap = frameContext->localColorMap(); | |
350 if (localColorMap.isDefined()) { | |
351 return localColorMap.buildTable(colorType, frameContext->transparentPixe
l()); | |
352 } | |
353 if (m_globalColorMap.isDefined()) { | |
354 return m_globalColorMap.buildTable(colorType, frameContext->transparentP
ixel()); | |
355 } | |
356 return nullptr; | |
357 } | |
358 | |
359 // Perform decoding for this frame. frameComplete will be true if the entire fra
me is decoded. | |
360 // Returns false if a decoding error occurred. This is a fatal error and causes
the GIFImageReader to set the "decode failed" flag. | |
361 // Otherwise, either not enough data is available to decode further than before,
or the new data has been decoded successfully; returns true in this case. | |
362 bool GIFFrameContext::decode(SkGifCodec* client, bool* frameComplete) | |
363 { | |
364 *frameComplete = false; | |
365 if (!m_lzwContext) { | |
366 // Wait for more data to properly initialize GIFLZWContext. | |
367 if (!isDataSizeDefined() || !isHeaderDefined()) | |
368 return true; | |
369 | |
370 m_lzwContext.reset(new GIFLZWContext(client, this)); | |
371 if (!m_lzwContext->prepareToDecode()) { | |
372 m_lzwContext.reset(); | |
373 return false; | |
374 } | |
375 | |
376 m_currentLzwBlock = 0; | |
377 } | |
378 | |
379 // Some bad GIFs have extra blocks beyond the last row, which we don't want
to decode. | |
380 while (m_currentLzwBlock < m_lzwBlocks.size() && m_lzwContext->hasRemainingR
ows()) { | |
381 if (!m_lzwContext->doLZW(reinterpret_cast<const unsigned char*>(m_lzwBlo
cks[m_currentLzwBlock]->data()), | |
382 m_lzwBlo
cks[m_currentLzwBlock]->size())) { | |
383 return false; | |
384 } | |
385 ++m_currentLzwBlock; | |
386 } | |
387 | |
388 // If this frame is data complete then the previous loop must have completel
y decoded all LZW blocks. | |
389 // There will be no more decoding for this frame so it's time to cleanup. | |
390 if (isComplete()) { | |
391 *frameComplete = true; | |
392 m_lzwContext.reset(); | |
393 } | |
394 return true; | |
395 } | |
396 | |
397 // Decode a frame. | |
398 // This method uses GIFFrameContext:decode() to decode the frame; decoding error
is reported to client as a critical failure. | |
399 // Return true if decoding has progressed. Return false if an error has occurred
. | |
400 bool GIFImageReader::decode(size_t frameIndex, bool* frameComplete) | |
401 { | |
402 GIFFrameContext* currentFrame = m_frames[frameIndex].get(); | |
403 | |
404 return currentFrame->decode(m_client, frameComplete); | |
405 } | |
406 | |
407 // Parse incoming GIF data stream into internal data structures. | |
408 // Return true if parsing has progressed or there is not enough data. | |
409 // Return false if a fatal error is encountered. | |
410 bool GIFImageReader::parse(GIFImageReader::GIFParseQuery query) | |
411 { | |
412 if (m_parseCompleted) { | |
413 return true; | |
414 } | |
415 | |
416 // GIFSizeQuery and GIFFrameCountQuery are negative, so this is only meaning
ful when >= 0. | |
417 const int lastFrameToParse = (int) query; | |
418 if (lastFrameToParse >= 0 && (int) m_frames.size() > lastFrameToParse | |
419 && m_frames[lastFrameToParse]->isComplete()) { | |
420 // We have already parsed this frame. | |
421 return true; | |
422 } | |
423 | |
424 while (true) { | |
425 const size_t bytesBuffered = m_streamBuffer.buffer(m_bytesToConsume); | |
426 if (bytesBuffered < m_bytesToConsume) { | |
427 // The stream does not yet have enough data. Mark that we need less
next time around, | |
428 // and return. | |
429 m_bytesToConsume -= bytesBuffered; | |
430 return true; | |
431 } | |
432 | |
433 switch (m_state) { | |
434 case GIFLZW: | |
435 SkASSERT(!m_frames.empty()); | |
436 // FIXME: All this copying might be wasteful for e.g. SkMemoryStream | |
437 m_frames.back()->addLzwBlock(m_streamBuffer.get(), m_streamBuffer.by
tesBuffered()); | |
438 GETN(1, GIFSubBlock); | |
439 break; | |
440 | |
441 case GIFLZWStart: { | |
442 SkASSERT(!m_frames.empty()); | |
443 m_frames.back()->setDataSize(this->getOneByte()); | |
444 GETN(1, GIFSubBlock); | |
445 break; | |
446 } | |
447 | |
448 case GIFType: { | |
449 const char* currentComponent = m_streamBuffer.get(); | |
450 | |
451 // All GIF files begin with "GIF87a" or "GIF89a". | |
452 if (!memcmp(currentComponent, "GIF89a", 6)) | |
453 m_version = 89; | |
454 else if (!memcmp(currentComponent, "GIF87a", 6)) | |
455 m_version = 87; | |
456 else { | |
457 // This prevents attempting to continue reading this invalid str
eam. | |
458 GETN(0, GIFDone); | |
459 return false; | |
460 } | |
461 GETN(7, GIFGlobalHeader); | |
462 break; | |
463 } | |
464 | |
465 case GIFGlobalHeader: { | |
466 const unsigned char* currentComponent = | |
467 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); | |
468 | |
469 // This is the height and width of the "screen" or frame into which | |
470 // images are rendered. The individual images can be smaller than | |
471 // the screen size and located with an origin anywhere within the | |
472 // screen. | |
473 // Note that we don't inform the client of the size yet, as it might | |
474 // change after we read the first frame's image header. | |
475 m_screenWidth = GETINT16(currentComponent); | |
476 m_screenHeight = GETINT16(currentComponent + 2); | |
477 | |
478 const size_t globalColorMapColors = 2 << (currentComponent[4] & 0x07
); | |
479 | |
480 if ((currentComponent[4] & 0x80) && globalColorMapColors > 0) { /* g
lobal map */ | |
481 m_globalColorMap.setNumColors(globalColorMapColors); | |
482 GETN(BYTES_PER_COLORMAP_ENTRY * globalColorMapColors, GIFGlobalC
olormap); | |
483 break; | |
484 } | |
485 | |
486 GETN(1, GIFImageStart); | |
487 break; | |
488 } | |
489 | |
490 case GIFGlobalColormap: { | |
491 m_globalColorMap.setRawData(m_streamBuffer.get(), m_streamBuffer.byt
esBuffered()); | |
492 GETN(1, GIFImageStart); | |
493 break; | |
494 } | |
495 | |
496 case GIFImageStart: { | |
497 const char currentComponent = m_streamBuffer.get()[0]; | |
498 | |
499 if (currentComponent == '!') { // extension. | |
500 GETN(2, GIFExtension); | |
501 break; | |
502 } | |
503 | |
504 if (currentComponent == ',') { // image separator. | |
505 GETN(9, GIFImageHeader); | |
506 break; | |
507 } | |
508 | |
509 // If we get anything other than ',' (image separator), '!' | |
510 // (extension), or ';' (trailer), there is extraneous data | |
511 // between blocks. The GIF87a spec tells us to keep reading | |
512 // until we find an image separator, but GIF89a says such | |
513 // a file is corrupt. We follow Mozilla's implementation and | |
514 // proceed as if the file were correctly terminated, so the | |
515 // GIF will display. | |
516 GETN(0, GIFDone); | |
517 break; | |
518 } | |
519 | |
520 case GIFExtension: { | |
521 const unsigned char* currentComponent = | |
522 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); | |
523 | |
524 size_t bytesInBlock = currentComponent[1]; | |
525 GIFState exceptionState = GIFSkipBlock; | |
526 | |
527 switch (*currentComponent) { | |
528 case 0xf9: | |
529 exceptionState = GIFControlExtension; | |
530 // The GIF spec mandates that the GIFControlExtension header blo
ck length is 4 bytes, | |
531 // and the parser for this block reads 4 bytes, so we must enfor
ce that the buffer | |
532 // contains at least this many bytes. If the GIF specifies a dif
ferent length, we | |
533 // allow that, so long as it's larger; the additional data will
simply be ignored. | |
534 bytesInBlock = std::max(bytesInBlock, static_cast<size_t>(4)); | |
535 break; | |
536 | |
537 // The GIF spec also specifies the lengths of the following two exte
nsions' headers | |
538 // (as 12 and 11 bytes, respectively). Because we ignore the plain t
ext extension entirely | |
539 // and sanity-check the actual length of the application extension h
eader before reading it, | |
540 // we allow GIFs to deviate from these values in either direction. T
his is important for | |
541 // real-world compatibility, as GIFs in the wild exist with applicat
ion extension headers | |
542 // that are both shorter and longer than 11 bytes. | |
543 case 0x01: | |
544 // ignoring plain text extension | |
545 break; | |
546 | |
547 case 0xff: | |
548 exceptionState = GIFApplicationExtension; | |
549 break; | |
550 | |
551 case 0xfe: | |
552 exceptionState = GIFConsumeComment; | |
553 break; | |
554 } | |
555 | |
556 if (bytesInBlock) | |
557 GETN(bytesInBlock, exceptionState); | |
558 else | |
559 GETN(1, GIFImageStart); | |
560 break; | |
561 } | |
562 | |
563 case GIFConsumeBlock: { | |
564 const unsigned char currentComponent = this->getOneByte(); | |
565 if (!currentComponent) | |
566 GETN(1, GIFImageStart); | |
567 else | |
568 GETN(currentComponent, GIFSkipBlock); | |
569 break; | |
570 } | |
571 | |
572 case GIFSkipBlock: { | |
573 GETN(1, GIFConsumeBlock); | |
574 break; | |
575 } | |
576 | |
577 case GIFControlExtension: { | |
578 const unsigned char* currentComponent = | |
579 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); | |
580 | |
581 addFrameIfNecessary(); | |
582 GIFFrameContext* currentFrame = m_frames.back().get(); | |
583 if (*currentComponent & 0x1) | |
584 currentFrame->setTransparentPixel(currentComponent[3]); | |
585 | |
586 // We ignore the "user input" bit. | |
587 | |
588 // NOTE: This relies on the values in the FrameDisposalMethod enum | |
589 // matching those in the GIF spec! | |
590 int rawDisposalMethod = ((*currentComponent) >> 2) & 0x7; | |
591 switch (rawDisposalMethod) { | |
592 case 1: | |
593 case 2: | |
594 case 3: | |
595 currentFrame->setDisposalMethod((SkCodecAnimation::DisposalMetho
d) rawDisposalMethod); | |
596 break; | |
597 case 4: | |
598 // Some specs say that disposal method 3 is "overwrite previous"
, others that setting | |
599 // the third bit of the field (i.e. method 4) is. We map both to
the same value. | |
600 currentFrame->setDisposalMethod(SkCodecAnimation::RestorePreviou
s_DisposalMethod); | |
601 break; | |
602 default: | |
603 // Other values use the default. | |
604 currentFrame->setDisposalMethod(SkCodecAnimation::Keep_DisposalM
ethod); | |
605 break; | |
606 } | |
607 currentFrame->setDelayTime(GETINT16(currentComponent + 1) * 10); | |
608 GETN(1, GIFConsumeBlock); | |
609 break; | |
610 } | |
611 | |
612 case GIFCommentExtension: { | |
613 const unsigned char currentComponent = this->getOneByte(); | |
614 if (currentComponent) | |
615 GETN(currentComponent, GIFConsumeComment); | |
616 else | |
617 GETN(1, GIFImageStart); | |
618 break; | |
619 } | |
620 | |
621 case GIFConsumeComment: { | |
622 GETN(1, GIFCommentExtension); | |
623 break; | |
624 } | |
625 | |
626 case GIFApplicationExtension: { | |
627 // Check for netscape application extension. | |
628 if (m_streamBuffer.bytesBuffered() == 11) { | |
629 const unsigned char* currentComponent = | |
630 reinterpret_cast<const unsigned char*>(m_streamBuffer.get())
; | |
631 | |
632 if (!memcmp(currentComponent, "NETSCAPE2.0", 11) || !memcmp(curr
entComponent, "ANIMEXTS1.0", 11)) | |
633 GETN(1, GIFNetscapeExtensionBlock); | |
634 } | |
635 | |
636 if (m_state != GIFNetscapeExtensionBlock) | |
637 GETN(1, GIFConsumeBlock); | |
638 break; | |
639 } | |
640 | |
641 // Netscape-specific GIF extension: animation looping. | |
642 case GIFNetscapeExtensionBlock: { | |
643 const int currentComponent = this->getOneByte(); | |
644 // GIFConsumeNetscapeExtension always reads 3 bytes from the stream;
we should at least wait for this amount. | |
645 if (currentComponent) | |
646 GETN(std::max(3, currentComponent), GIFConsumeNetscapeExtension)
; | |
647 else | |
648 GETN(1, GIFImageStart); | |
649 break; | |
650 } | |
651 | |
652 // Parse netscape-specific application extensions | |
653 case GIFConsumeNetscapeExtension: { | |
654 const unsigned char* currentComponent = | |
655 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); | |
656 | |
657 int netscapeExtension = currentComponent[0] & 7; | |
658 | |
659 // Loop entire animation specified # of times. Only read the loop co
unt during the first iteration. | |
660 if (netscapeExtension == 1) { | |
661 m_loopCount = GETINT16(currentComponent + 1); | |
662 | |
663 // Zero loop count is infinite animation loop request. | |
664 if (!m_loopCount) | |
665 m_loopCount = SkCodecAnimation::kAnimationLoopInfinite; | |
666 | |
667 GETN(1, GIFNetscapeExtensionBlock); | |
668 } else if (netscapeExtension == 2) { | |
669 // Wait for specified # of bytes to enter buffer. | |
670 | |
671 // Don't do this, this extension doesn't exist (isn't used at al
l) | |
672 // and doesn't do anything, as our streaming/buffering takes car
e of it all... | |
673 // See: http://semmix.pl/color/exgraf/eeg24.htm | |
674 GETN(1, GIFNetscapeExtensionBlock); | |
675 } else { | |
676 // 0,3-7 are yet to be defined netscape extension codes | |
677 // This prevents attempting to continue reading this invalid str
eam. | |
678 GETN(0, GIFDone); | |
679 return false; | |
680 } | |
681 break; | |
682 } | |
683 | |
684 case GIFImageHeader: { | |
685 unsigned height, width, xOffset, yOffset; | |
686 const unsigned char* currentComponent = | |
687 reinterpret_cast<const unsigned char*>(m_streamBuffer.get()); | |
688 | |
689 /* Get image offsets, with respect to the screen origin */ | |
690 xOffset = GETINT16(currentComponent); | |
691 yOffset = GETINT16(currentComponent + 2); | |
692 | |
693 /* Get image width and height. */ | |
694 width = GETINT16(currentComponent + 4); | |
695 height = GETINT16(currentComponent + 6); | |
696 | |
697 // Some GIF files have frames that don't fit in the specified | |
698 // overall image size. For the first frame, we can simply enlarge | |
699 // the image size to allow the frame to be visible. We can't do | |
700 // this on subsequent frames because the rest of the decoding | |
701 // infrastructure assumes the image size won't change as we | |
702 // continue decoding, so any subsequent frames that are even | |
703 // larger will be cropped. | |
704 // Luckily, handling just the first frame is sufficient to deal | |
705 // with most cases, e.g. ones where the image size is erroneously | |
706 // set to zero, since usually the first frame completely fills | |
707 // the image. | |
708 if (currentFrameIsFirstFrame()) { | |
709 m_screenHeight = std::max(m_screenHeight, yOffset + height); | |
710 m_screenWidth = std::max(m_screenWidth, xOffset + width); | |
711 } | |
712 | |
713 // NOTE: Chromium placed this block after setHeaderDefined, down | |
714 // below we returned true when asked for the size. So Chromium | |
715 // created an image which would fail. Is this the correct behavior? | |
716 // We choose to return false early, so we will not create an | |
717 // SkCodec. | |
718 | |
719 // Work around more broken GIF files that have zero image width or | |
720 // height. | |
721 if (!height || !width) { | |
722 height = m_screenHeight; | |
723 width = m_screenWidth; | |
724 if (!height || !width) { | |
725 // This prevents attempting to continue reading this invalid
stream. | |
726 GETN(0, GIFDone); | |
727 return false; | |
728 } | |
729 } | |
730 | |
731 const bool isLocalColormapDefined = currentComponent[8] & 0x80; | |
732 // The three low-order bits of currentComponent[8] specify the bits
per pixel. | |
733 const size_t numColors = 2 << (currentComponent[8] & 0x7); | |
734 if (currentFrameIsFirstFrame()) { | |
735 bool hasTransparentPixel; | |
736 if (m_frames.size() == 0) { | |
737 // We did not see a Graphics Control Extension, so no transp
arent | |
738 // pixel was specified. | |
739 hasTransparentPixel = false; | |
740 } else { | |
741 // This means we did see a Graphics Control Extension, which
specifies | |
742 // the transparent pixel | |
743 const size_t transparentPixel = m_frames[0]->transparentPixe
l(); | |
744 if (isLocalColormapDefined) { | |
745 hasTransparentPixel = transparentPixel < numColors; | |
746 } else { | |
747 const size_t globalColors = m_globalColorMap.numColors()
; | |
748 if (!globalColors) { | |
749 // No color table for this frame, so the frame is em
pty. | |
750 // This is technically different from having a trans
parent | |
751 // pixel, but we'll treat it the same - nothing to d
raw here. | |
752 hasTransparentPixel = true; | |
753 } else { | |
754 hasTransparentPixel = transparentPixel < globalColor
s; | |
755 } | |
756 } | |
757 } | |
758 | |
759 if (hasTransparentPixel) { | |
760 m_firstFrameHasAlpha = true; | |
761 m_firstFrameSupportsIndex8 = true; | |
762 } else { | |
763 const bool frameIsSubset = xOffset > 0 || yOffset > 0 | |
764 || xOffset + width < m_screenWidth | |
765 || yOffset + height < m_screenHeight; | |
766 m_firstFrameHasAlpha = frameIsSubset; | |
767 m_firstFrameSupportsIndex8 = !frameIsSubset; | |
768 } | |
769 } | |
770 | |
771 if (query == GIFSizeQuery) { | |
772 // The decoder needs to stop, so we return here, before | |
773 // flushing the buffer. Next time through, we'll be in the same | |
774 // state, requiring the same amount in the buffer. | |
775 m_bytesToConsume = 0; | |
776 return true; | |
777 } | |
778 | |
779 addFrameIfNecessary(); | |
780 GIFFrameContext* currentFrame = m_frames.back().get(); | |
781 | |
782 currentFrame->setHeaderDefined(); | |
783 | |
784 currentFrame->setRect(xOffset, yOffset, width, height); | |
785 currentFrame->setInterlaced(currentComponent[8] & 0x40); | |
786 | |
787 // Overlaying interlaced, transparent GIFs over | |
788 // existing image data using the Haeberli display hack | |
789 // requires saving the underlying image in order to | |
790 // avoid jaggies at the transparency edges. We are | |
791 // unprepared to deal with that, so don't display such | |
792 // images progressively. Which means only the first | |
793 // frame can be progressively displayed. | |
794 // FIXME: It is possible that a non-transparent frame | |
795 // can be interlaced and progressively displayed. | |
796 currentFrame->setProgressiveDisplay(currentFrameIsFirstFrame()); | |
797 | |
798 if (isLocalColormapDefined) { | |
799 currentFrame->localColorMap().setNumColors(numColors); | |
800 GETN(BYTES_PER_COLORMAP_ENTRY * numColors, GIFImageColormap); | |
801 break; | |
802 } | |
803 | |
804 GETN(1, GIFLZWStart); | |
805 break; | |
806 } | |
807 | |
808 case GIFImageColormap: { | |
809 SkASSERT(!m_frames.empty()); | |
810 m_frames.back()->localColorMap().setRawData(m_streamBuffer.get(), m_
streamBuffer.bytesBuffered()); | |
811 GETN(1, GIFLZWStart); | |
812 break; | |
813 } | |
814 | |
815 case GIFSubBlock: { | |
816 const size_t bytesInBlock = this->getOneByte(); | |
817 if (bytesInBlock) | |
818 GETN(bytesInBlock, GIFLZW); | |
819 else { | |
820 // Finished parsing one frame; Process next frame. | |
821 SkASSERT(!m_frames.empty()); | |
822 // Note that some broken GIF files do not have enough LZW blocks
to fully | |
823 // decode all rows but we treat it as frame complete. | |
824 m_frames.back()->setComplete(); | |
825 GETN(1, GIFImageStart); | |
826 if (lastFrameToParse >= 0 && (int) m_frames.size() > lastFrameTo
Parse) { | |
827 m_streamBuffer.flush(); | |
828 return true; | |
829 } | |
830 } | |
831 break; | |
832 } | |
833 | |
834 case GIFDone: { | |
835 m_parseCompleted = true; | |
836 return true; | |
837 } | |
838 | |
839 default: | |
840 // We shouldn't ever get here. | |
841 // This prevents attempting to continue reading this invalid stream. | |
842 GETN(0, GIFDone); | |
843 return false; | |
844 break; | |
845 } // switch | |
846 m_streamBuffer.flush(); | |
847 } | |
848 | |
849 return true; | |
850 } | |
851 | |
852 void GIFImageReader::addFrameIfNecessary() | |
853 { | |
854 if (m_frames.empty() || m_frames.back()->isComplete()) { | |
855 const size_t i = m_frames.size(); | |
856 std::unique_ptr<GIFFrameContext> frame(new GIFFrameContext(i)); | |
857 if (0 == i) { | |
858 frame->setRequiredFrame(SkCodec::kNone); | |
859 } else { | |
860 // FIXME: We could correct these after decoding (i.e. some frames ma
y turn out to be | |
861 // independent although we did not determine that here). | |
862 const GIFFrameContext* prevFrameContext = m_frames[i - 1].get(); | |
863 switch (prevFrameContext->getDisposalMethod()) { | |
864 case SkCodecAnimation::Keep_DisposalMethod: | |
865 frame->setRequiredFrame(i - 1); | |
866 break; | |
867 case SkCodecAnimation::RestorePrevious_DisposalMethod: | |
868 frame->setRequiredFrame(prevFrameContext->getRequiredFrame()
); | |
869 break; | |
870 case SkCodecAnimation::RestoreBGColor_DisposalMethod: | |
871 // If the prior frame covers the whole image | |
872 if (prevFrameContext->frameRect() == SkIRect::MakeWH(m_scree
nWidth, | |
873 m_scree
nHeight) | |
874 // Or the prior frame was independent | |
875 || prevFrameContext->getRequiredFrame() == SkCodec::
kNone) | |
876 { | |
877 // This frame is independent, since we clear everything | |
878 // prior frame to the BG color | |
879 frame->setRequiredFrame(SkCodec::kNone); | |
880 } else { | |
881 frame->setRequiredFrame(i - 1); | |
882 } | |
883 break; | |
884 } | |
885 } | |
886 m_frames.push_back(std::move(frame)); | |
887 } | |
888 } | |
889 | |
890 // FIXME: Move this method to close to doLZW(). | |
891 bool GIFLZWContext::prepareToDecode() | |
892 { | |
893 SkASSERT(m_frameContext->isDataSizeDefined() && m_frameContext->isHeaderDefi
ned()); | |
894 | |
895 // Since we use a codesize of 1 more than the datasize, we need to ensure | |
896 // that our datasize is strictly less than the MAX_DICTIONARY_ENTRY_BITS. | |
897 if (m_frameContext->dataSize() >= MAX_DICTIONARY_ENTRY_BITS) | |
898 return false; | |
899 clearCode = 1 << m_frameContext->dataSize(); | |
900 avail = clearCode + 2; | |
901 oldcode = -1; | |
902 codesize = m_frameContext->dataSize() + 1; | |
903 codemask = (1 << codesize) - 1; | |
904 datum = bits = 0; | |
905 ipass = m_frameContext->interlaced() ? 1 : 0; | |
906 irow = 0; | |
907 | |
908 // We want to know the longest sequence encodable by a dictionary with | |
909 // MAX_DICTIONARY_ENTRIES entries. If we ignore the need to encode the base | |
910 // values themselves at the beginning of the dictionary, as well as the need | |
911 // for a clear code or a termination code, we could use every entry to | |
912 // encode a series of multiple values. If the input value stream looked | |
913 // like "AAAAA..." (a long string of just one value), the first dictionary | |
914 // entry would encode AA, the next AAA, the next AAAA, and so forth. Thus | |
915 // the longest sequence would be MAX_DICTIONARY_ENTRIES + 1 values. | |
916 // | |
917 // However, we have to account for reserved entries. The first |datasize| | |
918 // bits are reserved for the base values, and the next two entries are | |
919 // reserved for the clear code and termination code. In theory a GIF can | |
920 // set the datasize to 0, meaning we have just two reserved entries, making | |
921 // the longest sequence (MAX_DICTIONARY_ENTIRES + 1) - 2 values long. Since | |
922 // each value is a byte, this is also the number of bytes in the longest | |
923 // encodable sequence. | |
924 const size_t maxBytes = MAX_DICTIONARY_ENTRIES - 1; | |
925 | |
926 // Now allocate the output buffer. We decode directly into this buffer | |
927 // until we have at least one row worth of data, then call outputRow(). | |
928 // This means worst case we may have (row width - 1) bytes in the buffer | |
929 // and then decode a sequence |maxBytes| long to append. | |
930 rowBuffer.reset(m_frameContext->width() - 1 + maxBytes); | |
931 rowIter = rowBuffer.begin(); | |
932 rowsRemaining = m_frameContext->height(); | |
933 | |
934 // Clearing the whole suffix table lets us be more tolerant of bad data. | |
935 for (int i = 0; i < clearCode; ++i) { | |
936 suffix[i] = i; | |
937 suffixLength[i] = 1; | |
938 } | |
939 return true; | |
940 } | |
941 | |
OLD | NEW |