source: trunk/src/plugins/imageformats/gif/qgifhandler.cpp@ 98

Last change on this file since 98 was 2, checked in by Dmitry A. Kuminov, 16 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.
File size: 27.7 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information ([email protected])
5**
6** This file is part of the plugins of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file. Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at [email protected].
38** $QT_END_LICENSE$
39**
40** WARNING:
41** A separate license from Unisys may be required to use the gif
42** reader. See http://www.unisys.com/about__unisys/lzw/
43** for information from Unisys
44**
45****************************************************************************/
46
47#include "qgifhandler.h"
48
49#include <qimage.h>
50#include <qiodevice.h>
51#include <qvariant.h>
52
53QT_BEGIN_NAMESPACE
54
55#define Q_TRANSPARENT 0x00ffffff
56
57/*
58 Incremental image decoder for GIF image format.
59
60 This subclass of QImageFormat decodes GIF format images,
61 including animated GIFs. Internally in
62*/
63
64class QGIFFormat {
65public:
66 QGIFFormat();
67 ~QGIFFormat();
68
69 int decode(QImage *image, const uchar* buffer, int length,
70 int *nextFrameDelay, int *loopCount, QSize *nextSize);
71
72 bool newFrame;
73 bool partialNewFrame;
74
75private:
76 void fillRect(QImage *image, int x, int y, int w, int h, QRgb col);
77 inline QRgb color(uchar index) const;
78
79 // GIF specific stuff
80 QRgb* globalcmap;
81 QRgb* localcmap;
82 QImage backingstore;
83 unsigned char hold[16];
84 bool gif89;
85 int count;
86 int ccount;
87 int expectcount;
88 enum State {
89 Header,
90 LogicalScreenDescriptor,
91 GlobalColorMap,
92 LocalColorMap,
93 Introducer,
94 ImageDescriptor,
95 TableImageLZWSize,
96 ImageDataBlockSize,
97 ImageDataBlock,
98 ExtensionLabel,
99 GraphicControlExtension,
100 ApplicationExtension,
101 NetscapeExtensionBlockSize,
102 NetscapeExtensionBlock,
103 SkipBlockSize,
104 SkipBlock,
105 Done,
106 Error
107 } state;
108 int gncols;
109 int lncols;
110 int ncols;
111 int lzwsize;
112 bool lcmap;
113 int swidth, sheight;
114 int width, height;
115 int left, top, right, bottom;
116 enum Disposal { NoDisposal, DoNotChange, RestoreBackground, RestoreImage };
117 Disposal disposal;
118 bool disposed;
119 int trans_index;
120 bool gcmap;
121 int bgcol;
122 int interlace;
123 int accum;
124 int bitcount;
125
126 enum { max_lzw_bits=12 }; // (poor-compiler's static const int)
127
128 int code_size, clear_code, end_code, max_code_size, max_code;
129 int firstcode, oldcode, incode;
130 short table[2][1<< max_lzw_bits];
131 short stack[(1<<(max_lzw_bits))*2];
132 short *sp;
133 bool needfirst;
134 int x, y;
135 int frame;
136 bool out_of_bounds;
137 bool digress;
138 void nextY(QImage *image);
139 void disposePrevious(QImage *image);
140};
141
142/*!
143 Constructs a QGIFFormat.
144*/
145QGIFFormat::QGIFFormat()
146{
147 globalcmap = 0;
148 localcmap = 0;
149 lncols = 0;
150 gncols = 0;
151 disposal = NoDisposal;
152 out_of_bounds = false;
153 disposed = true;
154 frame = -1;
155 state = Header;
156 count = 0;
157 lcmap = false;
158 newFrame = false;
159 partialNewFrame = false;
160}
161
162/*!
163 Destroys a QGIFFormat.
164*/
165QGIFFormat::~QGIFFormat()
166{
167 if (globalcmap) delete[] globalcmap;
168 if (localcmap) delete[] localcmap;
169}
170
171void QGIFFormat::disposePrevious(QImage *image)
172{
173 if (out_of_bounds) {
174 // flush anything that survived
175 // ### Changed: QRect(0, 0, swidth, sheight)
176 }
177
178 // Handle disposal of previous image before processing next one
179
180 if (disposed) return;
181
182 int l = qMin(swidth-1,left);
183 int r = qMin(swidth-1,right);
184 int t = qMin(sheight-1,top);
185 int b = qMin(sheight-1,bottom);
186
187 switch (disposal) {
188 case NoDisposal:
189 break;
190 case DoNotChange:
191 break;
192 case RestoreBackground:
193 if (trans_index>=0) {
194 // Easy: we use the transparent color
195 fillRect(image, l, t, r-l+1, b-t+1, Q_TRANSPARENT);
196 } else if (bgcol>=0) {
197 // Easy: we use the bgcol given
198 fillRect(image, l, t, r-l+1, b-t+1, color(bgcol));
199 } else {
200 // Impossible: We don't know of a bgcol - use pixel 0
201 QRgb *bits = (QRgb*)image->bits();
202 fillRect(image, l, t, r-l+1, b-t+1, bits[0]);
203 }
204 // ### Changed: QRect(l, t, r-l+1, b-t+1)
205 break;
206 case RestoreImage: {
207 if (frame >= 0) {
208 for (int ln=t; ln<=b; ln++) {
209 memcpy(image->scanLine(ln)+l,
210 backingstore.scanLine(ln-t),
211 (r-l+1)*sizeof(QRgb));
212 }
213 // ### Changed: QRect(l, t, r-l+1, b-t+1)
214 }
215 }
216 }
217 disposal = NoDisposal; // Until an extension says otherwise.
218
219 disposed = true;
220}
221
222/*!
223 This function decodes some data into image changes.
224
225 Returns the number of bytes consumed.
226*/
227int QGIFFormat::decode(QImage *image, const uchar *buffer, int length,
228 int *nextFrameDelay, int *loopCount, QSize *nextSize)
229{
230 // We are required to state that
231 // "The Graphics Interchange Format(c) is the Copyright property of
232 // CompuServe Incorporated. GIF(sm) is a Service Mark property of
233 // CompuServe Incorporated."
234
235#define LM(l, m) (((m)<<8)|l)
236 digress = false;
237 int initial = length;
238 while (!digress && length) {
239 length--;
240 unsigned char ch=*buffer++;
241 switch (state) {
242 case Header:
243 hold[count++]=ch;
244 if (count==6) {
245 // Header
246 gif89=(hold[3]!='8' || hold[4]!='7');
247 state=LogicalScreenDescriptor;
248 count=0;
249 }
250 break;
251 case LogicalScreenDescriptor:
252 hold[count++]=ch;
253 if (count==7) {
254 // Logical Screen Descriptor
255 swidth=LM(hold[0], hold[1]);
256 sheight=LM(hold[2], hold[3]);
257 gcmap=!!(hold[4]&0x80);
258 //UNUSED: bpchan=(((hold[4]&0x70)>>3)+1);
259 //UNUSED: gcmsortflag=!!(hold[4]&0x08);
260 gncols=2<<(hold[4]&0x7);
261 bgcol=(gcmap) ? hold[5] : -1;
262 //aspect=hold[6] ? double(hold[6]+15)/64.0 : 1.0;
263
264 trans_index = -1;
265 count=0;
266 ncols=gncols;
267 if (gcmap) {
268 ccount=0;
269 state=GlobalColorMap;
270 globalcmap = new QRgb[gncols+1]; // +1 for trans_index
271 globalcmap[gncols] = Q_TRANSPARENT;
272 } else {
273 state=Introducer;
274 }
275 }
276 break;
277 case GlobalColorMap: case LocalColorMap:
278 hold[count++]=ch;
279 if (count==3) {
280 QRgb rgb = qRgb(hold[0], hold[1], hold[2]);
281 if (state == LocalColorMap) {
282 if (ccount < lncols)
283 localcmap[ccount] = rgb;
284 } else {
285 globalcmap[ccount] = rgb;
286 }
287 if (++ccount >= ncols) {
288 if (state == LocalColorMap)
289 state=TableImageLZWSize;
290 else
291 state=Introducer;
292 }
293 count=0;
294 }
295 break;
296 case Introducer:
297 hold[count++]=ch;
298 switch (ch) {
299 case ',':
300 state=ImageDescriptor;
301 break;
302 case '!':
303 state=ExtensionLabel;
304 break;
305 case ';':
306 // ### Changed: QRect(0, 0, swidth, sheight)
307 state=Done;
308 break;
309 default:
310 digress=true;
311 // Unexpected Introducer - ignore block
312 state=Error;
313 }
314 break;
315 case ImageDescriptor:
316 hold[count++]=ch;
317 if (count==10) {
318 int newleft=LM(hold[1], hold[2]);
319 int newtop=LM(hold[3], hold[4]);
320 int newwidth=LM(hold[5], hold[6]);
321 int newheight=LM(hold[7], hold[8]);
322
323 // disbelieve ridiculous logical screen sizes,
324 // unless the image frames are also large.
325 if (swidth/10 > qMax(newwidth,200))
326 swidth = -1;
327 if (sheight/10 > qMax(newheight,200))
328 sheight = -1;
329
330 if (swidth <= 0)
331 swidth = newleft + newwidth;
332 if (sheight <= 0)
333 sheight = newtop + newheight;
334
335 QImage::Format format = trans_index >= 0 ? QImage::Format_ARGB32 : QImage::Format_RGB32;
336 if (image->isNull() || (image->size() != QSize(swidth, sheight)) || image->format() != format) {
337 (*image) = QImage(swidth, sheight, format);
338 memset(image->bits(), 0, image->numBytes());
339
340 // ### size of the upcoming frame, should rather
341 // be known before decoding it.
342 *nextSize = QSize(swidth, sheight);
343 }
344
345 disposePrevious(image);
346 disposed = false;
347
348 left = newleft;
349 top = newtop;
350 width = newwidth;
351 height = newheight;
352
353 right=qMax(0, qMin(left+width, swidth)-1);
354 bottom=qMax(0, qMin(top+height, sheight)-1);
355 lcmap=!!(hold[9]&0x80);
356 interlace=!!(hold[9]&0x40);
357 //bool lcmsortflag=!!(hold[9]&0x20);
358 lncols=lcmap ? (2<<(hold[9]&0x7)) : 0;
359 if (lncols) {
360 if (localcmap)
361 delete [] localcmap;
362 localcmap = new QRgb[lncols+1];
363 localcmap[lncols] = Q_TRANSPARENT;
364 ncols = lncols;
365 } else {
366 ncols = gncols;
367 }
368 frame++;
369 if (frame == 0) {
370 if (left || top || width<swidth || height<sheight) {
371 // Not full-size image - erase with bg or transparent
372 if (trans_index >= 0) {
373 fillRect(image, 0, 0, swidth, sheight, color(trans_index));
374 // ### Changed: QRect(0, 0, swidth, sheight)
375 } else if (bgcol>=0) {
376 fillRect(image, 0, 0, swidth, sheight, color(bgcol));
377 // ### Changed: QRect(0, 0, swidth, sheight)
378 }
379 }
380 }
381
382 if (disposal == RestoreImage) {
383 int l = qMin(swidth-1,left);
384 int r = qMin(swidth-1,right);
385 int t = qMin(sheight-1,top);
386 int b = qMin(sheight-1,bottom);
387 int w = r-l+1;
388 int h = b-t+1;
389
390 if (backingstore.width() < w
391 || backingstore.height() < h) {
392 // We just use the backing store as a byte array
393 backingstore = QImage(qMax(backingstore.width(), w),
394 qMax(backingstore.height(), h),
395 QImage::Format_RGB32);
396 memset(image->bits(), 0, image->numBytes());
397 }
398 for (int ln=0; ln<h; ln++) {
399 memcpy(backingstore.scanLine(ln),
400 image->scanLine(t+ln)+l, w*sizeof(QRgb));
401 }
402 }
403
404 count=0;
405 if (lcmap) {
406 ccount=0;
407 state=LocalColorMap;
408 } else {
409 state=TableImageLZWSize;
410 }
411 x = left;
412 y = top;
413 accum = 0;
414 bitcount = 0;
415 sp = stack;
416 firstcode = oldcode = 0;
417 needfirst = true;
418 out_of_bounds = left>=swidth || y>=sheight;
419 }
420 break;
421 case TableImageLZWSize: {
422 lzwsize=ch;
423 if (lzwsize > max_lzw_bits) {
424 state=Error;
425 } else {
426 code_size=lzwsize+1;
427 clear_code=1<<lzwsize;
428 end_code=clear_code+1;
429 max_code_size=2*clear_code;
430 max_code=clear_code+2;
431 int i;
432 for (i=0; i<clear_code; i++) {
433 table[0][i]=0;
434 table[1][i]=i;
435 }
436 state=ImageDataBlockSize;
437 }
438 count=0;
439 break;
440 } case ImageDataBlockSize:
441 expectcount=ch;
442 if (expectcount) {
443 state=ImageDataBlock;
444 } else {
445 state=Introducer;
446 digress = true;
447 newFrame = true;
448 }
449 break;
450 case ImageDataBlock:
451 count++;
452 accum|=(ch<<bitcount);
453 bitcount+=8;
454 while (bitcount>=code_size && state==ImageDataBlock) {
455 int code=accum&((1<<code_size)-1);
456 bitcount-=code_size;
457 accum>>=code_size;
458
459 if (code==clear_code) {
460 if (!needfirst) {
461 code_size=lzwsize+1;
462 max_code_size=2*clear_code;
463 max_code=clear_code+2;
464 }
465 needfirst=true;
466 } else if (code==end_code) {
467 bitcount = -32768;
468 // Left the block end arrive
469 } else {
470 if (needfirst) {
471 firstcode=oldcode=code;
472 if (!out_of_bounds && image->height() > y && firstcode!=trans_index)
473 ((QRgb*)image->scanLine(y))[x] = color(firstcode);
474 x++;
475 if (x>=swidth) out_of_bounds = true;
476 needfirst=false;
477 if (x>=left+width) {
478 x=left;
479 out_of_bounds = left>=swidth || y>=sheight;
480 nextY(image);
481 }
482 } else {
483 incode=code;
484 if (code>=max_code) {
485 *sp++=firstcode;
486 code=oldcode;
487 }
488 while (code>=clear_code+2) {
489 *sp++=table[1][code];
490 if (code==table[0][code]) {
491 state=Error;
492 break;
493 }
494 if (sp-stack>=(1<<(max_lzw_bits))*2) {
495 state=Error;
496 break;
497 }
498 code=table[0][code];
499 }
500 *sp++=firstcode=table[1][code];
501 code=max_code;
502 if (code<(1<<max_lzw_bits)) {
503 table[0][code]=oldcode;
504 table[1][code]=firstcode;
505 max_code++;
506 if ((max_code>=max_code_size)
507 && (max_code_size<(1<<max_lzw_bits)))
508 {
509 max_code_size*=2;
510 code_size++;
511 }
512 }
513 oldcode=incode;
514 const int h = image->height();
515 const QRgb *map = lcmap ? localcmap : globalcmap;
516 QRgb *line = 0;
517 if (!out_of_bounds && h > y)
518 line = (QRgb*)image->scanLine(y);
519 while (sp>stack) {
520 const uchar index = *(--sp);
521 if (!out_of_bounds && h > y && index!=trans_index) {
522 if (index > ncols)
523 line[x] = Q_TRANSPARENT;
524 else
525 line[x] = map ? map[index] : 0;
526 }
527 x++;
528 if (x>=swidth) out_of_bounds = true;
529 if (x>=left+width) {
530 x=left;
531 out_of_bounds = left>=swidth || y>=sheight;
532 nextY(image);
533 if (!out_of_bounds && h > y)
534 line = (QRgb*)image->scanLine(y);
535 }
536 }
537 }
538 }
539 }
540 partialNewFrame = true;
541 if (count==expectcount) {
542 count=0;
543 state=ImageDataBlockSize;
544 }
545 break;
546 case ExtensionLabel:
547 switch (ch) {
548 case 0xf9:
549 state=GraphicControlExtension;
550 break;
551 case 0xff:
552 state=ApplicationExtension;
553 break;
554#if 0
555 case 0xfe:
556 state=CommentExtension;
557 break;
558 case 0x01:
559 break;
560#endif
561 default:
562 state=SkipBlockSize;
563 }
564 count=0;
565 break;
566 case ApplicationExtension:
567 if (count<11) hold[count]=ch;
568 count++;
569 if (count==hold[0]+1) {
570 if (qstrncmp((char*)(hold+1), "NETSCAPE", 8)==0) {
571 // Looping extension
572 state=NetscapeExtensionBlockSize;
573 } else {
574 state=SkipBlockSize;
575 }
576 count=0;
577 }
578 break;
579 case NetscapeExtensionBlockSize:
580 expectcount=ch;
581 count=0;
582 if (expectcount) state=NetscapeExtensionBlock;
583 else state=Introducer;
584 break;
585 case NetscapeExtensionBlock:
586 if (count<3) hold[count]=ch;
587 count++;
588 if (count==expectcount) {
589 *loopCount = hold[1]+hold[2]*256;
590 state=SkipBlockSize; // Ignore further blocks
591 }
592 break;
593 case GraphicControlExtension:
594 if (count<5) hold[count]=ch;
595 count++;
596 if (count==hold[0]+1) {
597 disposePrevious(image);
598 disposal=Disposal((hold[1]>>2)&0x7);
599 //UNUSED: waitforuser=!!((hold[1]>>1)&0x1);
600 int delay=count>3 ? LM(hold[2], hold[3]) : 1;
601 // IE and mozilla use a minimum delay of 10. With the minimum delay of 10
602 // we are compatible to them and avoid huge loads on the app and xserver.
603 *nextFrameDelay = (delay < 2 ? 10 : delay) * 10;
604
605 bool havetrans=hold[1]&0x1;
606 trans_index = havetrans ? hold[4] : -1;
607
608 count=0;
609 state=SkipBlockSize;
610 }
611 break;
612 case SkipBlockSize:
613 expectcount=ch;
614 count=0;
615 if (expectcount) state=SkipBlock;
616 else state=Introducer;
617 break;
618 case SkipBlock:
619 count++;
620 if (count==expectcount) state=SkipBlockSize;
621 break;
622 case Done:
623 digress=true;
624 /* Netscape ignores the junk, so we do too.
625 length++; // Unget
626 state=Error; // More calls to this is an error
627 */
628 break;
629 case Error:
630 return -1; // Called again after done.
631 }
632 }
633 return initial-length;
634}
635
636void QGIFFormat::fillRect(QImage *image, int col, int row, int w, int h, QRgb color)
637{
638 if (w>0) {
639 for (int j=0; j<h; j++) {
640 QRgb *line = (QRgb*)image->scanLine(j+row);
641 for (int i=0; i<w; i++)
642 *(line+col+i) = color;
643 }
644 }
645}
646
647void QGIFFormat::nextY(QImage *image)
648{
649 int my;
650 switch (interlace) {
651 case 0: // Non-interlaced
652 // if (!out_of_bounds) {
653 // ### Changed: QRect(left, y, right - left + 1, 1);
654 // }
655 y++;
656 break;
657 case 1: {
658 int i;
659 my = qMin(7, bottom-y);
660 // Don't dup with transparency
661 if (trans_index < 0) {
662 for (i=1; i<=my; i++) {
663 memcpy(image->scanLine(y+i)+left*sizeof(QRgb), image->scanLine(y)+left*sizeof(QRgb),
664 (right-left+1)*sizeof(QRgb));
665 }
666 }
667
668 // if (!out_of_bounds) {
669 // ### Changed: QRect(left, y, right - left + 1, my + 1);
670 // }
671// if (!out_of_bounds)
672// qDebug("consumer->changed(QRect(%d, %d, %d, %d))", left, y, right-left+1, my+1);
673 y+=8;
674 if (y>bottom) {
675 interlace++; y=top+4;
676 if (y > bottom) { // for really broken GIFs with bottom < 5
677 interlace=2;
678 y = top + 2;
679 if (y > bottom) { // for really broken GIF with bottom < 3
680 interlace = 0;
681 y = top + 1;
682 }
683 }
684 }
685 } break;
686 case 2: {
687 int i;
688 my = qMin(3, bottom-y);
689 // Don't dup with transparency
690 if (trans_index < 0) {
691 for (i=1; i<=my; i++) {
692 memcpy(image->scanLine(y+i)+left*sizeof(QRgb), image->scanLine(y)+left*sizeof(QRgb),
693 (right-left+1)*sizeof(QRgb));
694 }
695 }
696
697 // if (!out_of_bounds) {
698 // ### Changed: QRect(left, y, right - left + 1, my + 1);
699 // }
700 y+=8;
701 if (y>bottom) {
702 interlace++; y=top+2;
703 // handle broken GIF with bottom < 3
704 if (y > bottom) {
705 interlace = 3;
706 y = top + 1;
707 }
708 }
709 } break;
710 case 3: {
711 int i;
712 my = qMin(1, bottom-y);
713 // Don't dup with transparency
714 if (trans_index < 0) {
715 for (i=1; i<=my; i++) {
716 memcpy(image->scanLine(y+i)+left*sizeof(QRgb), image->scanLine(y)+left*sizeof(QRgb),
717 (right-left+1)*sizeof(QRgb));
718 }
719 }
720 // if (!out_of_bounds) {
721 // ### Changed: QRect(left, y, right - left + 1, my + 1);
722 // }
723 y+=4;
724 if (y>bottom) { interlace++; y=top+1; }
725 } break;
726 case 4:
727 // if (!out_of_bounds) {
728 // ### Changed: QRect(left, y, right - left + 1, 1);
729 // }
730 y+=2;
731 }
732
733 // Consume bogus extra lines
734 if (y >= sheight) out_of_bounds=true; //y=bottom;
735}
736
737inline QRgb QGIFFormat::color(uchar index) const
738{
739 if (index == trans_index || index > ncols)
740 return Q_TRANSPARENT;
741
742 QRgb *map = lcmap ? localcmap : globalcmap;
743 return map ? map[index] : 0;
744}
745
746//-------------------------------------------------------------------------
747//-------------------------------------------------------------------------
748//-------------------------------------------------------------------------
749
750QGifHandler::QGifHandler()
751{
752 gifFormat = new QGIFFormat;
753 nextDelay = 0;
754 loopCnt = 0;
755 frameNumber = -1;
756 nextSize = QSize();
757}
758
759QGifHandler::~QGifHandler()
760{
761 delete gifFormat;
762}
763
764// Does partial decode if necessary, just to see if an image is coming
765
766bool QGifHandler::imageIsComing() const
767{
768 const int GifChunkSize = 4096;
769
770 while (!gifFormat->partialNewFrame) {
771 if (buffer.isEmpty()) {
772 buffer += device()->read(GifChunkSize);
773 if (buffer.isEmpty())
774 break;
775 }
776
777 int decoded = gifFormat->decode(&lastImage, (const uchar *)buffer.constData(), buffer.size(),
778 &nextDelay, &loopCnt, &nextSize);
779 if (decoded == -1)
780 break;
781 buffer.remove(0, decoded);
782 }
783 return gifFormat->partialNewFrame;
784}
785
786bool QGifHandler::canRead() const
787{
788 if (!nextDelay && canRead(device())) {
789 setFormat("gif");
790 return true;
791 }
792
793 return imageIsComing();
794}
795
796bool QGifHandler::canRead(QIODevice *device)
797{
798 if (!device) {
799 qWarning("QGifHandler::canRead() called with no device");
800 return false;
801 }
802
803 char head[6];
804 if (device->peek(head, sizeof(head)) == sizeof(head))
805 return qstrncmp(head, "GIF87a", 6) == 0
806 || qstrncmp(head, "GIF89a", 6) == 0;
807 return false;
808}
809
810bool QGifHandler::read(QImage *image)
811{
812 const int GifChunkSize = 4096;
813
814 while (!gifFormat->newFrame) {
815 if (buffer.isEmpty()) {
816 buffer += device()->read(GifChunkSize);
817 if (buffer.isEmpty())
818 break;
819 }
820
821 int decoded = gifFormat->decode(&lastImage, (const uchar *)buffer.constData(), buffer.size(),
822 &nextDelay, &loopCnt, &nextSize);
823 if (decoded == -1)
824 break;
825 buffer.remove(0, decoded);
826 }
827 if (gifFormat->newFrame || (gifFormat->partialNewFrame && device()->atEnd())) {
828 *image = lastImage;
829 ++frameNumber;
830 gifFormat->newFrame = false;
831 gifFormat->partialNewFrame = false;
832 return true;
833 }
834
835 return false;
836}
837
838bool QGifHandler::write(const QImage &image)
839{
840 Q_UNUSED(image);
841 return false;
842}
843
844bool QGifHandler::supportsOption(ImageOption option) const
845{
846 return option == Size
847 || option == Animation;
848}
849
850QVariant QGifHandler::option(ImageOption option) const
851{
852 if (option == Size) {
853 if (imageIsComing())
854 return nextSize;
855 } else if (option == Animation) {
856 return true;
857 }
858 return QVariant();
859}
860
861void QGifHandler::setOption(ImageOption option, const QVariant &value)
862{
863 Q_UNUSED(option);
864 Q_UNUSED(value);
865}
866
867int QGifHandler::nextImageDelay() const
868{
869 return nextDelay;
870}
871
872int QGifHandler::imageCount() const
873{
874 return 0; // Don't know
875}
876
877int QGifHandler::loopCount() const
878{
879 return loopCnt-1; // In GIF, loop count is iteration count, so subtract one
880}
881
882int QGifHandler::currentImageNumber() const
883{
884 return frameNumber;
885}
886
887QByteArray QGifHandler::name() const
888{
889 return "gif";
890}
891
892QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.