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
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/
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
15
* The Original Code is mozilla.org code.
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.
23
* Chris Saari <saari@netscape.com>
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.
38
* ***** END LICENSE BLOCK ***** */
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.
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
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."
61
For further information, please contact :
63
CompuServe Incorporated
64
Graphics Technology Department
65
5000 Arlington Center Boulevard
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
76
#include "GIFImageReader.h"
79
#include "GIFImageDecoder.h"
81
#if PLATFORM(CAIRO) || PLATFORM(QT)
83
using WebCore::GIFImageDecoder;
85
// Define the Mozilla macro setup so that we can leave the macros alone.
86
#define PR_BEGIN_MACRO do {
87
#define PR_END_MACRO } while (0)
90
* GETN(n, s) requests at least 'n' bytes available from 'q', at start of state 's'
92
* Note, the hold will never need to be bigger than 256 bytes to gather up in the hold,
93
* as each GIF block (except colormaps) can never be bigger than 256 bytes.
94
* Colormaps are directly copied in the resp. global_colormap or dynamically allocated local_colormap.
95
* So a fixed buffer in GIFImageReader is good enough.
96
* This buffer is only needed to copy left-over data from one GifWrite call to the next
100
bytes_to_consume = (n); \
104
/* Get a 16-bit value stored in little-endian format */
105
#define GETINT16(p) ((p)[1]<<8|(p)[0])
107
//******************************************************************************
108
// Send the data to the display front-end.
109
void GIFImageReader::output_row()
111
GIFFrameReader* gs = frame_reader;
113
int width, drow_start, drow_end;
115
drow_start = drow_end = gs->irow;
118
* Haeberli-inspired hack for interlaced GIFs: Replicate lines while
119
* displaying to diminish the "venetian-blind" effect as the image is
120
* loaded. Adjust pixel vertical positions to avoid the appearance of the
121
* image crawling up the screen as successive passes are drawn.
123
if (gs->progressive_display && gs->interlaced && gs->ipass < 4) {
124
unsigned row_dup = 0, row_shift = 0;
143
drow_start -= row_shift;
144
drow_end = drow_start + row_dup;
146
/* Extend if bottom edge isn't covered because of the shift upward. */
147
if (((gs->height - 1) - drow_end) <= row_shift)
148
drow_end = gs->height - 1;
150
/* Clamp first and last rows to upper and lower edge of image. */
153
if ((unsigned)drow_end >= gs->height)
154
drow_end = gs->height - 1;
157
/* Protect against too much image data */
158
if ((unsigned)drow_start >= gs->height)
161
/* Check for scanline below edge of logical screen */
162
if ((gs->y_offset + gs->irow) < screen_height) {
163
/* Clip if right edge of image exceeds limits */
164
if ((gs->x_offset + gs->width) > screen_width)
165
width = screen_width - gs->x_offset;
169
// CALLBACK: Let the client know we have decoded a row.
170
if (width > 0 && clientptr && frame_reader)
171
clientptr->haveDecodedRow(images_count - 1, frame_reader->rowbuf, frame_reader->rowend,
172
drow_start, drow_end - drow_start + 1);
175
gs->rowp = gs->rowbuf;
185
if (gs->irow >= gs->height) {
193
if (gs->irow >= gs->height) {
201
if (gs->irow >= gs->height) {
209
if (gs->irow >= gs->height){
218
} while (gs->irow > (gs->height - 1));
222
//******************************************************************************
223
/* Perform Lempel-Ziv-Welch decoding */
224
int GIFImageReader::do_lzw(const unsigned char *q)
226
GIFFrameReader* gs = frame_reader;
232
const unsigned char *ch;
234
/* Copy all the decoder state variables into locals so the compiler
235
* won't worry about them being aliased. The locals will be homed
236
* back into the GIF decoder structure when we exit.
238
int avail = gs->avail;
241
int codesize = gs->codesize;
242
int codemask = gs->codemask;
243
int oldcode = gs->oldcode;
244
int clear_code = gs->clear_code;
245
unsigned char firstchar = gs->firstchar;
246
int datum = gs->datum;
249
gs->prefix = new unsigned short[MAX_BITS];
250
memset(gs->prefix, 0, MAX_BITS * sizeof(short));
253
unsigned short *prefix = gs->prefix;
254
unsigned char *stackp = gs->stackp;
255
unsigned char *suffix = gs->suffix;
256
unsigned char *stack = gs->stack;
257
unsigned char *rowp = gs->rowp;
258
unsigned char *rowend = gs->rowend;
259
unsigned rows_remaining = gs->rows_remaining;
268
rowp = frame_reader->rowp; \
269
if (!rows_remaining) \
273
for (ch = q; cnt-- > 0; ch++)
275
/* Feed the next byte into the decoder's 32-bit input buffer. */
276
datum += ((int) *ch) << bits;
279
/* Check for underflow of decoder's 32-bit input buffer. */
280
while (bits >= codesize)
282
/* Get the leading variable-length symbol from the data stream */
283
code = datum & codemask;
287
/* Reset the dictionary to its original state, if requested */
288
if (code == clear_code) {
289
codesize = gs->datasize + 1;
290
codemask = (1 << codesize) - 1;
291
avail = clear_code + 2;
296
/* Check for explicit end-of-stream code */
297
if (code == (clear_code + 1)) {
298
/* end-of-stream should only appear after all image data */
299
if (rows_remaining != 0)
305
*rowp++ = suffix[code];
309
firstchar = oldcode = code;
315
*stackp++ = firstchar;
318
if (stackp == stack + MAX_BITS)
322
while (code >= clear_code)
324
if (code == prefix[code])
327
*stackp++ = suffix[code];
330
if (stackp == stack + MAX_BITS)
334
*stackp++ = firstchar = suffix[code];
336
/* Define a new codeword in the dictionary. */
338
prefix[avail] = oldcode;
339
suffix[avail] = firstchar;
342
/* If we've used up all the codewords of a given length
343
* increase the length of codewords by one bit, but don't
344
* exceed the specified maximum codeword size of 12 bits.
346
if (((avail & codemask) == 0) && (avail < 4096)) {
353
/* Copy the decoded data out to the scanline buffer. */
356
if (rowp == rowend) {
359
} while (stackp > stack);
365
/* Home the local copies of the GIF decoder state variables */
368
gs->codesize = codesize;
369
gs->codemask = codemask;
371
gs->oldcode = oldcode;
372
gs->firstchar = firstchar;
376
gs->rows_remaining = rows_remaining;
382
/******************************************************************************/
384
* process data arriving from the stream for the gif decoder
387
bool GIFImageReader::read(const unsigned char *buf, unsigned len,
388
GIFImageDecoder::GIFQuery query, unsigned haltAtFrame)
393
const unsigned char *q = buf;
395
// Add what we have so far to the block
396
// If previous call to me left something in the hold first complete current block
397
// Or if we are filling the colormaps, first complete the colormap
398
unsigned char* p = 0;
399
if (state == gif_global_colormap)
401
else if (state == gif_image_colormap)
402
p = frame_reader ? frame_reader->local_colormap : 0;
403
else if (bytes_in_hold)
408
if (p || (state == gif_global_colormap) || (state == gif_image_colormap)) {
409
// Add what we have sofar to the block
410
unsigned l = len < bytes_to_consume ? len : bytes_to_consume;
412
memcpy(p + bytes_in_hold, buf, l);
414
if (l < bytes_to_consume) {
415
// Not enough in 'buf' to complete current block, get more
417
bytes_to_consume -= l;
420
// Reset hold buffer count
422
// Point 'q' to complete block in hold (or in colormap)
427
// 'q' is start of current to be processed block (hold, colormap or buf)
428
// 'bytes_to_consume' is number of bytes to consume from 'buf'
429
// 'buf' points to the bytes to be consumed from the input buffer
430
// 'len' is number of bytes left in input buffer from position 'buf'.
431
// At entrance of the for loop will 'buf' will be moved 'bytes_to_consume'
432
// to point to next buffer, 'len' is adjusted accordingly.
433
// So that next round in for loop, q gets pointed to the next buffer.
435
for (;len >= bytes_to_consume; q=buf) {
436
// Eat the current block from the buffer, q keeps pointed at current block
437
buf += bytes_to_consume;
438
len -= bytes_to_consume;
447
GETN(1, gif_sub_block);
452
/* Initialize LZW parser/decoder */
454
if (datasize > MAX_LZW_BITS) {
458
int clear_code = 1 << datasize;
459
if (clear_code >= MAX_BITS) {
465
frame_reader->datasize = datasize;
466
frame_reader->clear_code = clear_code;
467
frame_reader->avail = frame_reader->clear_code + 2;
468
frame_reader->oldcode = -1;
469
frame_reader->codesize = frame_reader->datasize + 1;
470
frame_reader->codemask = (1 << frame_reader->codesize) - 1;
472
frame_reader->datum = frame_reader->bits = 0;
474
/* init the tables */
475
if (!frame_reader->suffix)
476
frame_reader->suffix = new unsigned char[MAX_BITS];
477
for (int i = 0; i < frame_reader->clear_code; i++)
478
frame_reader->suffix[i] = i;
480
if (!frame_reader->stack)
481
frame_reader->stack = new unsigned char[MAX_BITS];
482
frame_reader->stackp = frame_reader->stack;
485
GETN(1, gif_sub_block);
489
/* All GIF files begin with "GIF87a" or "GIF89a" */
492
if (!strncmp((char*)q, "GIF89a", 6)) {
494
} else if (!strncmp((char*)q, "GIF87a", 6)) {
500
GETN(7, gif_global_header);
504
case gif_global_header:
506
/* This is the height and width of the "screen" or
507
* frame into which images are rendered. The
508
* individual images can be smaller than the
509
* screen size and located with an origin anywhere
513
screen_width = GETINT16(q);
514
screen_height = GETINT16(q + 2);
516
// CALLBACK: Inform the decoderplugin of our size.
518
clientptr->sizeNowAvailable(screen_width, screen_height);
520
screen_bgcolor = q[5];
521
global_colormap_size = 2<<(q[4]&0x07);
523
if ((q[4] & 0x80) && global_colormap_size > 0) { /* global map */
524
// Get the global colormap
525
const unsigned size = 3*global_colormap_size;
527
// Malloc the color map, but only if we're not just counting frames.
528
if (query != GIFImageDecoder::GIFFrameCountQuery)
529
global_colormap = new unsigned char[size];
532
// Use 'hold' pattern to get the global colormap
533
GETN(size, gif_global_colormap);
537
// Copy everything and go directly to gif_image_start.
539
memcpy(global_colormap, buf, size);
544
GETN(1, gif_image_start);
546
// q[6] = Pixel Aspect Ratio
548
// float aspect = (float)((q[6] + 15) / 64.0);
552
case gif_global_colormap:
553
// Everything is already copied into global_colormap
554
GETN(1, gif_image_start);
557
case gif_image_start:
559
if (*q == ';') { /* terminator */
564
if (*q == '!') { /* extension */
565
GETN(2, gif_extension);
569
/* If we get anything other than ',' (image separator), '!'
570
* (extension), or ';' (trailer), there is extraneous data
571
* between blocks. The GIF87a spec tells us to keep reading
572
* until we find an image separator, but GIF89a says such
573
* a file is corrupt. We follow GIF89a and bail out. */
575
if (images_decoded > 0) {
576
/* The file is corrupt, but one or more images have
577
* been decoded correctly. In this case, we proceed
578
* as if the file were correctly terminated and set
579
* the state to gif_done, so the GIF will display.
583
/* No images decoded, there is nothing to display. */
588
GETN(9, gif_image_header);
594
int len = count = q[1];
595
gstate es = gif_skip_block;
600
es = gif_control_extension;
604
// ignoring plain text extension
608
es = gif_application_extension;
612
es = gif_consume_comment;
619
GETN(1, gif_image_start);
623
case gif_consume_block:
625
GETN(1, gif_image_start);
627
GETN(*q, gif_skip_block);
631
GETN(1, gif_consume_block);
634
case gif_control_extension:
636
if (query != GIFImageDecoder::GIFFrameCountQuery) {
638
frame_reader = new GIFFrameReader();
643
frame_reader->tpixel = q[3];
644
frame_reader->is_transparent = true;
646
frame_reader->is_transparent = false;
647
// ignoring gfx control extension
649
frame_reader->disposal_method = (gdispose)(((*q) >> 2) & 0x7);
650
// Some specs say 3rd bit (value 4), other specs say value 3
651
// Let's choose 3 (the more popular)
652
if (frame_reader->disposal_method == 4)
653
frame_reader->disposal_method = (gdispose)3;
654
unsigned short n = GETINT16(q + 1);
655
// Many annoying ads specify a 0 duration to make an image flash as quickly as possible.
656
// We follow Firefox's behavior and use a duration of 100 ms for any frames that specify
657
// a duration of <= 10 ms. See gfxImageFrame::GetTimeout in Gecko or Radar 4051389 for more.
658
frame_reader->delay_time = n <= 1 ? 100 : n * 10;
660
GETN(1, gif_consume_block);
664
case gif_comment_extension:
667
GETN(*q, gif_consume_comment);
669
GETN(1, gif_image_start);
673
case gif_consume_comment:
674
GETN(1, gif_comment_extension);
677
case gif_application_extension:
678
/* Check for netscape application extension */
679
if (!strncmp((char*)q, "NETSCAPE2.0", 11) ||
680
!strncmp((char*)q, "ANIMEXTS1.0", 11))
681
GETN(1, gif_netscape_extension_block);
683
GETN(1, gif_consume_block);
686
/* Netscape-specific GIF extension: animation looping */
687
case gif_netscape_extension_block:
689
GETN(*q, gif_consume_netscape_extension);
691
GETN(1, gif_image_start);
694
/* Parse netscape-specific application extensions */
695
case gif_consume_netscape_extension:
697
int netscape_extension = q[0] & 7;
699
/* Loop entire animation specified # of times. Only read the
700
loop count during the first iteration. */
701
if (netscape_extension == 1) {
702
loop_count = GETINT16(q + 1);
704
GETN(1, gif_netscape_extension_block);
706
/* Wait for specified # of bytes to enter buffer */
707
else if (netscape_extension == 2) {
708
// Don't do this, this extension doesn't exist (isn't used at all)
709
// and doesn't do anything, as our streaming/buffering takes care of it all...
710
// See: http://semmix.pl/color/exgraf/eeg24.htm
711
GETN(1, gif_netscape_extension_block);
713
state = gif_error; // 0,3-7 are yet to be defined netscape
719
case gif_image_header:
721
unsigned height, width, x_offset, y_offset;
723
/* Get image offsets, with respect to the screen origin */
724
x_offset = GETINT16(q);
725
y_offset = GETINT16(q + 2);
727
/* Get image width and height. */
728
width = GETINT16(q + 4);
729
height = GETINT16(q + 6);
731
/* Work around broken GIF files where the logical screen
732
* size has weird width or height. We assume that GIF87a
733
* files don't contain animations.
735
if ((images_decoded == 0) &&
736
((screen_height < height) || (screen_width < width) ||
739
screen_height = height;
740
screen_width = width;
744
// CALLBACK: Inform the decoderplugin of our size.
746
clientptr->sizeNowAvailable(screen_width, screen_height);
749
/* Work around more broken GIF files that have zero image
751
if (!height || !width) {
752
height = screen_height;
753
width = screen_width;
754
if (!height || !width) {
760
if (query == GIFImageDecoder::GIFSizeQuery || haltAtFrame == images_decoded) {
761
// The decoder needs to stop. Hand back the number of bytes we consumed from
762
// buffer minus 9 (the amount we consumed to read the header).
764
clientptr->decodingHalted(len + 9);
765
GETN(9, gif_image_header);
769
images_count = images_decoded + 1;
771
if (query == GIFImageDecoder::GIFFullQuery && !frame_reader)
772
frame_reader = new GIFFrameReader();
775
frame_reader->x_offset = x_offset;
776
frame_reader->y_offset = y_offset;
777
frame_reader->height = height;
778
frame_reader->width = width;
780
/* This case will never be taken if this is the first image */
781
/* being decoded. If any of the later images are larger */
782
/* than the screen size, we need to reallocate buffers. */
783
if (screen_width < width) {
786
delete []frame_reader->rowbuf;
787
frame_reader->rowbuf = new unsigned char[width];
789
if (!frame_reader->rowbuf) {
794
screen_width = width;
795
if (screen_height < frame_reader->height)
796
screen_height = frame_reader->height;
799
if (!frame_reader->rowbuf)
800
frame_reader->rowbuf = new unsigned char[screen_width];
803
if (!frame_reader->rowbuf) {
809
frame_reader->interlaced = true;
810
frame_reader->ipass = 1;
812
frame_reader->interlaced = false;
813
frame_reader->ipass = 0;
816
if (images_decoded == 0) {
817
frame_reader->progressive_display = true;
819
/* Overlaying interlaced, transparent GIFs over
820
existing image data using the Haeberli display hack
821
requires saving the underlying image in order to
822
avoid jaggies at the transparency edges. We are
823
unprepared to deal with that, so don't display such
824
images progressively */
825
frame_reader->progressive_display = false;
828
/* Clear state from last image */
829
frame_reader->irow = 0;
830
frame_reader->rows_remaining = frame_reader->height;
831
frame_reader->rowend = frame_reader->rowbuf + frame_reader->width;
832
frame_reader->rowp = frame_reader->rowbuf;
834
/* bits per pixel is q[8]&0x07 */
837
if (q[8] & 0x80) /* has a local colormap? */
839
int num_colors = 2 << (q[8] & 0x7);
840
const unsigned size = 3*num_colors;
841
unsigned char *map = frame_reader ? frame_reader->local_colormap : 0;
842
if (frame_reader && (!map || (num_colors > frame_reader->local_colormap_size))) {
844
map = new unsigned char[size];
851
/* Switch to the new local palette after it loads */
853
frame_reader->local_colormap = map;
854
frame_reader->local_colormap_size = num_colors;
855
frame_reader->is_local_colormap_defined = true;
859
// Use 'hold' pattern to get the image colormap
860
GETN(size, gif_image_colormap);
863
// Copy everything and directly go to gif_lzw_start
865
memcpy(frame_reader->local_colormap, buf, size);
868
} else if (frame_reader) {
869
/* Switch back to the global palette */
870
frame_reader->is_local_colormap_defined = false;
872
GETN(1, gif_lzw_start);
876
case gif_image_colormap:
877
// Everything is already copied into local_colormap
878
GETN(1, gif_lzw_start);
883
if ((count = *q) != 0)
884
/* Still working on the same image: Process next LZW data block */
886
/* Make sure there are still rows left. If the GIF data */
887
/* is corrupt, we may not get an explicit terminator. */
888
if (frame_reader && frame_reader->rows_remaining == 0) {
889
/* This is an illegal GIF, but we remain tolerant. */
890
GETN(1, gif_sub_block);
892
GETN(count, gif_lzw);
895
/* See if there are any more images in this sequence. */
899
// CALLBACK: The frame is now complete.
900
if (clientptr && frame_reader)
901
clientptr->frameComplete(images_decoded - 1, frame_reader->delay_time,
902
frame_reader->disposal_method == DISPOSE_KEEP);
904
/* Clear state from this image */
906
frame_reader->is_local_colormap_defined = false;
907
frame_reader->is_transparent = false;
910
GETN(1, gif_image_start);
916
// When the GIF is done, we can stop.
918
clientptr->gifComplete();
921
// Handle out of memory errors
925
// Handle general errors
927
// nsGIFDecoder2::EndGIF(gs->clientptr, gs->loop_count);
930
// We shouldn't ever get here.
936
// Copy the leftover into gs->hold
939
// Add what we have sofar to the block
941
if (state == gif_global_colormap)
943
else if (state == gif_image_colormap)
944
p = frame_reader ? frame_reader->local_colormap : 0;
949
bytes_to_consume -= len;
955
#endif // PLATFORM(CAIRO)
added
removed
WebCore/platform/image-decoders/gif/GIFImageReader.cpp
