1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the plugins of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    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_p.h"

    48 

    49 #include <qimage.h>

    50 #include <qiodevice.h>

    51 #include <qvariant.h>

    52 

    53 QT_BEGIN_NAMESPACE

    54 

    55 #define Q_TRANSPARENT 0x00ffffff

    56 

    57 // avoid going through QImage::scanLine() which calls detach

    58 #define FAST_SCAN_LINE(bits, bpl, y) (bits + (y) * bpl)

    59 

    60 

    61 /*

    62   Incremental image decoder for GIF image format.

    63 

    64   This subclass of QImageFormat decodes GIF format images,

    65   including animated GIFs. Internally in

    66 */

    67 

    68 class QGIFFormat {

    69 public:

    70     QGIFFormat();

    71     ~QGIFFormat();

    72 

    73     int decode(QImage *image, const uchar* buffer, int length,

    74                int *nextFrameDelay, int *loopCount);

    75     static void scan(QIODevice *device, QVector<QSize> *imageSizes, int *loopCount);

    76 

    77     bool newFrame;

    78     bool partialNewFrame;

    79 

    80 private:

    81     void fillRect(QImage *image, int x, int y, int w, int h, QRgb col);

    82     inline QRgb color(uchar index) const;

    83 

    84     // GIF specific stuff

    85     QRgb* globalcmap;

    86     QRgb* localcmap;

    87     QImage backingstore;

    88     unsigned char hold[16];

    89     bool gif89;

    90     int count;

    91     int ccount;

    92     int expectcount;

    93     enum State {

    94         Header,

    95         LogicalScreenDescriptor,

    96         GlobalColorMap,

    97         LocalColorMap,

    98         Introducer,

    99         ImageDescriptor,

   100         TableImageLZWSize,

   101         ImageDataBlockSize,

   102         ImageDataBlock,

   103         ExtensionLabel,

   104         GraphicControlExtension,

   105         ApplicationExtension,

   106         NetscapeExtensionBlockSize,

   107         NetscapeExtensionBlock,

   108         SkipBlockSize,

   109         SkipBlock,

   110         Done,

   111         Error

   112     } state;

   113     int gncols;

   114     int lncols;

   115     int ncols;

   116     int lzwsize;

   117     bool lcmap;

   118     int swidth, sheight;

   119     int width, height;

   120     int left, top, right, bottom;

   121     enum Disposal { NoDisposal, DoNotChange, RestoreBackground, RestoreImage };

   122     Disposal disposal;

   123     bool disposed;

   124     int trans_index;

   125     bool gcmap;

   126     int bgcol;

   127     int interlace;

   128     int accum;

   129     int bitcount;

   130 

   131     enum { max_lzw_bits=12 }; // (poor-compiler's static const int)

   132 

   133     int code_size, clear_code, end_code, max_code_size, max_code;

   134     int firstcode, oldcode, incode;

   135     short* table[2];

   136     short* stack;

   137     short *sp;

   138     bool needfirst;

   139     int x, y;

   140     int frame;

   141     bool out_of_bounds;

   142     bool digress;

   143     void nextY(unsigned char *bits, int bpl);

   144     void disposePrevious(QImage *image);

   145 };

   146 

   147 /*!

   148     Constructs a QGIFFormat.

   149 */

   150 QGIFFormat::QGIFFormat()

   151 {

   152     globalcmap = 0;

   153     localcmap = 0;

   154     lncols = 0;

   155     gncols = 0;

   156     disposal = NoDisposal;

   157     out_of_bounds = false;

   158     disposed = true;

   159     frame = -1;

   160     state = Header;

   161     count = 0;

   162     lcmap = false;

   163     newFrame = false;

   164     partialNewFrame = false;

   165     table[0] = 0;

   166     table[1] = 0;

   167     stack = 0;

   168 }

   169 

   170 /*!

   171     Destroys a QGIFFormat.

   172 */

   173 QGIFFormat::~QGIFFormat()

   174 {

   175     if (globalcmap) delete[] globalcmap;

   176     if (localcmap) delete[] localcmap;

   177     delete [] stack;

   178 }

   179 

   180 void QGIFFormat::disposePrevious(QImage *image)

   181 {

   182     if (out_of_bounds) {

   183         // flush anything that survived

   184         // ### Changed: QRect(0, 0, swidth, sheight)

   185     }

   186 

   187     // Handle disposal of previous image before processing next one

   188 

   189     if (disposed) return;

   190 

   191     int l = qMin(swidth-1,left);

   192     int r = qMin(swidth-1,right);

   193     int t = qMin(sheight-1,top);

   194     int b = qMin(sheight-1,bottom);

   195 

   196     switch (disposal) {

   197       case NoDisposal:

   198         break;

   199       case DoNotChange:

   200         break;

   201       case RestoreBackground:

   202         if (trans_index>=0) {

   203             // Easy:  we use the transparent color

   204             fillRect(image, l, t, r-l+1, b-t+1, Q_TRANSPARENT);

   205         } else if (bgcol>=0) {

   206             // Easy:  we use the bgcol given

   207             fillRect(image, l, t, r-l+1, b-t+1, color(bgcol));

   208         } else {

   209             // Impossible:  We don't know of a bgcol - use pixel 0

   210             QRgb *bits = (QRgb*)image->bits();

   211             fillRect(image, l, t, r-l+1, b-t+1, bits[0]);

   212         }

   213         // ### Changed: QRect(l, t, r-l+1, b-t+1)

   214         break;

   215       case RestoreImage: {

   216         if (frame >= 0) {

   217             for (int ln=t; ln<=b; ln++) {

   218                 memcpy(image->scanLine(ln)+l,

   219                     backingstore.scanLine(ln-t),

   220                     (r-l+1)*sizeof(QRgb));

   221             }

   222             // ### Changed: QRect(l, t, r-l+1, b-t+1)

   223         }

   224       }

   225     }

   226     disposal = NoDisposal; // Until an extension says otherwise.

   227 

   228     disposed = true;

   229 }

   230 

   231 /*!

   232     This function decodes some data into image changes.

   233 

   234     Returns the number of bytes consumed.

   235 */

   236 int QGIFFormat::decode(QImage *image, const uchar *buffer, int length,

   237                        int *nextFrameDelay, int *loopCount)

   238 {

   239     // We are required to state that

   240     //    "The Graphics Interchange Format(c) is the Copyright property of

   241     //    CompuServe Incorporated. GIF(sm) is a Service Mark property of

   242     //    CompuServe Incorporated."

   243 

   244     if (!stack) {

   245         stack = new short[(1 << max_lzw_bits) * 4];

   246         table[0] = &stack[(1 << max_lzw_bits) * 2];

   247         table[1] = &stack[(1 << max_lzw_bits) * 3];

   248     }

   249 

   250     image->detach();

   251     int bpl = image->bytesPerLine();

   252     unsigned char *bits = image->bits();

   253 

   254 #define LM(l, m) (((m)<<8)|l)

   255     digress = false;

   256     const int initial = length;

   257     while (!digress && length) {

   258         length--;

   259         unsigned char ch=*buffer++;

   260         switch (state) {

   261           case Header:

   262             hold[count++]=ch;

   263             if (count==6) {

   264                 // Header

   265                 gif89=(hold[3]!='8' || hold[4]!='7');

   266                 state=LogicalScreenDescriptor;

   267                 count=0;

   268             }

   269             break;

   270           case LogicalScreenDescriptor:

   271             hold[count++]=ch;

   272             if (count==7) {

   273                 // Logical Screen Descriptor

   274                 swidth=LM(hold[0], hold[1]);

   275                 sheight=LM(hold[2], hold[3]);

   276                 gcmap=!!(hold[4]&0x80);

   277                 //UNUSED: bpchan=(((hold[4]&0x70)>>3)+1);

   278                 //UNUSED: gcmsortflag=!!(hold[4]&0x08);

   279                 gncols=2<<(hold[4]&0x7);

   280                 bgcol=(gcmap) ? hold[5] : -1;

   281                 //aspect=hold[6] ? double(hold[6]+15)/64.0 : 1.0;

   282 

   283                 trans_index = -1;

   284                 count=0;

   285                 ncols=gncols;

   286                 if (gcmap) {

   287                     ccount=0;

   288                     state=GlobalColorMap;

   289                     globalcmap = new QRgb[gncols+1]; // +1 for trans_index

   290                     globalcmap[gncols] = Q_TRANSPARENT;

   291                 } else {

   292                     state=Introducer;

   293                 }

   294             }

   295             break;

   296           case GlobalColorMap: case LocalColorMap:

   297             hold[count++]=ch;

   298             if (count==3) {

   299                 QRgb rgb = qRgb(hold[0], hold[1], hold[2]);

   300                 if (state == LocalColorMap) {

   301                     if (ccount < lncols)

   302                         localcmap[ccount] =  rgb;

   303                 } else {

   304                     globalcmap[ccount] = rgb;

   305                 }

   306                 if (++ccount >= ncols) {

   307                     if (state == LocalColorMap)

   308                         state=TableImageLZWSize;

   309                     else

   310                         state=Introducer;

   311                 }

   312                 count=0;

   313             }

   314             break;

   315           case Introducer:

   316             hold[count++]=ch;

   317             switch (ch) {

   318               case ',':

   319                 state=ImageDescriptor;

   320                 break;

   321               case '!':

   322                 state=ExtensionLabel;

   323                 break;

   324               case ';':

   325                   // ### Changed: QRect(0, 0, swidth, sheight)

   326                 state=Done;

   327                 break;

   328               default:

   329                 digress=true;

   330                 // Unexpected Introducer - ignore block

   331                 state=Error;

   332             }

   333             break;

   334           case ImageDescriptor:

   335             hold[count++]=ch;

   336             if (count==10) {

   337                 int newleft=LM(hold[1], hold[2]);

   338                 int newtop=LM(hold[3], hold[4]);

   339                 int newwidth=LM(hold[5], hold[6]);

   340                 int newheight=LM(hold[7], hold[8]);

   341 

   342                 // disbelieve ridiculous logical screen sizes,

   343                 // unless the image frames are also large.

   344                 if (swidth/10 > qMax(newwidth,200))

   345                     swidth = -1;

   346                 if (sheight/10 > qMax(newheight,200))

   347                     sheight = -1;

   348 

   349                 if (swidth <= 0)

   350                     swidth = newleft + newwidth;

   351                 if (sheight <= 0)

   352                     sheight = newtop + newheight;

   353 

   354                 QImage::Format format = trans_index >= 0 ? QImage::Format_ARGB32 : QImage::Format_RGB32;

   355                 if (image->isNull()) {

   356                     (*image) = QImage(swidth, sheight, format);

   357                     bpl = image->bytesPerLine();

   358                     bits = image->bits();

   359                     memset(bits, 0, image->byteCount());

   360                 }

   361 

   362                 disposePrevious(image);

   363                 disposed = false;

   364 

   365                 left = newleft;

   366                 top = newtop;

   367                 width = newwidth;

   368                 height = newheight;

   369 

   370                 right=qMax(0, qMin(left+width, swidth)-1);

   371                 bottom=qMax(0, qMin(top+height, sheight)-1);

   372                 lcmap=!!(hold[9]&0x80);

   373                 interlace=!!(hold[9]&0x40);

   374                 //bool lcmsortflag=!!(hold[9]&0x20);

   375                 lncols=lcmap ? (2<<(hold[9]&0x7)) : 0;

   376                 if (lncols) {

   377                     if (localcmap)

   378                         delete [] localcmap;

   379                     localcmap = new QRgb[lncols+1];

   380                     localcmap[lncols] = Q_TRANSPARENT;

   381                     ncols = lncols;

   382                 } else {

   383                     ncols = gncols;

   384                 }

   385                 frame++;

   386                 if (frame == 0) {

   387                     if (left || top || width<swidth || height<sheight) {

   388                         // Not full-size image - erase with bg or transparent

   389                         if (trans_index >= 0) {

   390                             fillRect(image, 0, 0, swidth, sheight, color(trans_index));

   391                             // ### Changed: QRect(0, 0, swidth, sheight)

   392                         } else if (bgcol>=0) {

   393                             fillRect(image, 0, 0, swidth, sheight, color(bgcol));

   394                             // ### Changed: QRect(0, 0, swidth, sheight)

   395                         }

   396                     }

   397                 }

   398 

   399                 if (disposal == RestoreImage) {

   400                     int l = qMin(swidth-1,left);

   401                     int r = qMin(swidth-1,right);

   402                     int t = qMin(sheight-1,top);

   403                     int b = qMin(sheight-1,bottom);

   404                     int w = r-l+1;

   405                     int h = b-t+1;

   406 

   407                     if (backingstore.width() < w

   408                         || backingstore.height() < h) {

   409                         // We just use the backing store as a byte array

   410                         backingstore = QImage(qMax(backingstore.width(), w),

   411                                               qMax(backingstore.height(), h),

   412                                               QImage::Format_RGB32);

   413                         memset(bits, 0, image->byteCount());

   414                     }

   415                     const int dest_bpl = backingstore.bytesPerLine();

   416                     unsigned char *dest_data = backingstore.bits();

   417                     for (int ln=0; ln<h; ln++) {

   418                         memcpy(FAST_SCAN_LINE(dest_data, dest_bpl, ln),

   419                                FAST_SCAN_LINE(bits, bpl, t+ln) + l, w*sizeof(QRgb));

   420                     }

   421                 }

   422 

   423                 count=0;

   424                 if (lcmap) {

   425                     ccount=0;

   426                     state=LocalColorMap;

   427                 } else {

   428                     state=TableImageLZWSize;

   429                 }

   430                 x = left;

   431                 y = top;

   432                 accum = 0;

   433                 bitcount = 0;

   434                 sp = stack;

   435                 firstcode = oldcode = 0;

   436                 needfirst = true;

   437                 out_of_bounds = left>=swidth || y>=sheight;

   438             }

   439             break;

   440           case TableImageLZWSize: {

   441             lzwsize=ch;

   442             if (lzwsize > max_lzw_bits) {

   443                 state=Error;

   444             } else {

   445                 code_size=lzwsize+1;

   446                 clear_code=1<<lzwsize;

   447                 end_code=clear_code+1;

   448                 max_code_size=2*clear_code;

   449                 max_code=clear_code+2;

   450                 int i;

   451                 for (i=0; i<clear_code; i++) {

   452                     table[0][i]=0;

   453                     table[1][i]=i;

   454                 }

   455                 state=ImageDataBlockSize;

   456             }

   457             count=0;

   458             break;

   459           } case ImageDataBlockSize:

   460             expectcount=ch;

   461             if (expectcount) {

   462                 state=ImageDataBlock;

   463             } else {

   464                 state=Introducer;

   465                 digress = true;

   466                 newFrame = true;

   467             }

   468             break;

   469           case ImageDataBlock:

   470             count++;

   471             accum|=(ch<<bitcount);

   472             bitcount+=8;

   473             while (bitcount>=code_size && state==ImageDataBlock) {

   474                 int code=accum&((1<<code_size)-1);

   475                 bitcount-=code_size;

   476                 accum>>=code_size;

   477 

   478                 if (code==clear_code) {

   479                     if (!needfirst) {

   480                         code_size=lzwsize+1;

   481                         max_code_size=2*clear_code;

   482                         max_code=clear_code+2;

   483                     }

   484                     needfirst=true;

   485                 } else if (code==end_code) {

   486                     bitcount = -32768;

   487                     // Left the block end arrive

   488                 } else {

   489                     if (needfirst) {

   490                         firstcode=oldcode=code;

   491                         if (!out_of_bounds && image->height() > y && firstcode!=trans_index)

   492                             ((QRgb*)FAST_SCAN_LINE(bits, bpl, y))[x] = color(firstcode);

   493                         x++;

   494                         if (x>=swidth) out_of_bounds = true;

   495                         needfirst=false;

   496                         if (x>=left+width) {

   497                             x=left;

   498                             out_of_bounds = left>=swidth || y>=sheight;

   499                             nextY(bits, bpl);

   500                         }

   501                     } else {

   502                         incode=code;

   503                         if (code>=max_code) {

   504                             *sp++=firstcode;

   505                             code=oldcode;

   506                         }

   507                         while (code>=clear_code+2) {

   508                             *sp++=table[1][code];

   509                             if (code==table[0][code]) {

   510                                 state=Error;

   511                                 break;

   512                             }

   513                             if (sp-stack>=(1<<(max_lzw_bits))*2) {

   514                                 state=Error;

   515                                 break;

   516                             }

   517                             code=table[0][code];

   518                         }

   519                         *sp++=firstcode=table[1][code];

   520                         code=max_code;

   521                         if (code<(1<<max_lzw_bits)) {

   522                             table[0][code]=oldcode;

   523                             table[1][code]=firstcode;

   524                             max_code++;

   525                             if ((max_code>=max_code_size)

   526                              && (max_code_size<(1<<max_lzw_bits)))

   527                             {

   528                                 max_code_size*=2;

   529                                 code_size++;

   530                             }

   531                         }

   532                         oldcode=incode;

   533                         const int h = image->height();

   534                         const QRgb *map = lcmap ? localcmap : globalcmap;

   535                         QRgb *line = 0;

   536                         if (!out_of_bounds && h > y)

   537                             line = (QRgb*)FAST_SCAN_LINE(bits, bpl, y);

   538                         while (sp>stack) {

   539                             const uchar index = *(--sp);

   540                             if (!out_of_bounds && h > y && index!=trans_index) {

   541                                 if (index > ncols)

   542                                     line[x] = Q_TRANSPARENT;

   543                                 else

   544                                     line[x] = map ? map[index] : 0;

   545                             }

   546                             x++;

   547                             if (x>=swidth) out_of_bounds = true;

   548                             if (x>=left+width) {

   549                                 x=left;

   550                                 out_of_bounds = left>=swidth || y>=sheight;

   551                                 nextY(bits, bpl);

   552                                 if (!out_of_bounds && h > y)

   553                                     line = (QRgb*)FAST_SCAN_LINE(bits, bpl, y);

   554                             }

   555                         }

   556                     }

   557                 }

   558             }

   559             partialNewFrame = true;

   560             if (count==expectcount) {

   561                 count=0;

   562                 state=ImageDataBlockSize;

   563             }

   564             break;

   565           case ExtensionLabel:

   566             switch (ch) {

   567             case 0xf9:

   568                 state=GraphicControlExtension;

   569                 break;

   570             case 0xff:

   571                 state=ApplicationExtension;

   572                 break;

   573 #if 0

   574             case 0xfe:

   575                 state=CommentExtension;

   576                 break;

   577             case 0x01:

   578                 break;

   579 #endif

   580             default:

   581                 state=SkipBlockSize;

   582             }

   583             count=0;

   584             break;

   585           case ApplicationExtension:

   586             if (count<11) hold[count]=ch;

   587             count++;

   588             if (count==hold[0]+1) {

   589                 if (qstrncmp((char*)(hold+1), "NETSCAPE", 8)==0) {

   590                     // Looping extension

   591                     state=NetscapeExtensionBlockSize;

   592                 } else {

   593                     state=SkipBlockSize;

   594                 }

   595                 count=0;

   596             }

   597             break;

   598           case NetscapeExtensionBlockSize:

   599             expectcount=ch;

   600             count=0;

   601             if (expectcount) state=NetscapeExtensionBlock;

   602             else state=Introducer;

   603             break;

   604           case NetscapeExtensionBlock:

   605             if (count<3) hold[count]=ch;

   606             count++;

   607             if (count==expectcount) {

   608                 *loopCount = hold[1]+hold[2]*256;

   609                 state=SkipBlockSize; // Ignore further blocks

   610             }

   611             break;

   612           case GraphicControlExtension:

   613             if (count<5) hold[count]=ch;

   614             count++;

   615             if (count==hold[0]+1) {

   616                 disposePrevious(image);

   617                 disposal=Disposal((hold[1]>>2)&0x7);

   618                 //UNUSED: waitforuser=!!((hold[1]>>1)&0x1);

   619                 int delay=count>3 ? LM(hold[2], hold[3]) : 1;

   620                 // IE and mozilla use a minimum delay of 10. With the minimum delay of 10

   621                 // we are compatible to them and avoid huge loads on the app and xserver.

   622                 *nextFrameDelay = (delay < 2 ? 10 : delay) * 10;

   623 

   624                 bool havetrans=hold[1]&0x1;

   625                 trans_index = havetrans ? hold[4] : -1;

   626 

   627                 count=0;

   628                 state=SkipBlockSize;

   629             }

   630             break;

   631           case SkipBlockSize:

   632             expectcount=ch;

   633             count=0;

   634             if (expectcount) state=SkipBlock;

   635             else state=Introducer;

   636             break;

   637           case SkipBlock:

   638             count++;

   639             if (count==expectcount) state=SkipBlockSize;

   640             break;

   641           case Done:

   642             digress=true;

   643             /* Netscape ignores the junk, so we do too.

   644             length++; // Unget

   645             state=Error; // More calls to this is an error

   646             */

   647             break;

   648           case Error:

   649             return -1; // Called again after done.

   650         }

   651     }

   652     return initial-length;

   653 }

   654 

   655 /*!

   656    Scans through the data stream defined by \a device and returns the image

   657    sizes found in the stream in the \a imageSizes vector.

   658 */

   659 void QGIFFormat::scan(QIODevice *device, QVector<QSize> *imageSizes, int *loopCount)

   660 {

   661     if (!device)

   662         return;

   663 

   664     qint64 oldPos = device->pos();

   665     if (!device->seek(0))

   666         return;

   667 

   668     int colorCount = 0;

   669     int localColorCount = 0;

   670     int globalColorCount = 0;

   671     int colorReadCount = 0;

   672     bool localColormap = false;

   673     bool globalColormap = false;

   674     int count = 0;

   675     int blockSize = 0;

   676     int imageWidth = 0;

   677     int imageHeight = 0;

   678     bool done = false;

   679     uchar hold[16];

   680     State state = Header;

   681 

   682     const int readBufferSize = 40960; // 40k read buffer

   683     QByteArray readBuffer(device->read(readBufferSize));

   684 

   685     if (readBuffer.isEmpty()) {

   686         device->seek(oldPos);

   687         return;

   688     }

   689 

   690     // This is a specialized version of the state machine from decode(),

   691     // which doesn't do any image decoding or mallocing, and has an

   692     // optimized way of skipping SkipBlocks, ImageDataBlocks and

   693     // Global/LocalColorMaps.

   694 

   695     while (!readBuffer.isEmpty()) {

   696         int length = readBuffer.size();

   697         const uchar *buffer = (const uchar *) readBuffer.constData();

   698         while (!done && length) {

   699             length--;

   700             uchar ch = *buffer++;

   701             switch (state) {

   702             case Header:

   703                 hold[count++] = ch;

   704                 if (count == 6) {

   705                     state = LogicalScreenDescriptor;

   706                     count = 0;

   707                 }

   708                 break;

   709             case LogicalScreenDescriptor:

   710                 hold[count++] = ch;

   711                 if (count == 7) {

   712                     imageWidth = LM(hold[0], hold[1]);

   713                     imageHeight = LM(hold[2], hold[3]);

   714                     globalColormap = !!(hold[4] & 0x80);

   715                     globalColorCount = 2 << (hold[4] & 0x7);

   716                     count = 0;

   717                     colorCount = globalColorCount;

   718                     if (globalColormap) {

   719                         int colorTableSize = 3 * globalColorCount;

   720                         if (length >= colorTableSize) {

   721                             // skip the global color table in one go

   722                             length -= colorTableSize;

   723                             buffer += colorTableSize;

   724                             state = Introducer;

   725                         } else {

   726                             colorReadCount = 0;

   727                             state = GlobalColorMap;

   728                         }

   729                     } else {

   730                         state=Introducer;

   731                     }

   732                 }

   733                 break;

   734             case GlobalColorMap:

   735             case LocalColorMap:

   736                 hold[count++] = ch;

   737                 if (count == 3) {

   738                     if (++colorReadCount >= colorCount) {

   739                         if (state == LocalColorMap)

   740                             state = TableImageLZWSize;

   741                         else

   742                             state = Introducer;

   743                     }

   744                     count = 0;

   745                 }

   746                 break;

   747             case Introducer:

   748                 hold[count++] = ch;

   749                 switch (ch) {

   750                 case 0x2c:

   751                     state = ImageDescriptor;

   752                     break;

   753                 case 0x21:

   754                     state = ExtensionLabel;

   755                     break;

   756                 case 0x3b:

   757                     state = Done;

   758                     break;

   759                 default:

   760                     done = true;

   761                     state = Error;

   762                 }

   763                 break;

   764             case ImageDescriptor:

   765                 hold[count++] = ch;

   766                 if (count == 10) {

   767                     int newLeft = LM(hold[1], hold[2]);

   768                     int newTop = LM(hold[3], hold[4]);

   769                     int newWidth = LM(hold[5], hold[6]);

   770                     int newHeight = LM(hold[7], hold[8]);

   771 

   772                     if (imageWidth/10 > qMax(newWidth,200))

   773                         imageWidth = -1;

   774                     if (imageHeight/10 > qMax(newHeight,200))

   775                         imageHeight = -1;

   776 

   777                     if (imageWidth <= 0)

   778                         imageWidth = newLeft + newWidth;

   779                     if (imageHeight <= 0)

   780                         imageHeight = newTop + newHeight;

   781 

   782                     *imageSizes << QSize(imageWidth, imageHeight);

   783 

   784                     localColormap = !!(hold[9] & 0x80);

   785                     localColorCount = localColormap ? (2 << (hold[9] & 0x7)) : 0;

   786                     if (localColorCount)

   787                         colorCount = localColorCount;

   788                     else

   789                         colorCount = globalColorCount;

   790 

   791                     count = 0;

   792                     if (localColormap) {

   793                         int colorTableSize = 3 * localColorCount;

   794                         if (length >= colorTableSize) {

   795                             // skip the local color table in one go

   796                             length -= colorTableSize;

   797                             buffer += colorTableSize;

   798                             state = TableImageLZWSize;

   799                         } else {

   800                             colorReadCount = 0;

   801                             state = LocalColorMap;

   802                         }

   803                     } else {

   804                         state = TableImageLZWSize;

   805                     }

   806                 }

   807                 break;

   808             case TableImageLZWSize:

   809                 if (ch > max_lzw_bits)

   810                     state = Error;

   811                 else

   812                     state = ImageDataBlockSize;

   813                 count = 0;

   814                 break;

   815             case ImageDataBlockSize:

   816                 blockSize = ch;

   817                 if (blockSize) {

   818                     if (length >= blockSize) {

   819                         // we can skip the block in one go

   820                         length -= blockSize;

   821                         buffer += blockSize;

   822                         count = 0;

   823                     } else {

   824                         state = ImageDataBlock;

   825                     }

   826                 } else {

   827                     state = Introducer;

   828                 }

   829                 break;

   830             case ImageDataBlock:

   831                 ++count;

   832                 if (count == blockSize) {

   833                     count = 0;

   834                     state = ImageDataBlockSize;

   835                 }

   836                 break;

   837             case ExtensionLabel:

   838                 switch (ch) {

   839                 case 0xf9:

   840                     state = GraphicControlExtension;

   841                     break;

   842                 case 0xff:

   843                     state = ApplicationExtension;

   844                     break;

   845                 default:

   846                     state = SkipBlockSize;

   847                 }

   848                 count = 0;

   849                 break;

   850             case ApplicationExtension:

   851                 if (count < 11)

   852                     hold[count] = ch;

   853                 ++count;

   854                 if (count == hold[0] + 1) {

   855                     if (qstrncmp((char*)(hold+1), "NETSCAPE", 8) == 0)

   856                         state=NetscapeExtensionBlockSize;

   857                     else

   858                         state=SkipBlockSize;

   859                     count = 0;

   860                 }

   861                 break;

   862             case GraphicControlExtension:

   863                 if (count < 5)

   864                     hold[count] = ch;

   865                 ++count;

   866                 if (count == hold[0] + 1) {

   867                     count = 0;

   868                     state = SkipBlockSize;

   869                 }

   870                 break;

   871             case NetscapeExtensionBlockSize:

   872                 blockSize = ch;

   873                 count = 0;

   874                 if (blockSize)

   875                     state = NetscapeExtensionBlock;

   876                 else

   877                     state = Introducer;

   878                 break;

   879             case NetscapeExtensionBlock:

   880                 if (count < 3)

   881                     hold[count] = ch;

   882                 count++;

   883                 if (count == blockSize) {

   884                     *loopCount = LM(hold[1], hold[2]);

   885                     state = SkipBlockSize;

   886                 }

   887                 break;

   888             case SkipBlockSize:

   889                 blockSize = ch;

   890                 count = 0;

   891                 if (blockSize) {

   892                     if (length >= blockSize) {

   893                         // we can skip the block in one go

   894                         length -= blockSize;

   895                         buffer += blockSize;

   896                     } else {

   897                         state = SkipBlock;

   898                     }

   899                 } else {

   900                     state = Introducer;

   901                 }

   902                 break;

   903             case SkipBlock:

   904                 ++count;

   905                 if (count == blockSize)

   906                     state = SkipBlockSize;

   907                 break;

   908             case Done:

   909                 done = true;

   910                 break;

   911             case Error:

   912                 device->seek(oldPos);

   913                 return;

   914             }

   915         }

   916         readBuffer = device->read(readBufferSize);

   917     }

   918     device->seek(oldPos);

   919     return;

   920 }

   921 

   922 void QGIFFormat::fillRect(QImage *image, int col, int row, int w, int h, QRgb color)

   923 {

   924     if (w>0) {

   925         for (int j=0; j<h; j++) {

   926             QRgb *line = (QRgb*)image->scanLine(j+row);

   927             for (int i=0; i<w; i++)

   928                 *(line+col+i) = color;

   929         }

   930     }

   931 }

   932 

   933 void QGIFFormat::nextY(unsigned char *bits, int bpl)

   934 {

   935     int my;

   936     switch (interlace) {

   937     case 0: // Non-interlaced

   938         // if (!out_of_bounds) {

   939         //     ### Changed: QRect(left, y, right - left + 1, 1);

   940         // }

   941         y++;

   942         break;

   943     case 1: {

   944         int i;

   945         my = qMin(7, bottom-y);

   946         // Don't dup with transparency

   947         if (trans_index < 0) {

   948             for (i=1; i<=my; i++) {

   949                 memcpy(FAST_SCAN_LINE(bits, bpl, y+i)+left*sizeof(QRgb), FAST_SCAN_LINE(bits, bpl, y)+left*sizeof(QRgb),

   950                        (right-left+1)*sizeof(QRgb));

   951             }

   952         }

   953 

   954         // if (!out_of_bounds) {

   955         //     ### Changed: QRect(left, y, right - left + 1, my + 1);

   956         // }

   957 //        if (!out_of_bounds)

   958 //            qDebug("consumer->changed(QRect(%d, %d, %d, %d))", left, y, right-left+1, my+1);

   959         y+=8;

   960         if (y>bottom) {

   961             interlace++; y=top+4;

   962             if (y > bottom) { // for really broken GIFs with bottom < 5

   963                 interlace=2;

   964                 y = top + 2;

   965                 if (y > bottom) { // for really broken GIF with bottom < 3

   966                     interlace = 0;

   967                     y = top + 1;

   968                 }

   969             }

   970         }

   971     } break;

   972     case 2: {

   973         int i;

   974         my = qMin(3, bottom-y);

   975         // Don't dup with transparency

   976         if (trans_index < 0) {

   977             for (i=1; i<=my; i++) {

   978                 memcpy(FAST_SCAN_LINE(bits, bpl, y+i)+left*sizeof(QRgb), FAST_SCAN_LINE(bits, bpl, y)+left*sizeof(QRgb),

   979                        (right-left+1)*sizeof(QRgb));

   980             }

   981         }

   982 

   983         // if (!out_of_bounds) {

   984         //     ### Changed: QRect(left, y, right - left + 1, my + 1);

   985         // }

   986         y+=8;

   987         if (y>bottom) {

   988             interlace++; y=top+2;

   989             // handle broken GIF with bottom < 3

   990             if (y > bottom) {

   991                 interlace = 3;

   992                 y = top + 1;

   993             }

   994         }

   995     } break;

   996     case 3: {

   997         int i;

   998         my = qMin(1, bottom-y);

   999         // Don't dup with transparency

  1000         if (trans_index < 0) {

  1001             for (i=1; i<=my; i++) {

  1002                 memcpy(FAST_SCAN_LINE(bits, bpl, y+i)+left*sizeof(QRgb), FAST_SCAN_LINE(bits, bpl, y)+left*sizeof(QRgb),

  1003                        (right-left+1)*sizeof(QRgb));

  1004             }

  1005         }

  1006         // if (!out_of_bounds) {

  1007         //     ### Changed: QRect(left, y, right - left + 1, my + 1);

  1008         // }

  1009         y+=4;

  1010         if (y>bottom) { interlace++; y=top+1; }

  1011     } break;

  1012     case 4:

  1013         // if (!out_of_bounds) {

  1014         //     ### Changed: QRect(left, y, right - left + 1, 1);

  1015         // }

  1016         y+=2;

  1017     }

  1018 

  1019     // Consume bogus extra lines

  1020     if (y >= sheight) out_of_bounds=true; //y=bottom;

  1021 }

  1022 

  1023 inline QRgb QGIFFormat::color(uchar index) const

  1024 {

  1025     if (index == trans_index || index > ncols)

  1026         return Q_TRANSPARENT;

  1027 

  1028     QRgb *map = lcmap ? localcmap : globalcmap;

  1029     return map ? map[index] : 0;

  1030 }

  1031 

  1032 //-------------------------------------------------------------------------

  1033 //-------------------------------------------------------------------------

  1034 //-------------------------------------------------------------------------

  1035 

  1036 QGifHandler::QGifHandler()

  1037 {

  1038     gifFormat = new QGIFFormat;

  1039     nextDelay = 100;

  1040     loopCnt = 1;

  1041     frameNumber = -1;

  1042     scanIsCached = false;

  1043 }

  1044 

  1045 QGifHandler::~QGifHandler()

  1046 {

  1047     delete gifFormat;

  1048 }

  1049 

  1050 // Does partial decode if necessary, just to see if an image is coming

  1051 

  1052 bool QGifHandler::imageIsComing() const

  1053 {

  1054     const int GifChunkSize = 4096;

  1055 

  1056     while (!gifFormat->partialNewFrame) {

  1057         if (buffer.isEmpty()) {

  1058             buffer += device()->read(GifChunkSize);

  1059             if (buffer.isEmpty())

  1060                 break;

  1061         }

  1062 

  1063         int decoded = gifFormat->decode(&lastImage, (const uchar *)buffer.constData(), buffer.size(),

  1064                                         &nextDelay, &loopCnt);

  1065         if (decoded == -1)

  1066             break;

  1067         buffer.remove(0, decoded);

  1068     }

  1069     return gifFormat->partialNewFrame;

  1070 }

  1071 

  1072 bool QGifHandler::canRead() const

  1073 {

  1074     if (canRead(device()) || imageIsComing()) {

  1075         setFormat("gif");

  1076         return true;

  1077     }

  1078 

  1079     return false;

  1080 }

  1081 

  1082 bool QGifHandler::canRead(QIODevice *device)

  1083 {

  1084     if (!device) {

  1085         qWarning("QGifHandler::canRead() called with no device");

  1086         return false;

  1087     }

  1088 

  1089     char head[6];

  1090     if (device->peek(head, sizeof(head)) == sizeof(head))

  1091         return qstrncmp(head, "GIF87a", 6) == 0

  1092             || qstrncmp(head, "GIF89a", 6) == 0;

  1093     return false;

  1094 }

  1095 

  1096 bool QGifHandler::read(QImage *image)

  1097 {

  1098     const int GifChunkSize = 4096;

  1099 

  1100     while (!gifFormat->newFrame) {

  1101         if (buffer.isEmpty()) {

  1102             buffer += device()->read(GifChunkSize);

  1103             if (buffer.isEmpty())

  1104                 break;

  1105         }

  1106 

  1107         int decoded = gifFormat->decode(&lastImage, (const uchar *)buffer.constData(), buffer.size(),

  1108                                         &nextDelay, &loopCnt);

  1109         if (decoded == -1)

  1110             break;

  1111         buffer.remove(0, decoded);

  1112     }

  1113     if (gifFormat->newFrame || (gifFormat->partialNewFrame && device()->atEnd())) {

  1114         *image = lastImage;

  1115         ++frameNumber;

  1116         gifFormat->newFrame = false;

  1117         gifFormat->partialNewFrame = false;

  1118         return true;

  1119     }

  1120 

  1121     return false;

  1122 }

  1123 

  1124 bool QGifHandler::write(const QImage &image)

  1125 {

  1126     Q_UNUSED(image);

  1127     return false;

  1128 }

  1129 

  1130 bool QGifHandler::supportsOption(ImageOption option) const

  1131 {

  1132     if (!device() || device()->isSequential())

  1133         return option == Animation;

  1134     else

  1135         return option == Size