home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / modules / libimg / src / gif.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  48.8 KB  |  1,585 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* -*- Mode: C; tab-width: 4 -*-
  20.  *   gif.c --- GIF87 & GIF89 Image decoder
  21.  */
  22.  
  23.  
  24.  
  25. /* 
  26. The Graphics Interchange Format(c) is the copyright property of CompuServe
  27. Incorporated. Only CompuServe Incorporated is authorized to define, redefine,
  28. enhance, alter, modify or change in any way the definition of the format.
  29.  
  30. CompuServe Incorporated hereby grants a limited, non-exclusive, royalty-free
  31. license for the use of the Graphics Interchange Format(sm) in computer
  32. software; computer software utilizing GIF(sm) must acknowledge ownership of the
  33. Graphics Interchange Format and its Service Mark by CompuServe Incorporated, in
  34. User and Technical Documentation. Computer software utilizing GIF, which is
  35. distributed or may be distributed without User or Technical Documentation must
  36. display to the screen or printer a message acknowledging ownership of the
  37. Graphics Interchange Format and the Service Mark by CompuServe Incorporated; in
  38. this case, the acknowledgement may be displayed in an opening screen or leading
  39. banner, or a closing screen or trailing banner. A message such as the following
  40. may be used:
  41.  
  42.       "The Graphics Interchange Format(c) is the Copyright property of
  43.       CompuServe Incorporated. GIF(sm) is a Service Mark property of
  44.       CompuServe Incorporated."
  45.  
  46. For further information, please contact :
  47.  
  48.       CompuServe Incorporated
  49.       Graphics Technology Department
  50.       5000 Arlington Center Boulevard
  51.       Columbus, Ohio  43220
  52.       U. S. A.
  53.  
  54. CompuServe Incorporated maintains a mailing list with all those individuals and
  55. organizations who wish to receive copies of this document when it is corrected
  56. or revised. This service is offered free of charge; please provide us with your
  57. mailing address.
  58.  
  59. */
  60.  
  61. /*
  62. #include "xp.h"
  63. */
  64.  
  65. #include "if.h"
  66. #include "il.h"
  67. #include "xp_mem.h"
  68.  
  69. #include "merrors.h"
  70. #include "xp_core.h"
  71.  
  72. #define HOWMANY(x, r)     (((x) + ((r) - 1)) / (r))
  73. #define ROUNDUP(x, r)     (HOWMANY(x, r) * (r))
  74.  
  75.  
  76. #ifndef MAX
  77. #    define MAX(x, y)    (((x) > (y)) ? (x) : (y))
  78. #endif
  79.  
  80. extern int MK_OUT_OF_MEMORY;
  81.  
  82. #ifdef PROFILE
  83. #    pragma profile on
  84. #endif
  85.  
  86. /* List of possible parsing states */
  87. typedef enum {
  88.     gif_gather,
  89.     gif_init,                    /*1*/
  90.     gif_type,
  91.     gif_version,
  92.     gif_global_header,
  93.     gif_global_colormap,
  94.     gif_image_start,            /*6*/
  95.     gif_image_header,
  96.     gif_image_colormap,
  97.     gif_image_body,
  98.     gif_lzw_start,
  99.     gif_lzw,                    /*11*/
  100.     gif_sub_block,
  101.     gif_extension,
  102.     gif_control_extension,
  103.     gif_consume_block,
  104.     gif_skip_block,
  105.     gif_done,                    /*17*/
  106.     gif_oom,
  107.     gif_error,
  108.     gif_comment_extension,
  109.     gif_application_extension,
  110.     gif_netscape_extension_block,
  111.     gif_consume_netscape_extension,
  112.     gif_consume_comment,
  113.     gif_delay,
  114.     gif_wait_for_buffer_full
  115. } gstate;
  116.  
  117. /* "Disposal" method indicates how the image should be handled in the
  118.    framebuffer before the subsequent image is displayed. */
  119. typedef enum 
  120. {
  121.     DISPOSE_NOT_SPECIFIED      = 0,
  122.     DISPOSE_KEEP               = 1, /* Leave it in the framebuffer */
  123.     DISPOSE_OVERWRITE_BGCOLOR  = 2, /* Overwrite with background color */
  124.     DISPOSE_OVERWRITE_PREVIOUS = 4  /* Save-under */
  125. } gdispose;
  126.  
  127. #define MAX_HOLD 768        /* for now must be big enough for a cmap */
  128.  
  129. #define    MAX_LZW_BITS          12
  130. #define MAX_BITS            4097 /* 2^MAX_LZW_BITS+1 */
  131. #define MINIMUM_DELAY_TIME    10
  132.  
  133. /* A GIF decoder */
  134. typedef struct
  135. gif_struct {
  136.     /* Parsing state machine */
  137.     gstate state;               /* Curent decoder master state */
  138.     uint8 *hold;                /* Accumulation buffer */
  139.     int32 hold_size;            /* Capacity, in bytes, of accumulation buffer */
  140.     uint8 *gather_head;         /* Next byte to read in accumulation buffer */
  141.     int32 gather_request_size;  /* Number of bytes to accumulate */
  142.     int32 gathered;             /* bytes accumulated so far*/
  143.     gstate post_gather_state;   /* State after requested bytes accumulated */
  144.     int32 requested_buffer_fullness; /* For netscape application extension */
  145.  
  146.     /* LZW decoder state machine */
  147.     uint8 *stack;               /* Base of decoder stack */
  148.     uint8 *stackp;              /* Current stack pointer */
  149.     uint16 *prefix;
  150.     uint8 *suffix;
  151.     int datasize;
  152.     int codesize;
  153.     int codemask;
  154.     int clear_code;             /* Codeword used to trigger dictionary reset */
  155.     int avail;                  /* Index of next available slot in dictionary */
  156.     int oldcode;
  157.     uint8 firstchar;
  158.     int count;                  /* Remaining # bytes in sub-block */
  159.     int bits;                   /* Number of unread bits in "datum" */
  160.     int32 datum;                /* 32-bit input buffer */
  161.  
  162.     /* Output state machine */
  163.     int ipass;                  /* Interlace pass; Ranges 1-4 if interlaced. */
  164.     uint rows_remaining;        /* Rows remaining to be output */
  165.     uint irow;                  /* Current output row, starting at zero */
  166.     uint8 *rgbrow;              /* Temporary storage for dithering/mapping */
  167.     uint8 *rowbuf;              /* Single scanline temporary buffer */
  168.     uint8 *rowend;              /* Pointer to end of rowbuf */
  169.     uint8 *rowp;                /* Current output pointer */
  170.  
  171.     /* Image parameters */
  172.     uint x_offset, y_offset;    /* With respect to "screen" origin */
  173.     uint height, width;
  174.     uint last_x_offset, last_y_offset; /* With respect to "screen" origin */
  175.     uint last_height, last_width;
  176.     int interlaced;             /* TRUE, if scanlines arrive interlaced order */
  177.     int tpixel;                 /* Index of transparent pixel */
  178.     int is_transparent;         /* TRUE, if tpixel is valid */
  179.     int control_extension;      /* TRUE, if image control extension present */
  180.     int is_local_colormap_defined;
  181.     gdispose disposal_method;   /* Restore to background, leave in place, etc.*/
  182.     gdispose last_disposal_method;
  183.     IL_RGB *local_colormap;     /* Per-image colormap */
  184.     int local_colormap_size;    /* Size of local colormap array. */
  185.     int progressive_display;    /* If TRUE, do Haeberli interlace hack */
  186.     uint32 delay_time;          /* Display time, in milliseconds,
  187.                                    for this image in a multi-image GIF */
  188.  
  189.     /* Global (multi-image) state */
  190.     int screen_bgcolor;         /* Logical screen background color */
  191.     int version;                /* Either 89 for GIF89 or 87 for GIF87 */
  192.     uint screen_width;          /* Logical screen width & height */
  193.     uint screen_height;
  194.     IL_RGB *global_colormap;    /* Default colormap if local not supplied  */
  195.     int global_colormap_size;   /* Size of global colormap array. */
  196.     int images_decoded;         /* Counts images for multi-part GIFs */
  197.     il_container *ic;           /* Back pointer to requesting image_container */
  198.     void *delay_timeout;        /* Used to delay after displaying picture */
  199.     int destroy_pending;        /* Stream has ended */
  200. } gif_struct;
  201.  
  202. /* Gather n characters from the input stream and then enter state s. */
  203. #define GETN(n,s)                                                             \
  204. do {gs->state=gif_gather; gs->gather_request_size = (n);                      \
  205.     gs->post_gather_state = s;} while (0)
  206.  
  207. /* Get a 16-bit value stored in little-endian format */
  208. #define GETINT16(p)   ((p)[1]<<8|(p)[0])
  209.  
  210. /* Get a 32-bit value stored in little-endian format */
  211. #define GETINT32(p)   (((p)[3]<<24) | ((p)[2]<<16) | ((p)[1]<<8) | ((p)[0]))
  212.  
  213.  
  214.  
  215.  
  216. /* Send the data to the display front-end. */
  217. static void
  218. output_row(gif_struct *gs)
  219. {
  220.     int width, drow_start, drow_end;
  221.     
  222.     drow_start = drow_end = gs->irow;
  223.  
  224.     /*
  225.      * Haeberli-inspired hack for interlaced GIFs: Replicate lines while
  226.      * displaying to diminish the "venetian-blind" effect as the image is
  227.      * loaded. Adjust pixel vertical positions to avoid the appearance of the
  228.      * image crawling up the screen as successive passes are drawn.
  229.      */
  230.     if (gs->progressive_display && gs->interlaced && (gs->ipass < 4))
  231.     {
  232.         uint row_dup, row_shift;
  233.  
  234.         switch (gs->ipass) {
  235.         case 1:
  236.             row_dup = 7;
  237.             row_shift = 3;
  238.             break;
  239.         case 2:
  240.             row_dup = 3;
  241.             row_shift = 1;
  242.             break;
  243.         case 3:            
  244.             row_dup = 1;
  245.             row_shift = 0;
  246.             break;
  247.         default:
  248.             XP_ABORT(("Illegal interlace pass"));
  249.             break;
  250.         }
  251.  
  252.         drow_start -= row_shift;
  253.         drow_end = drow_start + row_dup;
  254.  
  255.         /* Extend if bottom edge isn't covered because of the shift upward. */
  256.         if (((gs->height - 1) - drow_end) <= row_shift)
  257.             drow_end = gs->height - 1;
  258.  
  259.         /* Clamp first and last rows to upper and lower edge of image. */
  260.         if (drow_start < 0)
  261.             drow_start = 0; 
  262.         if ((uint)drow_end >= gs->height)
  263.             drow_end = gs->height - 1;
  264.     }
  265.  
  266.     /* Check for scanline below edge of logical screen */
  267.     if ((gs->y_offset + gs->irow) < gs->screen_height) {
  268.         il_draw_mode draw_mode;
  269.  
  270.         if (gs->images_decoded >= 1)
  271.             draw_mode = ilOverlay;
  272.         else
  273.             draw_mode = ilErase;
  274.  
  275.         /* Clip if right edge of image exceeds limits */
  276.         if ((gs->x_offset + gs->width) > gs->screen_width)
  277.             width = gs->screen_width - gs->x_offset;
  278.         else
  279.             width = gs->width;
  280.  
  281.         if (width > 0)
  282.             il_emit_row(gs->ic, gs->rowbuf, gs->rgbrow, gs->x_offset, width,
  283.                         gs->y_offset + drow_start, drow_end - drow_start + 1,
  284.                         draw_mode, gs->ipass);
  285.     }
  286.  
  287.     gs->rowp = gs->rowbuf;
  288.  
  289.     if(!gs->interlaced)
  290.     {
  291.         gs->irow++;
  292.     }
  293.     else
  294.     {
  295.         do{
  296.             switch(gs->ipass)
  297.             {
  298.                 case 1:
  299.                     gs->irow += 8;
  300.                     if(gs->irow >= gs->height)
  301.                     {
  302.                         gs->ipass++;
  303.                         gs->irow = 4;
  304.                     }
  305.                     break;
  306.  
  307.                 case 2:
  308.                     gs->irow += 8;
  309.                     if(gs->irow >= gs->height)
  310.                     {
  311.                         gs->ipass++;
  312.                         gs->irow = 2;
  313.                     }
  314.                     break;
  315.  
  316.                 case 3:
  317.                     gs->irow += 4;
  318.                     if(gs->irow >= gs->height)
  319.                     {
  320.                         gs->ipass++;
  321.                         gs->irow = 1;
  322.                     }
  323.                     break;
  324.  
  325.                 case 4:
  326.                     gs->irow += 2;
  327.                     if(gs->irow >= gs->height){
  328.                         gs->ipass++;
  329.                         gs->irow = 0;
  330.                     }
  331.                     break;
  332.  
  333.                 default:
  334.                     XP_ASSERT(0);
  335.             }
  336.         }while(gs->irow > gs->height - 1);
  337.     }
  338. }
  339.  
  340. /* Perform Lempel-Ziv-Welch decoding */
  341. static int 
  342. do_lzw(gif_struct *gs, const uint8 *q)
  343. {
  344.     int code;
  345.     int incode;
  346.     const uint8 *ch;
  347.  
  348.     /* Copy all the decoder state variables into locals so the compiler
  349.      * won't worry about them being aliased.  The locals will be homed
  350.      * back into the GIF decoder structure when we exit.
  351.      */
  352.     int avail       = gs->avail;
  353.     int bits        = gs->bits;
  354.     int codesize    = gs->codesize;
  355.     int codemask    = gs->codemask;
  356.     int count       = gs->count;
  357.     int oldcode     = gs->oldcode;
  358.     int clear_code  = gs->clear_code;
  359.     uint8 firstchar = gs->firstchar;
  360.     int32 datum     = gs->datum;
  361.     uint16 *prefix  = gs->prefix;
  362.     uint8 *stackp   = gs->stackp;
  363.     uint8 *suffix   = gs->suffix;
  364.     uint8 *stack    = gs->stack;
  365.     uint8 *rowp     = gs->rowp;
  366.     uint8 *rowend   = gs->rowend;
  367.     uint rows_remaining = gs->rows_remaining;
  368.  
  369.  
  370. #define OUTPUT_ROW(gs)                                                          \
  371.     {                                                                          \
  372.         output_row(gs);                                                          \
  373.         rows_remaining--;                                                      \
  374.         rowp = gs->rowp;                                                      \
  375.         if (!rows_remaining)                                                  \
  376.             goto END;                                                          \
  377.     }
  378.  
  379.     for (ch=q; count-- > 0; ch++) 
  380.     {
  381.         /* Feed the next byte into the decoder's 32-bit input buffer. */
  382.         datum += ((int32) *ch) << bits;
  383.         bits += 8;
  384.         
  385.         /* Check for underflow of decoder's 32-bit input buffer. */
  386.         while (bits >= codesize) 
  387.         {
  388.             /* Get the leading variable-length symbol from the data stream */
  389.             code = datum & codemask;
  390.             datum >>= codesize;
  391.             bits -= codesize;
  392.  
  393.             /* Reset the dictionary to its original state, if requested */
  394.             if (code == clear_code) 
  395.             {
  396.                 codesize = gs->datasize + 1;
  397.                 codemask = (1 << codesize) - 1;
  398.                 avail = clear_code + 2;
  399.                 oldcode = -1;
  400.                 continue;
  401.             }
  402.  
  403.             /* Check for explicit end-of-stream code */
  404.             if (code == (clear_code + 1))
  405.                     return 0;
  406.  
  407.             if (oldcode == -1) 
  408.             {
  409.                 *rowp++ = suffix[code];
  410.                 if (rowp == rowend) {
  411.                     OUTPUT_ROW(gs);
  412.                 }
  413.                 
  414.                 firstchar = oldcode = code;
  415.                 continue;
  416.             }
  417.  
  418.             /* Check for a code not defined in the dictionary yet. */
  419.             if (code > avail) 
  420.             {
  421.                 ILTRACE(3,("il:gif: code too large %d %d", code, avail));
  422.                 return -1;
  423.             }
  424.  
  425.             incode = code;
  426.             if (code == avail) 
  427.             {       
  428.                 /* the first code is always < avail */
  429.                 *stackp++ = firstchar;
  430.                 code = oldcode;
  431.             }
  432.  
  433.  
  434.             while(code > clear_code)
  435.             {        
  436.                 if(code == prefix[code])
  437.                     return -1;
  438.  
  439.                 *stackp++ = suffix[code];
  440.                 code = prefix[code];
  441.                 
  442.             }
  443.  
  444.             /* Define a new codeword in the dictionary. */
  445.             *stackp++ = firstchar = suffix[code];
  446.             prefix[avail] = oldcode;
  447.             suffix[avail] = firstchar;
  448.             avail++;
  449.             if(avail >= MAX_BITS)
  450.                 return -1;
  451.  
  452.             /* If we've used up all the codewords of a given length
  453.              * increase the length of codewords by one bit, but don't
  454.              * exceed the specified maximum codeword size of 12 bits.
  455.              */
  456.             if (((avail & codemask) == 0) && (avail < 4096)) 
  457.             {
  458.                 codesize++;
  459.                 codemask += avail;
  460.             }
  461.             oldcode = incode;
  462.             
  463.             /* Copy the decoded data out to the scanline buffer. */
  464.             do {
  465.                 *rowp++ = *--stackp;
  466.                 if (rowp == rowend) {
  467.                     OUTPUT_ROW(gs);
  468.                 }
  469.             } while (stackp > stack);
  470.         }
  471.     }
  472.  
  473.   END:
  474.  
  475.     /* Home the local copies of the GIF decoder state variables */
  476.     gs->avail = avail;
  477.     gs->bits = bits;
  478.     gs->codesize = codesize;
  479.     gs->codemask = codemask;
  480.     gs->count = count;
  481.     gs->oldcode = oldcode;
  482.     gs->firstchar = firstchar;
  483.     gs->datum = datum;
  484.     gs->stackp = stackp;
  485.     gs->rowp = rowp;
  486.     gs->rows_remaining = rows_remaining;
  487.  
  488.     return 0;
  489. }
  490.  
  491. /*
  492.  * setup an ic for gif decoding
  493.  */
  494. int
  495. il_gif_init(il_container *ic)
  496. {
  497.     gif_struct *gs;
  498.     NI_ColorSpace *src_color_space = ic->src_header->color_space;
  499.  
  500.     gs = XP_NEW_ZAP(gif_struct);
  501.     if (gs) 
  502.     {
  503.         ic->ds = gs;
  504.         gs->state = gif_init;
  505.         gs->post_gather_state = gif_error;
  506.         gs->ic = ic;
  507.     }
  508.  
  509.     /* Initialize the container's source image header. */
  510.     src_color_space->type = NI_PseudoColor;
  511.     src_color_space->pixmap_depth = 8;
  512.     src_color_space->bit_alloc.index_depth = 8;
  513.  
  514.     return gs != 0;
  515. }
  516.  
  517. static int
  518. il_gif_init_transparency(il_container *ic, int index)
  519. {
  520.     IL_IRGB *src_trans_pixel = ic->src_header->transparent_pixel;
  521.     IL_IRGB *img_trans_pixel;
  522.     
  523.     if (!src_trans_pixel) {
  524.         src_trans_pixel = XP_NEW_ZAP(IL_IRGB);
  525.         if (!src_trans_pixel)
  526.             return FALSE;
  527.         ic->src_header->transparent_pixel = src_trans_pixel;
  528.  
  529.         /* Initialize the destination image's transparent pixel. */
  530.         il_init_image_transparent_pixel(ic);
  531.  
  532.         /* Set the source image's transparent pixel color to be the preferred
  533.            transparency color of the destination image. */
  534.         img_trans_pixel = ic->image->header.transparent_pixel;
  535.         src_trans_pixel->red = img_trans_pixel->red;
  536.         src_trans_pixel->green = img_trans_pixel->green;
  537.         src_trans_pixel->blue = img_trans_pixel->blue;
  538.     }
  539.         
  540.     /* Set the source image's transparent pixel index.  Do this even if the source
  541.        image's transparent pixel has previously been set, since the index can vary
  542.        from frame to frame in an animated gif. */
  543.     src_trans_pixel->index = index;
  544.  
  545.     return TRUE;
  546. }
  547.  
  548.  
  549. static void
  550. il_gif_destroy_transparency(il_container *ic)
  551. {
  552.     NI_PixmapHeader *src_header = ic->src_header;
  553.     
  554.     if (src_header->transparent_pixel) {
  555.         /* Destroy the source image's transparent pixel. */
  556.         XP_FREE(src_header->transparent_pixel);
  557.         src_header->transparent_pixel = NULL;
  558.  
  559.         /* Destroy the destination image's transparent pixel. */
  560.         il_destroy_image_transparent_pixel(ic);
  561.     }
  562. }
  563.  
  564.  
  565. int
  566. il_gif_compute_percentage_complete(int row, il_container *ic)
  567. {
  568.     uint percent_height;
  569.     int percent_done = 0;
  570.     
  571.     percent_height = (uint)(row * (uint32)100 / ic->image->header.height);
  572.     switch(ic->pass) {
  573.     case 0: percent_done = percent_height; /* non-interlaced GIF */
  574.         break;
  575.     case 1: percent_done =      percent_height / 8;
  576.         break;
  577.     case 2: percent_done = 12 + percent_height / 8;
  578.         break;
  579.     case 3: percent_done = 25 + percent_height / 4;
  580.         break;
  581.     case 4: percent_done = 50 + percent_height / 2;
  582.         break;
  583.     default:
  584.         XP_ABORT(("Illegal interlace pass"));
  585.         break;
  586.     }
  587.  
  588.     return percent_done;
  589. }
  590.  
  591. /* Maximum # of bytes to read ahead while waiting for delay_time to expire.
  592.    We limit this number to remain within WIN16 malloc limitations */
  593.  
  594. #define MAX_READ_AHEAD  (60000L)
  595.  
  596. unsigned int
  597. il_gif_write_ready(il_container *ic)
  598. {
  599.     gif_struct *gs = (gif_struct *)ic->ds;
  600.     int32 max;
  601.     
  602.     if (!gs)
  603.         return 1;               /* Let imglib generic code decide */
  604.  
  605.     max = MAX(MAX_READ_AHEAD, gs->requested_buffer_fullness);
  606.     if (gs->gathered < max)
  607.         return 1;               /* Let imglib generic code decide */
  608.     else
  609.         return 0;               /* No more data until timeout expires */
  610. }
  611.  
  612.  
  613. static void
  614. process_buffered_gif_input_data(gif_struct* gs)
  615. {
  616.     gstate state;
  617.     il_container *ic = gs->ic;
  618.  
  619.     /* Force any data we've buffered up to be processed. */
  620.     il_gif_write(ic, (uint8 *) "", 0);
  621.  
  622.     /* The stream has already finished delivering data and the stream
  623.        completion routine has been called sometime in the past. Now that
  624.        we're actually done handling all of that data, call the stream
  625.        completion routine again, but this time for real. */
  626.     state = gs->state;
  627.     if (gs->destroy_pending &&
  628.         ((state == gif_done) || (state == gif_error) || (state == gif_oom))) {
  629.         il_gif_abort(ic);
  630.         il_image_complete(ic);
  631.     }
  632. }
  633.  
  634. static void
  635. gif_delay_time_callback(void *closure)
  636. {
  637.     gif_struct *gs = (gif_struct *)closure;
  638.  
  639.     XP_ASSERT(gs->state == gif_delay);
  640.  
  641.     gs->delay_timeout = NULL;
  642.  
  643.     if (gs->ic->state == IC_ABORT_PENDING)
  644.         return;                                        
  645.  
  646.     gs->delay_time = 0;         /* Reset for next image */
  647.  
  648.     if (gs->state == gif_delay) {
  649.         GETN(1, gif_image_start);
  650.         process_buffered_gif_input_data(gs);
  651.     }
  652. }
  653.  
  654. /*
  655.  * For the first images in the sequence clear the logical
  656.  * screen to the background color, unless the first image
  657.  * completely covers the logical screen, in which case
  658.  * it's unnecessary.  XXX - This can be optimized.
  659.  */
  660.  
  661. static int
  662. gif_clear_screen(gif_struct *gs)
  663. {
  664.     uint erase_width, erase_height, erase_x_offset, erase_y_offset;
  665.     XP_Bool erase;
  666.     il_container *ic = gs->ic;
  667.  
  668.     erase = FALSE;
  669.     if (gs->images_decoded == 0)
  670.     {
  671.         if ((gs->width  != gs->screen_width) ||
  672.             (gs->height != gs->screen_height))
  673.         {
  674.             erase = TRUE;
  675.             erase_width  = gs->screen_width;
  676.             erase_height = gs->screen_height;
  677.             erase_x_offset = erase_y_offset = 0;
  678.         }
  679.     }
  680.     else
  681.     {
  682.         if (gs->last_disposal_method == DISPOSE_OVERWRITE_BGCOLOR)
  683.         {
  684.             erase = TRUE;
  685.             erase_width    = gs->last_width;
  686.             erase_height   = gs->last_height;
  687.             erase_x_offset = gs->last_x_offset;
  688.             erase_y_offset = gs->last_y_offset;
  689.         }
  690.     }
  691.  
  692.     gs->last_disposal_method = gs->disposal_method;
  693.     gs->last_width = gs->width;
  694.     gs->last_height = gs->height;
  695.     gs->last_x_offset = gs->x_offset;
  696.     gs->last_y_offset = gs->y_offset;
  697.             
  698.     if (erase)
  699.     {
  700.         uint i;
  701.         int src_trans_pixel_index;
  702.         uint8 *rowbuf = gs->rowbuf;
  703.         NI_PixmapHeader *src_header = ic->src_header;
  704.         IL_IRGB *saved_src_trans_pixel;
  705.  
  706.         /* Catch images that fall outside the logical screen. */
  707.         if ((erase_x_offset + erase_width) > gs->screen_width)
  708.             erase_width = gs->screen_width - erase_x_offset;
  709.  
  710.         /* We have to temporarily pretend the image is transparent
  711.            so we can clear using the context's background color. */
  712.         saved_src_trans_pixel = src_header->transparent_pixel;
  713.         src_header->transparent_pixel = NULL;
  714.  
  715.         /* Pick an index for the source image's temporary transparent pixel.
  716.            The actual choice is immaterial since it will only be used for
  717.            the clear screen operation. */
  718.         src_trans_pixel_index = 0;
  719.         if (!il_gif_init_transparency(ic, src_trans_pixel_index))
  720.             return MK_OUT_OF_MEMORY;
  721.  
  722.         /* Now fill in the row buffer. */
  723.         for (i = 0; i < erase_width; i++)
  724.             rowbuf[i] = src_trans_pixel_index;
  725.                     
  726.         /* Note: We deliberately lie about the interlace
  727.            pass number so that calls to il_flush_image_data()
  728.            are done using a timer. */
  729.         if (erase_width > 0)
  730.             il_emit_row(gs->ic, gs->rowbuf, gs->rgbrow, erase_x_offset,
  731.                         erase_width, erase_y_offset, erase_height,
  732.                         ilErase, 2);
  733.  
  734.         /* Reset the source image's transparent pixel to its former state. */
  735.         il_gif_destroy_transparency(ic);
  736.         src_header->transparent_pixel = saved_src_trans_pixel;
  737.     }
  738.     return 0;
  739. }
  740.  
  741.  
  742. /*
  743.  * process data arriving from the stream for the gif decoder
  744.  */
  745.  
  746. int
  747. il_gif_write(il_container *ic, const uint8 *buf, int32 len)
  748. {
  749.     int status;
  750.     gif_struct *gs = (gif_struct *)ic->ds;
  751.     NI_PixmapHeader *src_header = ic->src_header;
  752.     NI_ColorMap *cmap = &src_header->color_space->cmap;
  753.     const uint8 *q, *p=buf,*ep=buf+len;
  754.  
  755.     /* If this assert fires, chances are the netlib flubbed and
  756.        continued to send data after the image stream was closed. */
  757.     XP_ASSERT(gs);
  758.     if (!gs) {
  759. #ifdef DEBUG
  760.         XP_TRACE(("Netlib Error - imagelib image stream is closed\n"));
  761. #endif
  762.         return MK_IMAGE_LOSSAGE;
  763.     }
  764.  
  765.     /* If this assert fires, some upstream data provider ignored the
  766.        zero return value from il_gif_write_ready() which says not to
  767.        send any more data to this stream until the delay timeout fires. */
  768.     XP_ASSERT ((len == 0) || (gs->gathered < MAX_READ_AHEAD));
  769.     if (!((len == 0) || (gs->gathered < MAX_READ_AHEAD)))
  770.         return MK_INTERRUPTED;
  771.     
  772.     q = NULL;                   /* Initialize to shut up gcc warnings */
  773.     
  774.     while (p <= ep)
  775.     {
  776.         ILTRACE(9,("il:gif: state %d len %d buf %u p %u q %u ep %u",
  777.                    gs->state,len,buf,p,q,ep));
  778.         switch(gs->state)
  779.         {
  780.         case gif_lzw:
  781.             if (do_lzw(gs, q) < 0)
  782.             {
  783.                 gs->state=gif_error;
  784.                 break;
  785.             }            
  786.             GETN(1,gif_sub_block);
  787.             break;
  788.         
  789.         case gif_lzw_start:
  790.         {
  791.             int i, status;
  792.  
  793.             cmap->map = gs->is_local_colormap_defined ?
  794.                 gs->local_colormap : gs->global_colormap;
  795.  
  796.             XP_ASSERT(cmap->map);
  797.             if (!cmap->map)
  798.                 return MK_IMAGE_LOSSAGE;
  799.  
  800.             /* Now we know how many colors are in our colormap. */
  801.             if (gs->is_local_colormap_defined || (gs->images_decoded == 0))
  802.                 il_setup_color_space_converter(ic); /* XXXM12N Should check
  803.                                                        return code. */
  804.  
  805.             status = gif_clear_screen(gs);
  806.             if (status < 0)
  807.                 return status;
  808.  
  809.             /* Initialize LZW parser/decoder */
  810.             gs->datasize = *q;
  811.             if(gs->datasize > MAX_LZW_BITS)
  812.             {
  813.                 gs->state=gif_error;
  814.                 break;
  815.             }
  816.  
  817.             gs->clear_code = 1 << gs->datasize;
  818.             gs->avail = gs->clear_code + 2;
  819.             gs->oldcode = -1;
  820.             gs->codesize = gs->datasize + 1;
  821.             gs->codemask = (1 << gs->codesize) - 1;
  822.  
  823.             gs->datum = gs->bits = 0;
  824.  
  825.             if (!gs->prefix)        
  826.                 gs->prefix = (uint16 *)XP_CALLOC(sizeof(uint16), MAX_BITS);
  827.             if (!gs->suffix)
  828.                 gs->suffix = ( uint8 *)XP_CALLOC(sizeof(uint8),  MAX_BITS);
  829.             if (!gs->stack)
  830.                 gs->stack  = ( uint8 *)XP_CALLOC(sizeof(uint8),  MAX_BITS);
  831.                     
  832.             if( !gs->prefix || !gs->suffix || !gs->stack)
  833.             {
  834.                 /* complete from abort will free prefix & suffix */
  835.                 ILTRACE(0,("il:gif: MEM stack"));
  836.                 gs->state=gif_oom;
  837.                 break;
  838.             }
  839.  
  840.             if(gs->clear_code >= MAX_BITS)
  841.             {
  842.                 gs->state=gif_error;
  843.                 break;
  844.             }
  845.  
  846.             /* init the tables */
  847.             for (i=0; i < gs->clear_code; i++) 
  848.                 gs->suffix[i] = i;
  849.  
  850.             gs->stackp = gs->stack;
  851.  
  852.             GETN(1,gif_sub_block);
  853.         }
  854.         break;
  855.  
  856.         /* We're positioned at the very start of the file. */
  857.         case gif_init:
  858.         {
  859.             GETN(3,gif_type);
  860.             break;
  861.         }
  862.  
  863.         /* All GIF files begin with "GIF87a" or "GIF89a" */
  864.         case gif_type:
  865.         {
  866.             if (strncmp((char*)q,"GIF",3))
  867.             {
  868.                 ILTRACE(2,("il:gif: not a GIF file"));
  869.                 gs->state=gif_error;
  870.                 break;
  871.             }
  872.             GETN(3,gif_version);
  873.         }
  874.         break;
  875.  
  876.         case gif_version:
  877.         {
  878.             if(!strncmp((char*)q,"89a",3))
  879.             {
  880.                 gs->version=89;
  881.             }
  882.             else
  883.             {
  884.                 if(!strncmp((char*)q,"87a",3))
  885.                 {
  886.                     gs->version=87;
  887.                 }
  888.                 else
  889.                 {
  890.                     ILTRACE(2,("il:gif: unrecognized GIF version number"));
  891.                     gs->state=gif_error;
  892.                     break;
  893.                 }
  894.             }
  895.             ILTRACE(2,("il:gif: %d gif", gs->version));
  896.             GETN(7,gif_global_header);
  897.         }
  898.         break;
  899.  
  900.         case gif_global_header:
  901.         {
  902.             /* This is the height and width of the "screen" or
  903.              * frame into which images are rendered.  The
  904.              * individual images can be smaller than the
  905.              * screen size and located with an origin anywhere
  906.              * within the screen.
  907.              */
  908.                     
  909.             gs->screen_width = GETINT16(q);    
  910.             gs->screen_height = GETINT16(q+2);
  911.  
  912.             gs->screen_bgcolor = q[5];
  913.  
  914.             gs->global_colormap_size = 2<<(q[4]&0x07);
  915.  
  916.             /* A -ve value for cmap->num_colors indicates that the colors may
  917.                be non-unique.*/
  918.             cmap->num_colors = -gs->global_colormap_size;
  919.             cmap->map = NULL;
  920.  
  921.             if(q[6])
  922.             {
  923.                 /* should assert gif89 */
  924.                 if(q[6] != 49)
  925.                 {
  926. #ifdef DEBUG
  927.                     float aspect = (float)((q[6] + 15) / 64.0);
  928. #endif
  929.                     ILTRACE(2, ("il:gif: %f aspect ratio", aspect));
  930.                 }
  931.             }
  932.  
  933.             if( q[4] & 0x80 ) /* global map */
  934.             {
  935.                 GETN(gs->global_colormap_size*3, gif_global_colormap);
  936.             }
  937.             else
  938.             {
  939.                 GETN(1, gif_image_start);
  940.             }
  941.         }
  942.         break;
  943.  
  944.         case gif_global_colormap:
  945.         {
  946.             IL_RGB* map;
  947.             int i;
  948.  
  949.             if(!(map = (IL_RGB*)XP_CALLOC(gs->global_colormap_size,
  950.                                           sizeof(IL_RGB))))
  951.             {
  952.                 ILTRACE(0,("il:gif: MEM map"));
  953.                 gs->state=gif_oom;
  954.                 break;
  955.             }
  956.                     
  957.             il_reset_palette(ic);
  958.             gs->global_colormap = map;
  959.  
  960. #ifndef M12N                    /* Fix me. */
  961. #ifdef XP_MAC
  962.             im->hasUniqueColormap = 1;
  963. #endif
  964. #endif /* M12N */
  965.             for (i=0; i < gs->global_colormap_size; i++, map++) 
  966.             {
  967.                 map->red = *q++;
  968.                 map->green = *q++;
  969.                 map->blue = *q++;
  970.             }
  971.  
  972.             GETN(1,gif_image_start);
  973.         }
  974.         break;
  975.  
  976.         case gif_image_start:
  977.         {
  978.             if(*q==';') /* terminator */
  979.             {
  980.                 gs->state = gif_done;
  981.                 break;
  982.             }
  983.  
  984.             if(*q=='!') /* extension */
  985.             {
  986.                 GETN(2,gif_extension);
  987.                 break;
  988.             }
  989.                         
  990.             if(*q!=',') /* invalid start character */
  991.             {
  992.                 ILTRACE(2,("il:gif: bogus start character 0x%02x",
  993.                            (int)*q));
  994.                 gs->state=gif_error;
  995.                 break;
  996.             }
  997.             else
  998.             {
  999.                 /* If this is a multi-part GIF, flush the last image */
  1000.                 if (gs->images_decoded) {
  1001.                     ic->multi++;    /* Avoid progressive display */
  1002.                 }
  1003.             
  1004.                 GETN(9, gif_image_header);
  1005.             }
  1006.         }
  1007.         break;
  1008.  
  1009.         case gif_extension:
  1010.         {
  1011.             int len = gs->count = q[1];
  1012.             gstate es = gif_skip_block;
  1013.  
  1014.             ILTRACE(2,("il:gif: %d byte extension %x", len, (int)*q));
  1015.             switch(*q)
  1016.             {
  1017.             case 0xf9:
  1018.                 es = gif_control_extension;
  1019.                 break;
  1020.  
  1021.             case 0x01:
  1022.                 ILTRACE(2,("il:gif: ignoring plain text extension"));
  1023.                 break;
  1024.                             
  1025.             case 0xff:
  1026.                 es = gif_application_extension;
  1027.                 break;
  1028.  
  1029.             case 0xfe:
  1030.                 es = gif_consume_comment;
  1031.                 break;
  1032.             }
  1033.             
  1034.             if (len)
  1035.                 GETN(len, es);
  1036.             else
  1037.                 GETN(1, gif_image_start);
  1038.         }
  1039.         break;
  1040.  
  1041.         case gif_consume_block:
  1042.         {
  1043.             if(!*q)
  1044.             {
  1045.                 GETN(1, gif_image_start);
  1046.             }
  1047.             else
  1048.             {
  1049.                 GETN(*q, gif_skip_block);
  1050.             }
  1051.         }
  1052.         break;
  1053.             
  1054.         case gif_skip_block:
  1055.             GETN(1, gif_consume_block);
  1056.             break;
  1057.  
  1058.         case gif_control_extension:
  1059.         {
  1060.             if(*q & 0x1)
  1061.             {
  1062.                 gs->tpixel = *(q+3);
  1063.                 ILTRACE(2,("il:gif: transparent pixel %d", gs->tpixel));
  1064.                 if (!il_gif_init_transparency(ic, gs->tpixel))
  1065.                     return MK_OUT_OF_MEMORY;
  1066.                 gs->is_transparent = TRUE;
  1067.             }
  1068.             else
  1069.             {
  1070.                 ILTRACE(2,("il:gif: ignoring gfx control extension"));
  1071.             }
  1072.             gs->control_extension = TRUE;
  1073.             gs->disposal_method = (gdispose)(((*q) >> 2) & 0x7);
  1074.             gs->delay_time = GETINT16(q + 1) * 10;
  1075.             GETN(1,gif_consume_block);
  1076.         }
  1077.         break;
  1078.  
  1079.         case gif_comment_extension:
  1080.         {
  1081.             gs->count = *q;
  1082.             if (gs->count) 
  1083.                 GETN(gs->count, gif_consume_comment);
  1084.             else
  1085.                 GETN(1, gif_image_start);
  1086.         }
  1087.         break;
  1088.  
  1089.         case gif_consume_comment:
  1090.         {
  1091.             BlockAllocCat(ic->comment, ic->comment_length, (char*)q, gs->count + 1);
  1092.             ic->comment_length += gs->count;
  1093.             ic->comment[ic->comment_length] = 0;
  1094.             GETN(1, gif_comment_extension);
  1095.         }
  1096.         break;
  1097.  
  1098.         case gif_application_extension:
  1099.             /* Check for netscape application extension */
  1100.             if (!strncmp((char*)q, "NETSCAPE2.0", 11) ||
  1101.                 !strncmp((char*)q, "ANIMEXTS1.0", 11))
  1102.                 GETN(1, gif_netscape_extension_block);
  1103.             else
  1104.                 GETN(1, gif_consume_block);
  1105.             break;
  1106.  
  1107.         /* Netscape-specific GIF extension: animation looping */
  1108.         case gif_netscape_extension_block:
  1109.             if (*q)
  1110.                 GETN(*q, gif_consume_netscape_extension);
  1111.             else
  1112.                 GETN(1, gif_image_start);
  1113.             break;
  1114.  
  1115.         /* Parse netscape-specific application extensions */
  1116.         case gif_consume_netscape_extension:
  1117.         {
  1118.             int netscape_extension = q[0] & 7;
  1119.  
  1120.             /* Loop entire animation specified # of times.  Only read the
  1121.                loop count during the first iteration. */
  1122.             if (netscape_extension == 1) {
  1123.                 if (!ic->is_looping) {
  1124.                     ic->loop_count = GETINT16(q + 1);
  1125.  
  1126.                     /* Zero loop count is infinite animation loop request */
  1127.                     if (ic->loop_count == 0)
  1128.                         ic->loop_count = -1;
  1129.  
  1130.                     /* Tell the front end that the stop state might have changed */
  1131.                     /* because of the looping GIF.                               */
  1132. #ifndef M12N                    /* XXXM12N Fix me. */
  1133.                     if (ic->net_cx)
  1134.                       FE_UpdateStopState(ic->net_cx);
  1135. #endif /* M12N */
  1136.                 }
  1137.  
  1138.                 GETN(1, gif_netscape_extension_block);
  1139.             }
  1140.  
  1141.             /* Wait for specified # of bytes to enter buffer */
  1142.             else if (netscape_extension == 2)
  1143.             {
  1144.                 gs->requested_buffer_fullness = GETINT32(q + 1);
  1145.                 GETN(gs->requested_buffer_fullness, gif_wait_for_buffer_full);
  1146.             }
  1147.  
  1148.             break;
  1149.         }
  1150.  
  1151.         case gif_wait_for_buffer_full:
  1152.             gs->gathered = gs->requested_buffer_fullness;
  1153.             GETN(1, gif_netscape_extension_block);
  1154.             break;
  1155.  
  1156.         case gif_image_header:
  1157.         {
  1158.             uint height, width;
  1159.             
  1160.             /* Get image offsets, with respect to the screen origin */
  1161.             gs->x_offset = GETINT16(q);
  1162.             gs->y_offset = GETINT16(q + 2);
  1163.  
  1164.             /* Get image width and height. */
  1165.             width  = GETINT16(q + 4);            
  1166.             height = GETINT16(q + 6);
  1167.  
  1168.             ILTRACE(2,("il:gif: screen %dx%d, image %dx%d", 
  1169.                        gs->screen_width, gs->screen_height, width, height));
  1170.  
  1171.             /* Work around broken GIF files where the logical screen
  1172.              * size has weird width or height.  We assume that GIF87a
  1173.              * files don't contain animations.
  1174.              */
  1175.          if ((gs->images_decoded == 0) &&
  1176.                 ((gs->screen_height < height) || (gs->screen_width < width) ||
  1177.                  (gs->version == 87))){           
  1178.                 gs->screen_height = height;
  1179.                 gs->screen_width = width;
  1180.                 gs->x_offset = 0;
  1181.                 gs->y_offset = 0;
  1182.             }
  1183.             /* Work around more broken GIF files that have zero image
  1184.                width or height */
  1185.             if (!height || !width) 
  1186.             {
  1187.                 height = gs->screen_height;
  1188.                 width = gs->screen_width;
  1189.             }
  1190.  
  1191.             gs->height = height;
  1192.             gs->width = width;
  1193.  
  1194.             /* This case will never be taken if this is the first image */
  1195.             /* being decoded. If any of the later images are larger     */
  1196.             /* than the screen size, we need to reallocate buffers.     */
  1197.             if (gs->screen_width < width) {
  1198.  
  1199.                 gs->rgbrow = (uint8*)XP_REALLOC(gs->rgbrow, 3 * width);
  1200.                 gs->rowbuf = (uint8*)XP_REALLOC(gs->rowbuf, width);
  1201.             
  1202.                 gs->screen_width = width;
  1203.                 if(gs->screen_height < gs->height )
  1204.                     gs->screen_height = gs->height;
  1205.  
  1206.                 ic->src_header->width = gs->width;
  1207.                 ic->src_header->height = gs->height;
  1208.                 ic->image->header.width = gs->width;
  1209.                 ic->image->header.height = gs->height;
  1210.                 ic->image->header.widthBytes = (ic->image->header.width * ic->image->header.color_space->pixmap_depth + 7)/8; 
  1211.  
  1212.                 ic->image->header.widthBytes = ROUNDUP(ic->image->header.widthBytes, 4);
  1213.                 status = il_size(ic);
  1214.  
  1215.                 if (status < 0)
  1216.                 { 
  1217.                     if (status == MK_OUT_OF_MEMORY) 
  1218.                         gs->state = gif_oom;
  1219.                     else
  1220.                         gs->state = gif_error;
  1221.                     break;
  1222.                 }
  1223.                 IMGCBIF_NewPixmap(ic->img_cx->img_cb, ic->img_cx->dpy_cx, ic->dest_width,
  1224.                               ic->dest_height, ic->image, ic->mask);
  1225.     
  1226.                 if((!ic->scalerow)||(!ic->image->bits)||(ic->mask && !ic->mask->bits)){
  1227.                     gs->state=gif_oom;
  1228.                     break;
  1229.                 }
  1230.         }
  1231.         else{
  1232.             if (!gs->rgbrow)
  1233.                 gs->rgbrow = (uint8*)XP_ALLOC(3 * gs->screen_width);
  1234.  
  1235.             if (!gs->rowbuf)
  1236.                 gs->rowbuf = (uint8*)XP_ALLOC(gs->screen_width);
  1237.         }
  1238.  
  1239.             if (!gs->rowbuf || !gs->rgbrow)
  1240.             {
  1241.                     ILTRACE(0,("il:gif: MEM row"));
  1242.                     gs->state=gif_oom;
  1243.                         break;
  1244.             }
  1245.                     
  1246.             /* Free transparency from earlier image in multi-image sequence. */
  1247.             if (!gs->is_transparent && src_header->transparent_pixel) { 
  1248.                 il_gif_destroy_transparency(ic);
  1249.             }
  1250.  
  1251.             if (gs->images_decoded == 0) {
  1252.                 src_header->width = gs->screen_width;
  1253.                 src_header->height = gs->screen_height;
  1254.                 status = il_size(ic);
  1255.                 if (status < 0)
  1256.                 { 
  1257.                     if (status == MK_OUT_OF_MEMORY) {
  1258.                         ILTRACE(0,("il:gif: MEM il_size"));
  1259.                         gs->state = gif_oom;
  1260.                     }
  1261.                     else
  1262.                         gs->state = gif_error;
  1263.                     break;
  1264.                 }
  1265.             }
  1266.  
  1267.             if ( *(q+8) & 0x40 )
  1268.             {
  1269.                 ILTRACE(2,("il:gif: interlaced"));
  1270.                 gs->interlaced = TRUE;
  1271.                 gs->ipass = 1;
  1272.             } else {
  1273.                 gs->interlaced = FALSE;
  1274.                 gs->ipass = 0;
  1275.             }
  1276.             
  1277.             if (gs->images_decoded == 0)
  1278.             {
  1279.                 gs->progressive_display = ic->img_cx->progressive_display;
  1280.             } else {
  1281.  
  1282.                 /* Overlaying interlaced, transparent GIFs over
  1283.                    existing image data using the Haeberli display hack
  1284.                    requires saving the underlying image in order to
  1285.                    avoid jaggies at the transparency edges.  We are
  1286.                    unprepared to deal with that, so don't display such
  1287.                    images progressively */
  1288.                 gs->progressive_display = ic->img_cx->progressive_display &&
  1289.                     !(gs->interlaced && gs->is_transparent);
  1290.             }
  1291.  
  1292.             /* Clear state from last image */
  1293.             gs->requested_buffer_fullness = 0;
  1294.             gs->control_extension = FALSE;
  1295.             gs->is_transparent = FALSE;
  1296.             gs->irow = 0;
  1297.             gs->rows_remaining = gs->height;
  1298.             gs->rowend = gs->rowbuf + gs->width;
  1299.             gs->rowp = gs->rowbuf;
  1300.  
  1301.             /* bits per pixel is 1<<((q[8]&0x07)+1); */
  1302.  
  1303.             if ( *(q+8) & 0x80 ) 
  1304.             {
  1305.                 int num_colors = 2 << (*(q + 8) & 0x7);
  1306.                 
  1307.                 if ((num_colors > gs->local_colormap_size) &&
  1308.                     gs->local_colormap)
  1309.                 {
  1310.                     XP_FREE(gs->local_colormap);
  1311.                     gs->local_colormap = NULL;
  1312.                 }
  1313.                 gs->local_colormap_size = num_colors;
  1314.                 /* A -ve value for cmap->num_colors indicates that the colors
  1315.                    may be non-unique. */
  1316.                 cmap->num_colors = -num_colors;
  1317.  
  1318.                 /* Switch to the new local palette after it loads */
  1319.                 il_reset_palette(ic);
  1320.  
  1321.                 gs->is_local_colormap_defined = TRUE;
  1322.                 GETN(gs->local_colormap_size * 3, gif_image_colormap);
  1323.             }
  1324.             else
  1325.             {
  1326.                 /* Switch back to the global palette */
  1327.                 if (gs->is_local_colormap_defined)
  1328.                     il_reset_palette(ic);
  1329.  
  1330.                 gs->is_local_colormap_defined = FALSE;
  1331.                 GETN(1, gif_lzw_start);
  1332.             }
  1333.         }
  1334.         break;
  1335.  
  1336.         case gif_image_colormap:
  1337.         {
  1338.             IL_RGB* map;
  1339.             int i;
  1340.  
  1341.             ILTRACE(2,("il:gif: local colormap"));
  1342.                     
  1343.             map = gs->local_colormap;
  1344.             if (!map) 
  1345.             {
  1346.                 map = gs->local_colormap = (IL_RGB*)XP_CALLOC(
  1347.                     gs->local_colormap_size, sizeof(IL_RGB));
  1348.  
  1349.                 if(!map)
  1350.                 {
  1351.                     ILTRACE(0,("il:gif: MEM map"));
  1352.                     gs->state=gif_oom;
  1353.                     break;
  1354.                 }
  1355.             }
  1356.  
  1357. #ifndef M12N                    /* Fix me */
  1358. #ifdef XP_MAC
  1359.             im->hasUniqueColormap = 1;
  1360. #endif
  1361. #endif /* M12N */
  1362.  
  1363.             for (i=0; i < gs->local_colormap_size; i++, map++) 
  1364.             {
  1365.                 map->red   = *q++;
  1366.                 map->green = *q++;
  1367.                 map->blue  = *q++;
  1368.             }
  1369.  
  1370.             GETN(1,gif_lzw_start);
  1371.         }
  1372.         break;
  1373.  
  1374.         case gif_sub_block:
  1375.         {
  1376.             if ((gs->count = *q) != 0)
  1377.             /* Still working on the same image: Process next LZW data block */
  1378.             {
  1379.                 /* Make sure there are still rows left. If the GIF data */
  1380.                 /* is corrupt, we may not get an explicit terminator.   */
  1381.                 if (gs->rows_remaining == 0) {
  1382.                     ILTRACE(3,("il:gif: missing image terminator, continuing"));
  1383.                     /* This is an illegal GIF, but we remain tolerant. */
  1384. #ifdef DONT_TOLERATE_BROKEN_GIFS
  1385.                     gs->state=gif_error;
  1386.                     break;
  1387. #else
  1388.                     GETN(1,gif_sub_block);
  1389. #endif
  1390.                 }
  1391.                 GETN(gs->count, gif_lzw);
  1392.             }
  1393.             else
  1394.             /* See if there are any more images in this sequence. */                
  1395.             {
  1396.                 /* Flush the image data unconditionally, so that we can
  1397.                    notify observers that the current frame has completed. */
  1398.                 il_flush_image_data(ic);
  1399.                 il_frame_complete_notify(ic);
  1400.                 
  1401.                 gs->images_decoded++;
  1402.  
  1403.                 /* An image can specify a delay time before which to display
  1404.                    subsequent images.  Block until the appointed time. */
  1405.                 if(gs->delay_time < MINIMUM_DELAY_TIME )
  1406.                     gs->delay_time = MINIMUM_DELAY_TIME;
  1407.                 if (gs->delay_time){
  1408.                     gs->delay_timeout =
  1409.                         FE_SetTimeout(gif_delay_time_callback, gs, gs->delay_time);
  1410.  
  1411.                     /* Essentially, tell the decoder state machine to wait
  1412.                        forever.  The timeout callback routine will wake up the
  1413.                        state machine and force it to decode the next image. */
  1414.                     GETN(1L<<30, gif_image_start);
  1415.                     gs->state = gif_delay;
  1416.                 } else {
  1417.                     GETN(1, gif_image_start);
  1418.                 }
  1419.             }
  1420.         }
  1421.         break;
  1422.  
  1423.         case gif_done:
  1424.             return 0;
  1425.             break;
  1426.  
  1427.         case gif_delay:
  1428.         case gif_gather:    
  1429.         {
  1430.             int32 gather_remaining;
  1431.             int32 request_size = gs->gather_request_size;
  1432.             
  1433.             {
  1434.                 gather_remaining = request_size - gs->gathered;
  1435.  
  1436.                 /* Do we already have enough data in the accumulation
  1437.                    buffer to satisfy the request ?  (This can happen
  1438.                    after we transition from the gif_delay state.) */
  1439.                 if (gather_remaining <= 0)
  1440.                 {
  1441.                     gs->gathered -= request_size;
  1442.                     q = gs->gather_head;
  1443.                     gs->gather_head += request_size;
  1444.                     gs->state = gs->post_gather_state;
  1445.                     break;
  1446.                 }
  1447.  
  1448.                 /* Shift remaining data to the head of the buffer */
  1449.                 if (gs->gathered && (gs->gather_head != gs->hold)) {
  1450.                     XP_MEMMOVE(gs->hold, gs->gather_head, gs->gathered);
  1451.                     gs->gather_head = gs->hold;
  1452.                 }
  1453.                  
  1454.                 /* If we add the data just handed to us by the netlib
  1455.                    to what we've already gathered, is there enough to satisfy 
  1456.                    the current request ? */
  1457.                 if ((ep - p) >= gather_remaining)
  1458.                 {
  1459.                     if(gs->gathered)
  1460.                     { /* finish a prior gather */
  1461.                         char *hold = (char*)gs->hold;
  1462.                         BlockAllocCat(hold, gs->gathered, (char*)p, gather_remaining);
  1463.                         gs->hold = (uint8*)hold;
  1464.                         q = gs->gather_head = gs->hold;
  1465.                         gs->gathered = 0;
  1466.                     }
  1467.                     else
  1468.                     {
  1469.                         q = p;
  1470.                     }
  1471.                     p += gather_remaining;
  1472.                     gs->state = gs->post_gather_state;
  1473.                 }
  1474.                 else
  1475.                 { 
  1476.                     char *hold = (char*)gs->hold;
  1477.                     BlockAllocCat(hold, gs->gathered, (char*)p, ep - p);
  1478.                     gs->hold = (uint8*)hold;
  1479.                     gs->gather_head = gs->hold;
  1480.                     gs->gathered += ep-p;
  1481.                     return 0;
  1482.                 }
  1483.             }
  1484.         }
  1485.         break;
  1486.  
  1487.         case gif_oom: 
  1488.             ILTRACE(1,("il:gif: reached oom state"));
  1489.             return MK_OUT_OF_MEMORY;
  1490.             break;
  1491.  
  1492.         case gif_error: 
  1493.             ILTRACE(2,("il:gif: reached error state"));
  1494.             return MK_IMAGE_LOSSAGE;
  1495.             break;
  1496.  
  1497.         default: 
  1498.             ILTRACE(0,("il:gif: unknown state"));
  1499.             XP_ASSERT(0);
  1500.             break;
  1501.         }
  1502.     }
  1503.  
  1504.     return 0;
  1505. }
  1506.  
  1507. void
  1508. il_gif_complete(il_container *ic)
  1509. {
  1510.     if (ic->ds)
  1511.     {
  1512.         gif_struct *gs = (gif_struct*) ic->ds;
  1513.  
  1514.         /* No more data in the stream, but we may still have work to do,
  1515.            so don't actually free any of the data structures. */
  1516.         if (gs->delay_timeout) {
  1517.             /* We will free the data structures when image display completes. */
  1518.             gs->destroy_pending = TRUE;
  1519.             return;
  1520.         } else if (gs->requested_buffer_fullness) {
  1521.             /* We will free the data structures when image display completes. */
  1522.             gs->destroy_pending = TRUE;
  1523.             process_buffered_gif_input_data(gs);
  1524.             return;
  1525.         }
  1526.         il_gif_abort(ic);
  1527.     }
  1528.     il_image_complete(ic);
  1529. }
  1530.  
  1531. /* Free up all the data structures associated with decoding a GIF */
  1532. void
  1533. il_gif_abort(il_container *ic)
  1534. {
  1535.     if (ic->ds) 
  1536.     {
  1537.         gif_struct *gs = (gif_struct*) ic->ds;
  1538.  
  1539.         /* Clear any pending timeouts */
  1540.         if (gs->delay_timeout) {
  1541.             FE_ClearTimeout(gs->delay_timeout);
  1542.             gs->delay_timeout = NULL;
  1543.         }
  1544.     
  1545.         if (gs->rowbuf) 
  1546.             XP_FREE(gs->rowbuf);
  1547.         if (gs->rgbrow) 
  1548.             XP_FREE(gs->rgbrow);
  1549.         if (gs->prefix)
  1550.             XP_FREE(gs->prefix);
  1551.         if (gs->suffix)
  1552.             XP_FREE(gs->suffix);
  1553.         if (gs->stack)
  1554.             XP_FREE(gs->stack);
  1555.  
  1556.         if (gs->hold)
  1557.             XP_FREE(gs->hold);
  1558.  
  1559.         /* Free the colormap that is not in use.  The other one, if
  1560.          * present, will be freed when the image container is
  1561.          * destroyed.
  1562.          */
  1563.         if (gs->is_local_colormap_defined) {
  1564.             if (gs->global_colormap) {
  1565.                 XP_FREE(gs->global_colormap);
  1566.                 gs->global_colormap = NULL;
  1567.             }
  1568.         } else {
  1569.             if (gs->local_colormap) {
  1570.                 XP_FREE(gs->local_colormap);
  1571.                 gs->local_colormap = NULL;
  1572.             }
  1573.         }
  1574.  
  1575.         XP_FREE(gs);
  1576.  
  1577.         ic->ds = 0;
  1578.     }
  1579. }
  1580.  
  1581. #ifdef PROFILE
  1582. #pragma profile off
  1583. #endif
  1584.  
  1585.