开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
gifread.c
资源名称：gif2png-2.3.2.tar.gz　[点击查看]
上传用户：sorock1981
上传日期：2007-01-06
资源大小：73k
文件大小：19k
源码类别：

图片显示

开发平台：

Unix_Linux

gifread.c：源码内容
  1. /* This code is Copyright 1990 - 1994, David Koblas <koblas@netcom.com> */
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include "gif2png.h"
  8. #define TRUE    1
  9. #define FALSE   0
  11. #define CM_RED          0
  12. #define CM_GREEN        1
  13. #define CM_BLUE         2
  15. #define MAX_LWZ_BITS            12
  17. #define INTERLACE               0x40
  18. #define GLOBALCOLORMAP  0x80
  19. #define LOCALCOLORMAP   0x80
  20. #define BitSet(byte, bit)       (((byte) & (bit)) == (bit))
  22. #define ReadOK(file,buffer,len) (fread(buffer, len, 1, file) != 0)
  24. #define LM_to_uint(a,b)                 (((b)<<8)|(a))
  26. struct gif_scr GifScreen;
  28. struct {
  29.   int   transparent;
  30.   int   delayTime;
  31.   int   inputFlag;
  32.   int   disposal;
  33. } Gif89;
  35. extern int c_437_l1[];
  36. extern int verbose;
  38. static int ReadColorMap(FILE *fd, int number, GifColor buffer[MAXCMSIZE]);
  39. static int DoExtension(FILE *fd, int label);
  40. static int GetDataBlock(FILE *fd, unsigned char  *buf);
  41. static int ReadImage(FILE *fd, int x_off, int y_off, int len, int height, int cmapSize, GifColor cmap[MAXCMSIZE], int interlace);
  43. int imagecount;
  44. int recover_message; /* ==TRUE message already printed */
  46. /* check if recover option is active, if not, print warning */
  48. int check_recover(int some_data)
  49. {
  50.   if(recover)
  51.     return imagecount;
  52.   if(!recover_message && (imagecount>0 || some_data)) {
  53.     fprintf(stderr, "gif2png: image reading error, use option -r to recover ");
  54.     if(imagecount>0)
  55.       fprintf(stderr, "%d complete image%s ", imagecount,
  56.               (imagecount>1?"s":""));
  57.     if(imagecount>0 && some_data)
  58.       fprintf(stderr, "and ");
  59.     if(some_data)
  60.       fprintf(stderr, "partial data of a broken image");
  61.     fprintf(stderr, "n");
  62.     recover_message=TRUE;
  63.   }
  64.   return -1;
  65. }
  67. int
  68. ReadGIF(FILE *fd)
  69. {
  70.   unsigned char buf[16];
  71.   unsigned char c;
  72.   GifColor      localColorMap[MAXCMSIZE];
  73.   int           useGlobalColormap;
  74.   int           bitPixel;
  75.   char          gif_version[4];
  76.   int i;
  77.   int w, h, x_off, y_off;
  79.   imagecount=0;
  80.   recover_message=FALSE;
  82.   /*
  83.    * Initialize GIF89 extensions
  84.    */
  85.   Gif89.transparent = -1;
  86.   Gif89.delayTime = -1;
  87.   Gif89.inputFlag = -1;
  88.   Gif89.disposal = 0;
  90.   if (! ReadOK(fd,buf,6)) {
  91.     fprintf(stderr, "gif2png: error reading magic numbern");
  92.     return(-1);
  93.   }
  95.   if (strncmp((char *)buf,"GIF",3) != 0) {
  96.     fprintf(stderr, "gif2png: not a GIF filen");
  97.     return(-1);
  98.   }
  100.   strncpy(gif_version, (char *)buf + 3, 3);
  101.   gif_version[3] = '';
  103.   if ((strcmp(gif_version, "87a") != 0) && (strcmp(gif_version, "89a") != 0)) {
  104.     fprintf(stderr, "gif2png: bad version number, not '87a' or '89a', trying anywayn");
  105.   }
  107.   if (! ReadOK(fd,buf,7)) {
  108.     fprintf(stderr, "gif2png: failed to read screen descriptorn");
  109.     return(-1);
  110.   }
  112.   GifScreen.Width           = LM_to_uint(buf[0],buf[1]);
  113.   GifScreen.Height          = LM_to_uint(buf[2],buf[3]);
  114.   GifScreen.BitPixel        = 2<<(buf[4]&0x07);
  115.   GifScreen.ColorResolution = (((buf[4]&0x70)>>3)+1);
  116.   GifScreen.ColorMap_present = BitSet(buf[4], GLOBALCOLORMAP);
  118.   if (GifScreen.ColorMap_present) {     /* Global Colormap */
  120.     if (ReadColorMap(fd,GifScreen.BitPixel,GifScreen.ColorMap)) {
  121.       fprintf(stderr, "gif2png: error reading global colormapn");
  122.       return(-1);
  123.     }
  124.   } else {
  125.     /* the GIF spec says that if neither global nor local
  126.      * color maps are present, the decoder should use a system
  127.      * default map, which should have black and white as the
  128.      * first two colors. So we use black, white, red, green, blue,
  129.      * yellow, purple and cyan.
  130.      * I don't think missing color tables are a common case,
  131.      * at least it's not handled by most GIF readers.
  132.      */
  134.     static int colors[]={0, 7, 1, 2, 4, 3, 5, 6};
  136.     for(i=0 ; i<MAXCMSIZE-8 ; i++) {
  137.       GifScreen.ColorMap[i].red   = (colors[i&7]&1) ? ((255-i)&0xf8) : 0;
  138.       GifScreen.ColorMap[i].green = (colors[i&7]&2) ? ((255-i)&0xf8) : 0;
  139.       GifScreen.ColorMap[i].blue  = (colors[i&7]&4) ? ((255-i)&0xf8) : 0;
  140.     }
  141.     for(i=MAXCMSIZE-8 ; i<MAXCMSIZE; i++) {
  142.       GifScreen.ColorMap[i].red   = (colors[i&7]&1) ? 4 : 0;
  143.       GifScreen.ColorMap[i].green = (colors[i&7]&2) ? 4 : 0;
  144.       GifScreen.ColorMap[i].blue  = (colors[i&7]&4) ? 4 : 0;
  145.     }
  146.   }
  148.   if(GifScreen.ColorMap_present) {
  149.     GifScreen.Background       = buf[5];
  150.   } else {
  151.     GifScreen.Background       = -1; /* background unspecified */
  152.   }
  154.   GifScreen.AspectRatio     = buf[6];
  156.   while (1) {
  157.     if (! ReadOK(fd,&c,1)) {
  158.       fprintf(stderr, "gif2png: EOF / read error on image datan");
  159.       return check_recover(FALSE);
  160.     }
  162.     if (c == GIFterminator) {           /* GIF terminator */
  163.       if (verbose > 1)
  164.         fprintf(stderr, "gif2png: end of GIF data streamn");
  165.       return(imagecount);
  166.     }
  168.     if (c == GIFextension) {    /* Extension */
  169.       if (! ReadOK(fd,&c,1)) {
  170.         fprintf(stderr, "gif2png: EOF / read error on extension function coden");
  171.         return check_recover(FALSE);
  172.       }
  173.       if(DoExtension(fd, c))
  174.         return check_recover(FALSE);
  175.       continue;
  176.     }
  178.     if (c != GIFimage) {                /* Not a valid start character */
  179.       fprintf(stderr, "gif2png: bogus character 0x%02xn",
  180.               (int)c);
  181.       return check_recover(FALSE);
  182.     }
  184.     if (! ReadOK(fd,buf,9)) {
  185.       fprintf(stderr,"gif2png: couldn't read left/top/width/heightn");
  186.       return check_recover(FALSE);
  187.     }
  189.     useGlobalColormap = ! BitSet(buf[8], LOCALCOLORMAP);
  191.     bitPixel = 1<<((buf[8]&0x07)+1);
  193.     x_off = LM_to_uint(buf[0],buf[1]);
  194.     y_off = LM_to_uint(buf[1],buf[2]);
  195.     w = LM_to_uint(buf[4],buf[5]);
  196.     h = LM_to_uint(buf[6],buf[7]);
  198.     if (! useGlobalColormap) {
  199.       if (ReadColorMap(fd,bitPixel,localColorMap)) {
  200.         fprintf(stderr, "gif2png: error reading local colormapn");
  201.         return check_recover(FALSE);
  202.       }
  204.       if(!ReadImage(fd, x_off, y_off, w, h, bitPixel,
  205.                     localColorMap, BitSet(buf[8], INTERLACE))) {
  206.         imagecount++;
  207.       }
  208.     } else {
  209.       if(!GifScreen.ColorMap_present) {
  210.         if (verbose > 1)
  211.           fprintf(stderr, "gif2png: neither global nor local colormap, using defaultn");
  212.       }
  214.       if(!ReadImage(fd, x_off, y_off, w, h, GifScreen.BitPixel,
  215.                     GifScreen.ColorMap,  BitSet(buf[8], INTERLACE))) {
  216.         imagecount++;
  217.       }
  218.     }
  220.     /*
  221.      * reset GIF89 extensions after image
  222.      */
  223.     Gif89.transparent = -1;
  224.     Gif89.delayTime = -1;
  225.     Gif89.inputFlag = -1;
  226.     Gif89.disposal = 0;
  227.   }
  228. }
  230. static int
  231. ReadColorMap(FILE *fd, int number, GifColor colors[MAXCMSIZE])
  232. {
  233.   int   i;
  234.   byte  rgb[3];
  236.   for (i = 0; i < number; ++i) {
  237.     if (! ReadOK(fd, rgb, sizeof(rgb))) {
  238.       fprintf(stderr, "gif2png: bad colormapn");
  239.       return(TRUE);
  240.     }
  242.     colors[i].red   = rgb[0];
  243.     colors[i].green = rgb[1];
  244.     colors[i].blue  = rgb[2];
  245.   }
  247.   for (i = number; i<MAXCMSIZE; ++i) {
  248.     colors[i].red   = 0;
  249.     colors[i].green = 0;
  250.     colors[i].blue  = 0;
  251.   }
  253.   return FALSE;
  254. }
  256. static int
  257. DoExtension(FILE *fd, int label)
  258. {
  259.   static char   buf[256];
  260.   char *str;
  261.   char *p,*p2;
  262.   int size;
  263.   int last_cr;
  265.   switch (label) {
  266.   case GIFplaintext:            /* Plain Text Extension */
  267.     str = "Plain Text Extension";
  268.     /*
  269.      * reset GIF89 extensions after Plain Text
  270.      */
  271.     Gif89.transparent = -1;
  272.     Gif89.delayTime = -1;
  273.     Gif89.inputFlag = -1;
  274.     Gif89.disposal = 0;
  275.     if (verbose > 1)
  276.         fprintf(stderr, "gif2png: got a 'Plain Text Extension' extension (skipping)n");
  278.       while (GetDataBlock(fd, (unsigned char*) buf) > 0)
  279.         continue;
  280.       return (0);
  282.   case GIFapplication:/* Application Extension */
  283.     str = "Application Extension";
  284.     break;
  286.   case GIFcomment:      /* Comment Extension */
  287.     allocate_element(); /* current now points to new element struct */
  289.     /* the GIF89a spec defines comment extensions to contain ASCII text,
  290.        but doesn't specify what end-of-line delimiter is to be used.
  291.        Most programs use DOS style (CR/LF), at least one uses CR (Graphic
  292.        Workshop for Windows), unix programs probably use LF. We just delete
  293.        CRs unless they are not followed by a LF, then we convert CR to LF.
  294.        Even though 7 bit ASCII is specified, there are some GIF files with
  295.        comments that use codepage 437 and most DOS GIF readers display this
  296.        in the DOS charset (e.g. VPIC). We convert the characters both in
  297.        cp437 and latin1 and try to approximate some of the box drawing chars.
  298.     */
  300.     last_cr=0;
  302.     while ((size=GetDataBlock(fd, (unsigned char*) buf)) > 0) {
  304.       p2=p=buf;
  306.       /* take care of CR as last char of one sub-block and no LF at first of
  307.          the next */
  308.       if(last_cr && *p!='n') {
  309.         store_block("n",1);
  310.         last_cr=0;
  311.       }
  313.       while(p-buf<size) {
  314.         if(last_cr) {
  315.           if(*p!='n')
  316.             *p2++='n';
  317.           last_cr=0;
  318.         }
  319.         if(*p=='r')
  320.           last_cr=1;
  321.         else
  322.           *p2++=c_437_l1[(unsigned char)*p];
  323.         p++;
  324.       }
  325.       size=p2-buf;
  327.       store_block(buf, size);
  328.     }
  330.     if (verbose > 1)
  331.       fprintf(stderr, "gif2png: got a 'Comment Extension' extensionn");
  333.     current->GIFtype=label;
  335.     fix_current();
  336.     return 0;
  338.   case GIFgraphicctl:           /* Graphic Control Extension */
  339.     str = "Graphic Control Extension";
  340.     size = GetDataBlock(fd, (unsigned char*) buf);
  341.     Gif89.disposal    = (buf[0] >> 2) & 0x7;
  342.     Gif89.inputFlag   = (buf[0] >> 1) & 0x1;
  343.     Gif89.delayTime   = LM_to_uint(buf[1],buf[2]);
  344.     if ((buf[0] & 0x1) != 0)
  345.       Gif89.transparent = (int)((unsigned char)buf[3]);
  347.     if(Gif89.disposal==0 && Gif89.inputFlag==0 &&
  348.        Gif89.delayTime==0) {
  350.       /* do not keep GCEs only indicating transparency */
  352.       while (GetDataBlock(fd, (unsigned char*) buf) > 0)
  353.         ;
  355.       return (0);
  356.     } else {
  357.       /* copy block already read */
  358.       allocate_element(); /* current now points to new element struct */
  360.       goto copy_block;
  361.     }
  362.   default:
  363.     if (verbose > 1)
  364.       fprintf(stderr, "gif2png: skipping unknown extension 0x%02xn",
  365.             (unsigned char)label);
  366.     while (GetDataBlock(fd, (unsigned char*) buf) > 0)
  367.       ;
  368.     return (1);
  369.   }
  371.   allocate_element(); /* current now points to new element struct */
  373.   while ((size=GetDataBlock(fd, (unsigned char*) buf)) > 0) {
  374. copy_block:
  375.     store_block(buf, size);
  376.   }
  378.   if (verbose > 1)
  379.     fprintf(stderr, "gif2png: got a '%s' extensionn", str);
  381.   current->GIFtype=label;
  383.   fix_current();
  385.   return (0);
  386. }
  388. static int      ZeroDataBlock = FALSE;
  390. static int
  391. GetDataBlock(FILE *fd, unsigned char *buf)
  392. {
  393.   unsigned char count;
  395.   count = 0;
  396.   if (! ReadOK(fd, &count, 1)) {
  397.     fprintf(stderr, "gif2png: error in getting DataBlock sizen");
  398.     return -1;
  399.   }
  401.   ZeroDataBlock = count == 0;
  403.   if ((count != 0) && (! ReadOK(fd, buf, count))) {
  404.     fprintf(stderr, "gif2png: error in reading DataBlockn");
  405.     return -1;
  406.   }
  408.   return((int)count);
  409. }
  411. /*
  412. **  Pulled out of nextCode
  413. */
  414. static  int             curbit, lastbit, get_done, last_byte;
  415. static  int             return_clear;
  416. /*
  417. **  Out of nextLWZ
  418. */
  419. static int      stack[(1<<(MAX_LWZ_BITS))*2], *sp;
  420. static int      code_size, set_code_size;
  421. static int      max_code, max_code_size;
  422. static int      clear_code, end_code;
  424. static void initLWZ(int input_code_size)
  425. {
  426.   set_code_size = input_code_size;
  427.   code_size     = set_code_size + 1;
  428.   clear_code    = 1 << set_code_size ;
  429.   end_code      = clear_code + 1;
  430.   max_code_size = 2 * clear_code;
  431.   max_code      = clear_code + 2;
  433.   curbit = lastbit = 0;
  434.   last_byte = 2;
  435.   get_done = FALSE;
  437.   return_clear = TRUE;
  439.   sp = stack;
  440. }
  442. static int nextCode(FILE *fd, int code_size)
  443. {
  444.   static unsigned char    buf[280];
  445.   static int maskTbl[16] = {
  446.     0x0000, 0x0001, 0x0003, 0x0007,
  447.     0x000f, 0x001f, 0x003f, 0x007f,
  448.     0x00ff, 0x01ff, 0x03ff, 0x07ff,
  449.     0x0fff, 0x1fff, 0x3fff, 0x7fff,
  450.   };
  451.   int i, j, end;
  452.   long ret;
  454.   if (return_clear) {
  455.     return_clear = FALSE;
  456.     return clear_code;
  457.   }
  459.   end = curbit + code_size;
  461.   if (end >= lastbit) {
  462.     int     count;
  464.     if (get_done) {
  465.       if (verbose && curbit >= lastbit) {
  466.         fprintf(stderr, "gif2png: ran off the end of input bitsn");
  467.       }
  468.       return -1;
  469.     }
  470.     buf[0] = buf[last_byte-2];
  471.     buf[1] = buf[last_byte-1];
  473.     if ((count = GetDataBlock(fd, &buf[2])) == 0)
  474.       get_done = TRUE;
  476.     if (count<0) return -1;
  478.     last_byte = 2 + count;
  479.     curbit = (curbit - lastbit) + 16;
  480.     lastbit = (2+count)*8 ;
  482.     end = curbit + code_size;
  483.   }
  485.   j = end / 8;
  486.   i = curbit / 8;
  488.   if (i == j)
  489.     ret = (long)buf[i];
  490.   else if (i + 1 == j)
  491.     ret = (long)buf[i] | ((long)buf[i+1] << 8);
  492.   else
  493.     ret = (long)buf[i] | ((long)buf[i+1] << 8) | ((long)buf[i+2] << 16);
  495.   ret = (ret >> (curbit % 8)) & maskTbl[code_size];
  497.   curbit += code_size;
  499.   return (int)ret;
  500. }
  502. #define readLWZ(fd) ((sp > stack) ? *--sp : nextLWZ(fd))
  504. static int nextLWZ(FILE *fd)
  505. {
  506.   static int       table[2][(1<< MAX_LWZ_BITS)];
  507.   static int       firstcode, oldcode;
  508.   int              code, incode;
  509.   register int     i;
  511.   while ((code = nextCode(fd, code_size)) >= 0) {
  512.     if (code == clear_code) {
  514.       /* corrupt GIFs can make this happen */
  515.       if (clear_code >= (1<<MAX_LWZ_BITS)) {
  516.         return -2;
  517.       }
  519.       for (i = 0; i < clear_code; ++i) {
  520.         table[0][i] = 0;
  521.         table[1][i] = i;
  522.       }
  523.       for (; i < (1<<MAX_LWZ_BITS); ++i)
  524.         table[0][i] = table[1][i] = 0;
  525.       code_size = set_code_size+1;
  526.       max_code_size = 2*clear_code;
  527.       max_code = clear_code+2;
  528.       sp = stack;
  529.       do {
  530.         firstcode = oldcode = nextCode(fd, code_size);
  531.       } while (firstcode == clear_code);
  533.       return firstcode;
  534.     }
  535.     if (code == end_code) {
  536.       int             count;
  537.       unsigned char   buf[260];
  539.       if (ZeroDataBlock)
  540.         return -2;
  542.       while ((count = GetDataBlock(fd, buf)) > 0)
  543.         ;
  545.       if (count != 0) {
  546.         fprintf(stderr, "gif2png: missing EOD in data stream (common occurrence)n");
  547.       }
  548.       return -2;
  549.     }
  551.     incode = code;
  553.     if (code >= max_code) {
  554.       *sp++ = firstcode;
  555.       code = oldcode;
  556.     }
  558.     while (code >= clear_code) {
  559.       *sp++ = table[1][code];
  560.       if (code == table[0][code]) {
  561.         fprintf(stderr, "gif2png: circular table entry BIG ERRORn");
  562.         return(code);
  563.       }
  564.       if (((char *)sp - (char *)stack) >= sizeof(stack)) {
  565.         fprintf(stderr, "gif2png: circular table STACK OVERFLOW!n");
  566.         return(code);
  567.       }
  568.       code = table[0][code];
  569.     }
  571.     *sp++ = firstcode = table[1][code];
  573.     if ((code = max_code) <(1<<MAX_LWZ_BITS)) {
  574.       table[0][code] = oldcode;
  575.       table[1][code] = firstcode;
  576.       ++max_code;
  577.       if ((max_code >= max_code_size) &&
  578.           (max_code_size < (1<<MAX_LWZ_BITS))) {
  579.         max_code_size *= 2;
  580.         ++code_size;
  581.       }
  582.     }
  584.     oldcode = incode;
  586.     if (sp > stack)
  587.       return *--sp;
  588.   }
  589.   return code;
  590. }
  592. /* find the nearest line above that already has data in it */
  594. static byte *
  595. get_prev_line(int width, int height, int line)
  596. {
  597.   int prev_line;
  598.   byte *res;
  599. #ifdef TMPFILE
  600.   long filepos;
  601. #endif
  603.   prev_line=inv_interlace_line(height,line)-1;
  604.   while(interlace_line(height, prev_line)>=line)
  605.     prev_line--;
  607. #ifdef TMPFILE
  608.   filepos=ftell(tempfile);
  609. #endif
  611.   res=access_data(current, width*interlace_line(height, prev_line), width);
  613. #ifdef TMPFILE
  614.   fseek(tempfile, filepos, SEEK_SET);
  615. #endif
  617.   return res;
  618. }
  620. static int
  621. ReadImage(FILE *fd, int x_off, int y_off, int width, int height, int cmapSize,
  622.           GifColor cmap[MAXCMSIZE], int interlace)
  623. {
  624.   unsigned char *dp, c;
  625.   int           v;
  626.   int           xpos = 0, ypos = 0;
  627.   unsigned char *image;
  628.   int i;
  629.   unsigned long *count;
  631.   /*
  632.    **  Initialize the compression routines
  633.    */
  634.   if (! ReadOK(fd,&c,1)) {
  635.     fprintf(stderr, "gif2png: EOF / read error on image datan");
  636.     return(1);
  637.   }
  639.   initLWZ(c);
  641.   if (verbose > 1)
  642.     fprintf(stderr, "gif2png: reading %d by %d%s GIF imagen",
  643.           width, height, interlace ? " interlaced" : "" );
  645.   allocate_image();
  646.   /* since we know how large the image will be, we set the size in advance.
  647.      This saves a lot of realloc calls, which may require copying memory. */
  649.   set_size((long)width*height);
  651.   image=xalloc(width);
  653.   current->imagestruct->offset_x = x_off;
  654.   current->imagestruct->offset_y = y_off;
  655.   current->imagestruct->width    = width;
  656.   current->imagestruct->height   = height;
  657.   current->imagestruct->trans    = Gif89.transparent;
  658.   current->imagestruct->interlace= interlace;
  660.   memcpy(current->imagestruct->colors, cmap, sizeof(GifColor)*MAXCMSIZE);
  662.   count=current->imagestruct->color_count;
  664.   for(i=0;i<MAXCMSIZE;i++) {
  665.     count[i]=0;
  666.   }
  668.   for (ypos = 0; ypos < height; ypos++) {
  669.     dp=image;
  670.     for (xpos = 0; xpos < width; xpos++) {
  671.       if ((v = readLWZ(fd)) < 0 || v>=cmapSize) {
  672.         if(v>=cmapSize)
  673.           fprintf(stderr, "gif2png: reference to undefined colormap entryn");
  675.         if(xpos>0 || ypos>0) {
  676.           if(recover) {
  677.             if(!interlace) {
  678.               /* easy part, just fill the rest of the `screen' with color 0 */
  679.               memset(image+xpos,0, width-xpos);
  680.               store_block((char *)image,width);
  681.               ypos++;
  683.               memset(image, 0, width);
  684.               for( ; ypos < height ; ypos++)
  685.                 store_block((char *)image,width);
  686.             } else {
  687.               /* interlacing recovery is a bit tricky */
  689.               if(xpos>0) {
  690.                 if((inv_interlace_line(height, ypos)&7)==0) {
  691.                   /* in 1st pass */
  692.                   memset(image+xpos, 0, width-xpos);
  693.                 } else {
  694.                   /* pass >=2 */
  695.                   memcpy(image+xpos, get_prev_line(width, height, ypos)+xpos,
  696.                          width-xpos);
  697.                 }
  698.                 store_block((char *)image,width);
  699.                 ypos++;
  700.               }
  702.               /* fill rest of 1st pass with color 0 */
  703.               memset(image, 0, width);
  704.               for( ; (inv_interlace_line(height, ypos)&7)==0 ; ypos++)
  705.                 store_block((char *)image,width);
  707.               /* all other passes, copy from line above */
  708.               for( ; ypos<height ; ypos++) {
  709.                 memcpy(image, get_prev_line(width, height, ypos), width);
  710.                 store_block((char *)image,width);
  711.               }
  712.             }
  713.             goto fini;
  714.           } else {
  715.             check_recover(TRUE);
  716.             return(1);
  717.           }
  718.         } else {
  719.           return(1);
  720.         }
  721.       }
  723.       count[v]++;
  725.       *dp++=v;
  726.     }
  727.     store_block((char *)image,width);
  728.   }
  729.  fini:
  731.   while(readLWZ(fd)>=0)
  732.     continue;
  734.   free(image);
  736.   fix_current();
  738.   /*
  739.    * reset GIF89 extensions after image
  740.    */
  742.   Gif89.transparent = -1;
  743.   Gif89.delayTime = -1;
  744.   Gif89.inputFlag = -1;
  745.   Gif89.disposal = 0;
  747.   return(0);
  748. }
  750. /* gifread.c ends here */