rdgif.c

   1 /*
   2  * rdgif.c
   3  *
   4  * This file was part of the Independent JPEG Group's software:
   5  * Copyright (C) 1991-1997, Thomas G. Lane.
   6  * Modified 2019 by Guido Vollbeding.
   7  * libjpeg-turbo Modifications:
   8  * Copyright (C) 2021-2022, D. R. Commander.
   9  * For conditions of distribution and use, see the accompanying README.ijg
  10  * file.
  11  *
  12  * This file contains routines to read input images in GIF format.
  13  *
  14  * These routines may need modification for non-Unix environments or
  15  * specialized applications.  As they stand, they assume input from
  16  * an ordinary stdio stream.  They further assume that reading begins
  17  * at the start of the file; start_input may need work if the
  18  * user interface has already read some data (e.g., to determine that
  19  * the file is indeed GIF format).
  20  */
  21
  22 /*
  23  * This code is loosely based on giftoppm from the PBMPLUS distribution
  24  * of Feb. 1991.  That file contains the following copyright notice:
  25  * +-------------------------------------------------------------------+
  26  * | Copyright 1990, David Koblas.                                     |
  27  * |   Permission to use, copy, modify, and distribute this software   |
  28  * |   and its documentation for any purpose and without fee is hereby |
  29  * |   granted, provided that the above copyright notice appear in all |
  30  * |   copies and that both that copyright notice and this permission  |
  31  * |   notice appear in supporting documentation.  This software is    |
  32  * |   provided "as is" without express or implied warranty.           |
  33  * +-------------------------------------------------------------------+
  34  */
  35
  36 #include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
  37 #include "jsamplecomp.h"
  38
  39 #if defined(GIF_SUPPORTED) && \
  40     (BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED))
  41
  42
  43 /* Macros to deal with unsigned chars as efficiently as compiler allows */
  44
  45 typedef unsigned char U_CHAR;
  46 #define UCH(x)  ((int)(x))
  47
  48
  49 #define ReadOK(file, buffer, len) \
  50   (fread(buffer, 1, len, file) == ((size_t)(len)))
  51
  52
  53 #define MAXCOLORMAPSIZE  256    /* max # of colors in a GIF colormap */
  54 #define NUMCOLORS        3      /* # of colors */
  55 #define CM_RED           0      /* color component numbers */
  56 #define CM_GREEN         1
  57 #define CM_BLUE          2
  58
  59 #define MAX_LZW_BITS     12     /* maximum LZW code size */
  60 #define LZW_TABLE_SIZE   (1 << MAX_LZW_BITS) /* # of possible LZW symbols */
  61
  62 /* Macros for extracting header data --- note we assume chars may be signed */
  63
  64 #define LM_to_uint(array, offset) \
  65   ((unsigned int)UCH(array[offset]) + \
  66    (((unsigned int)UCH(array[offset + 1])) << 8))
  67
  68 #define BitSet(byte, bit)       ((byte) & (bit))
  69 #define INTERLACE       0x40    /* mask for bit signifying interlaced image */
  70 #define COLORMAPFLAG    0x80    /* mask for bit signifying colormap presence */
  71
  72
  73 /*
  74  * LZW decompression tables look like this:
  75  *   symbol_head[K] = prefix symbol of any LZW symbol K (0..LZW_TABLE_SIZE-1)
  76  *   symbol_tail[K] = suffix byte   of any LZW symbol K (0..LZW_TABLE_SIZE-1)
  77  * Note that entries 0..end_code of the above tables are not used,
  78  * since those symbols represent raw bytes or special codes.
  79  *
  80  * The stack represents the not-yet-used expansion of the last LZW symbol.
  81  * In the worst case, a symbol could expand to as many bytes as there are
  82  * LZW symbols, so we allocate LZW_TABLE_SIZE bytes for the stack.
  83  * (This is conservative since that number includes the raw-byte symbols.)
  84  */
  85
  86
  87 /* Private version of data source object */
  88
  89 typedef struct {
  90   struct cjpeg_source_struct pub; /* public fields */
  91
  92   j_compress_ptr cinfo;         /* back link saves passing separate parm */
  93
  94   _JSAMPARRAY colormap;         /* GIF colormap (converted to my format) */
  95
  96   /* State for GetCode and LZWReadByte */
  97   U_CHAR code_buf[256 + 4];     /* current input data block */
  98   int last_byte;                /* # of bytes in code_buf */
  99   int last_bit;                 /* # of bits in code_buf */
 100   int cur_bit;                  /* next bit index to read */
 101   boolean first_time;           /* flags first call to GetCode */
 102   boolean out_of_blocks;        /* TRUE if hit terminator data block */
 103
 104   int input_code_size;          /* codesize given in GIF file */
 105   int clear_code, end_code;     /* values for Clear and End codes */
 106
 107   int code_size;                /* current actual code size */
 108   int limit_code;               /* 2^code_size */
 109   int max_code;                 /* first unused code value */
 110
 111   /* Private state for LZWReadByte */
 112   int oldcode;                  /* previous LZW symbol */
 113   int firstcode;                /* first byte of oldcode's expansion */
 114
 115   /* LZW symbol table and expansion stack */
 116   UINT16 *symbol_head;          /* => table of prefix symbols */
 117   UINT8  *symbol_tail;          /* => table of suffix bytes */
 118   UINT8  *symbol_stack;         /* => stack for symbol expansions */
 119   UINT8  *sp;                   /* stack pointer */
 120
 121   /* State for interlaced image processing */
 122   boolean is_interlaced;        /* TRUE if have interlaced image */
 123   jvirt_sarray_ptr interlaced_image; /* full image in interlaced order */
 124   JDIMENSION cur_row_number;    /* need to know actual row number */
 125   JDIMENSION pass2_offset;      /* # of pixel rows in pass 1 */
 126   JDIMENSION pass3_offset;      /* # of pixel rows in passes 1&2 */
 127   JDIMENSION pass4_offset;      /* # of pixel rows in passes 1,2,3 */
 128 } gif_source_struct;
 129
 130 typedef gif_source_struct *gif_source_ptr;
 131
 132
 133 /* Forward declarations */
 134 METHODDEF(JDIMENSION) get_pixel_rows(j_compress_ptr cinfo,
 135                                      cjpeg_source_ptr sinfo);
 136 METHODDEF(JDIMENSION) load_interlaced_image(j_compress_ptr cinfo,
 137                                             cjpeg_source_ptr sinfo);
 138 METHODDEF(JDIMENSION) get_interlaced_row(j_compress_ptr cinfo,
 139                                          cjpeg_source_ptr sinfo);
 140
 141
 142 LOCAL(int)
 143 ReadByte(gif_source_ptr sinfo)
 144 /* Read next byte from GIF file */
 145 {
 146   register FILE *infile = sinfo->pub.input_file;
 147   register int c;
 148
 149   if ((c = getc(infile)) == EOF)
 150     ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
 151   return c;
 152 }
 153
 154
 155 LOCAL(int)
 156 GetDataBlock(gif_source_ptr sinfo, U_CHAR *buf)
 157 /* Read a GIF data block, which has a leading count byte */
 158 /* A zero-length block marks the end of a data block sequence */
 159 {
 160   int count;
 161
 162   count = ReadByte(sinfo);
 163   if (count > 0) {
 164     if (!ReadOK(sinfo->pub.input_file, buf, count))
 165       ERREXIT(sinfo->cinfo, JERR_INPUT_EOF);
 166   }
 167   return count;
 168 }
 169
 170
 171 LOCAL(void)
 172 SkipDataBlocks(gif_source_ptr sinfo)
 173 /* Skip a series of data blocks, until a block terminator is found */
 174 {
 175   U_CHAR buf[256];
 176
 177   while (GetDataBlock(sinfo, buf) > 0)
 178     /* skip */;
 179 }
 180
 181
 182 LOCAL(void)
 183 ReInitLZW(gif_source_ptr sinfo)
 184 /* (Re)initialize LZW state; shared code for startup and Clear processing */
 185 {
 186   sinfo->code_size = sinfo->input_code_size + 1;
 187   sinfo->limit_code = sinfo->clear_code << 1;   /* 2^code_size */
 188   sinfo->max_code = sinfo->clear_code + 2;      /* first unused code value */
 189   sinfo->sp = sinfo->symbol_stack;              /* init stack to empty */
 190 }
 191
 192
 193 LOCAL(void)
 194 InitLZWCode(gif_source_ptr sinfo)
 195 /* Initialize for a series of LZWReadByte (and hence GetCode) calls */
 196 {
 197   /* GetCode initialization */
 198   sinfo->last_byte = 2;         /* make safe to "recopy last two bytes" */
 199   sinfo->code_buf[0] = 0;
 200   sinfo->code_buf[1] = 0;
 201   sinfo->last_bit = 0;          /* nothing in the buffer */
 202   sinfo->cur_bit = 0;           /* force buffer load on first call */
 203   sinfo->first_time = TRUE;
 204   sinfo->out_of_blocks = FALSE;
 205
 206   /* LZWReadByte initialization: */
 207   /* compute special code values (note that these do not change later) */
 208   sinfo->clear_code = 1 << sinfo->input_code_size;
 209   sinfo->end_code = sinfo->clear_code + 1;
 210   ReInitLZW(sinfo);
 211 }
 212
 213
 214 LOCAL(int)
 215 GetCode(gif_source_ptr sinfo)
 216 /* Fetch the next code_size bits from the GIF data */
 217 /* We assume code_size is less than 16 */
 218 {
 219   register int accum;
 220   int offs, count;
 221
 222   while (sinfo->cur_bit + sinfo->code_size > sinfo->last_bit) {
 223     /* Time to reload the buffer */
 224     /* First time, share code with Clear case */
 225     if (sinfo->first_time) {
 226       sinfo->first_time = FALSE;
 227       return sinfo->clear_code;
 228     }
 229     if (sinfo->out_of_blocks) {
 230       WARNMS(sinfo->cinfo, JWRN_GIF_NOMOREDATA);
 231       return sinfo->end_code;   /* fake something useful */
 232     }
 233     /* preserve last two bytes of what we have -- assume code_size <= 16 */
 234     sinfo->code_buf[0] = sinfo->code_buf[sinfo->last_byte-2];
 235     sinfo->code_buf[1] = sinfo->code_buf[sinfo->last_byte-1];
 236     /* Load more bytes; set flag if we reach the terminator block */
 237     if ((count = GetDataBlock(sinfo, &sinfo->code_buf[2])) == 0) {
 238       sinfo->out_of_blocks = TRUE;
 239       WARNMS(sinfo->cinfo, JWRN_GIF_NOMOREDATA);
 240       return sinfo->end_code;   /* fake something useful */
 241     }
 242     /* Reset counters */
 243     sinfo->cur_bit = (sinfo->cur_bit - sinfo->last_bit) + 16;
 244     sinfo->last_byte = 2 + count;
 245     sinfo->last_bit = sinfo->last_byte * 8;
 246   }
 247
 248   /* Form up next 24 bits in accum */
 249   offs = sinfo->cur_bit >> 3;   /* byte containing cur_bit */
 250   accum = UCH(sinfo->code_buf[offs + 2]);
 251   accum <<= 8;
 252   accum |= UCH(sinfo->code_buf[offs + 1]);
 253   accum <<= 8;
 254   accum |= UCH(sinfo->code_buf[offs]);
 255
 256   /* Right-align cur_bit in accum, then mask off desired number of bits */
 257   accum >>= (sinfo->cur_bit & 7);
 258   sinfo->cur_bit += sinfo->code_size;
 259   return accum & ((1 << sinfo->code_size) - 1);
 260 }
 261
 262
 263 LOCAL(int)
 264 LZWReadByte(gif_source_ptr sinfo)
 265 /* Read an LZW-compressed byte */
 266 {
 267   register int code;            /* current working code */
 268   int incode;                   /* saves actual input code */
 269
 270   /* If any codes are stacked from a previously read symbol, return them */
 271   if (sinfo->sp > sinfo->symbol_stack)
 272     return (int)(*(--sinfo->sp));
 273
 274   /* Time to read a new symbol */
 275   code = GetCode(sinfo);
 276
 277   if (code == sinfo->clear_code) {
 278     /* Reinit state, swallow any extra Clear codes, and */
 279     /* return next code, which is expected to be a raw byte. */
 280     ReInitLZW(sinfo);
 281     do {
 282       code = GetCode(sinfo);
 283     } while (code == sinfo->clear_code);
 284     if (code > sinfo->clear_code) { /* make sure it is a raw byte */
 285       WARNMS(sinfo->cinfo, JWRN_GIF_BADDATA);
 286       code = 0;                 /* use something valid */
 287     }
 288     /* make firstcode, oldcode valid! */
 289     sinfo->firstcode = sinfo->oldcode = code;
 290     return code;
 291   }
 292
 293   if (code == sinfo->end_code) {
 294     /* Skip the rest of the image, unless GetCode already read terminator */
 295     if (!sinfo->out_of_blocks) {
 296       SkipDataBlocks(sinfo);
 297       sinfo->out_of_blocks = TRUE;
 298     }
 299     /* Complain that there's not enough data */
 300     WARNMS(sinfo->cinfo, JWRN_GIF_ENDCODE);
 301     /* Pad data with 0's */
 302     return 0;                   /* fake something usable */
 303   }
 304
 305   /* Got normal raw byte or LZW symbol */
 306   incode = code;                /* save for a moment */
 307
 308   if (code >= sinfo->max_code) { /* special case for not-yet-defined symbol */
 309     /* code == max_code is OK; anything bigger is bad data */
 310     if (code > sinfo->max_code) {
 311       WARNMS(sinfo->cinfo, JWRN_GIF_BADDATA);
 312       incode = 0;               /* prevent creation of loops in symbol table */
 313     }
 314     /* this symbol will be defined as oldcode/firstcode */
 315     *(sinfo->sp++) = (UINT8)sinfo->firstcode;
 316     code = sinfo->oldcode;
 317   }
 318
 319   /* If it's a symbol, expand it into the stack */
 320   while (code >= sinfo->clear_code) {
 321     *(sinfo->sp++) = sinfo->symbol_tail[code]; /* tail is a byte value */
 322     code = sinfo->symbol_head[code]; /* head is another LZW symbol */
 323   }
 324   /* At this point code just represents a raw byte */
 325   sinfo->firstcode = code;      /* save for possible future use */
 326
 327   /* If there's room in table... */
 328   if ((code = sinfo->max_code) < LZW_TABLE_SIZE) {
 329     /* Define a new symbol = prev sym + head of this sym's expansion */
 330     sinfo->symbol_head[code] = (UINT16)sinfo->oldcode;
 331     sinfo->symbol_tail[code] = (UINT8)sinfo->firstcode;
 332     sinfo->max_code++;
 333     /* Is it time to increase code_size? */
 334     if (sinfo->max_code >= sinfo->limit_code &&
 335         sinfo->code_size < MAX_LZW_BITS) {
 336       sinfo->code_size++;
 337       sinfo->limit_code <<= 1;  /* keep equal to 2^code_size */
 338     }
 339   }
 340
 341   sinfo->oldcode = incode;      /* save last input symbol for future use */
 342   return sinfo->firstcode;      /* return first byte of symbol's expansion */
 343 }
 344
 345
 346 LOCAL(void)
 347 ReadColorMap(gif_source_ptr sinfo, int cmaplen, _JSAMPARRAY cmap)
 348 /* Read a GIF colormap */
 349 {
 350   int i, gray = 1;
 351
 352   for (i = 0; i < cmaplen; i++) {
 353 #if BITS_IN_JSAMPLE == 8
 354 #define UPSCALE(x)  (x)
 355 #else
 356 #define UPSCALE(x)  ((x) << (BITS_IN_JSAMPLE - 8))
 357 #endif
 358     cmap[CM_RED][i]   = (_JSAMPLE)UPSCALE(ReadByte(sinfo));
 359     cmap[CM_GREEN][i] = (_JSAMPLE)UPSCALE(ReadByte(sinfo));
 360     cmap[CM_BLUE][i]  = (_JSAMPLE)UPSCALE(ReadByte(sinfo));
 361     if (cmap[CM_RED][i] != cmap[CM_GREEN][i] ||
 362         cmap[CM_GREEN][i] != cmap[CM_BLUE][i])
 363       gray = 0;
 364   }
 365
 366   if (sinfo->cinfo->in_color_space == JCS_RGB && gray) {
 367     sinfo->cinfo->in_color_space = JCS_GRAYSCALE;
 368     sinfo->cinfo->input_components = 1;
 369   }
 370 }
 371
 372
 373 LOCAL(void)
 374 DoExtension(gif_source_ptr sinfo)
 375 /* Process an extension block */
 376 /* Currently we ignore 'em all */
 377 {
 378   int extlabel;
 379
 380   /* Read extension label byte */
 381   extlabel = ReadByte(sinfo);
 382   TRACEMS1(sinfo->cinfo, 1, JTRC_GIF_EXTENSION, extlabel);
 383   /* Skip the data block(s) associated with the extension */
 384   SkipDataBlocks(sinfo);
 385 }
 386
 387
 388 /*
 389  * Read the file header; return image size and component count.
 390  */
 391
 392 METHODDEF(void)
 393 start_input_gif(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 394 {
 395   gif_source_ptr source = (gif_source_ptr)sinfo;
 396   U_CHAR hdrbuf[10];            /* workspace for reading control blocks */
 397   unsigned int width, height;   /* image dimensions */
 398   int colormaplen, aspectRatio;
 399   int c;
 400
 401   /* Read and verify GIF Header */
 402   if (!ReadOK(source->pub.input_file, hdrbuf, 6))
 403     ERREXIT(cinfo, JERR_GIF_NOT);
 404   if (hdrbuf[0] != 'G' || hdrbuf[1] != 'I' || hdrbuf[2] != 'F')
 405     ERREXIT(cinfo, JERR_GIF_NOT);
 406   /* Check for expected version numbers.
 407    * If unknown version, give warning and try to process anyway;
 408    * this is per recommendation in GIF89a standard.
 409    */
 410   if ((hdrbuf[3] != '8' || hdrbuf[4] != '7' || hdrbuf[5] != 'a') &&
 411       (hdrbuf[3] != '8' || hdrbuf[4] != '9' || hdrbuf[5] != 'a'))
 412     TRACEMS3(cinfo, 1, JTRC_GIF_BADVERSION, hdrbuf[3], hdrbuf[4], hdrbuf[5]);
 413
 414   /* Read and decipher Logical Screen Descriptor */
 415   if (!ReadOK(source->pub.input_file, hdrbuf, 7))
 416     ERREXIT(cinfo, JERR_INPUT_EOF);
 417   width = LM_to_uint(hdrbuf, 0);
 418   height = LM_to_uint(hdrbuf, 2);
 419   if (width == 0 || height == 0)
 420     ERREXIT(cinfo, JERR_GIF_EMPTY);
 421 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 422   if (sinfo->max_pixels &&
 423       (unsigned long long)width * height > sinfo->max_pixels)
 424     ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
 425 #endif
 426   /* we ignore the color resolution, sort flag, and background color index */
 427   aspectRatio = UCH(hdrbuf[6]);
 428   if (aspectRatio != 0 && aspectRatio != 49)
 429     TRACEMS(cinfo, 1, JTRC_GIF_NONSQUARE);
 430
 431   /* Allocate space to store the colormap */
 432   source->colormap = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
 433     ((j_common_ptr)cinfo, JPOOL_IMAGE, (JDIMENSION)MAXCOLORMAPSIZE,
 434      (JDIMENSION)NUMCOLORS);
 435   colormaplen = 0;              /* indicate initialization */
 436
 437   /* Read global colormap if header indicates it is present */
 438   if (BitSet(hdrbuf[4], COLORMAPFLAG)) {
 439     colormaplen = 2 << (hdrbuf[4] & 0x07);
 440     ReadColorMap(source, colormaplen, source->colormap);
 441   }
 442
 443   /* Scan until we reach start of desired image.
 444    * We don't currently support skipping images, but could add it easily.
 445    */
 446   for (;;) {
 447     c = ReadByte(source);
 448
 449     if (c == ';')               /* GIF terminator?? */
 450       ERREXIT(cinfo, JERR_GIF_IMAGENOTFOUND);
 451
 452     if (c == '!') {             /* Extension */
 453       DoExtension(source);
 454       continue;
 455     }
 456
 457     if (c != ',') {             /* Not an image separator? */
 458       WARNMS1(cinfo, JWRN_GIF_CHAR, c);
 459       continue;
 460     }
 461
 462     /* Read and decipher Local Image Descriptor */
 463     if (!ReadOK(source->pub.input_file, hdrbuf, 9))
 464       ERREXIT(cinfo, JERR_INPUT_EOF);
 465     /* we ignore top/left position info, also sort flag */
 466     width = LM_to_uint(hdrbuf, 4);
 467     height = LM_to_uint(hdrbuf, 6);
 468     if (width == 0 || height == 0)
 469       ERREXIT(cinfo, JERR_GIF_EMPTY);
 470 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 471     if (sinfo->max_pixels &&
 472         (unsigned long long)width * height > sinfo->max_pixels)
 473       ERREXIT(cinfo, JERR_WIDTH_OVERFLOW);
 474 #endif
 475     source->is_interlaced = (BitSet(hdrbuf[8], INTERLACE) != 0);
 476
 477     /* Read local colormap if header indicates it is present */
 478     /* Note: if we wanted to support skipping images, */
 479     /* we'd need to skip rather than read colormap for ignored images */
 480     if (BitSet(hdrbuf[8], COLORMAPFLAG)) {
 481       colormaplen = 2 << (hdrbuf[8] & 0x07);
 482       ReadColorMap(source, colormaplen, source->colormap);
 483     }
 484
 485     source->input_code_size = ReadByte(source); /* get min-code-size byte */
 486     if (source->input_code_size < 2 || source->input_code_size > 8)
 487       ERREXIT1(cinfo, JERR_GIF_CODESIZE, source->input_code_size);
 488
 489     /* Reached desired image, so break out of loop */
 490     /* If we wanted to skip this image, */
 491     /* we'd call SkipDataBlocks and then continue the loop */
 492     break;
 493   }
 494
 495   /* Prepare to read selected image: first initialize LZW decompressor */
 496   source->symbol_head = (UINT16 *)
 497     (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 498                                 LZW_TABLE_SIZE * sizeof(UINT16));
 499   source->symbol_tail = (UINT8 *)
 500     (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 501                                 LZW_TABLE_SIZE * sizeof(UINT8));
 502   source->symbol_stack = (UINT8 *)
 503     (*cinfo->mem->alloc_large) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 504                                 LZW_TABLE_SIZE * sizeof(UINT8));
 505   InitLZWCode(source);
 506
 507   /*
 508    * If image is interlaced, we read it into a full-size sample array,
 509    * decompressing as we go; then get_interlaced_row selects rows from the
 510    * sample array in the proper order.
 511    */
 512   if (source->is_interlaced) {
 513     /* We request the virtual array now, but can't access it until virtual
 514      * arrays have been allocated.  Hence, the actual work of reading the
 515      * image is postponed until the first call to get_pixel_rows.
 516      */
 517     source->interlaced_image = (*cinfo->mem->request_virt_sarray)
 518       ((j_common_ptr)cinfo, JPOOL_IMAGE, FALSE,
 519        (JDIMENSION)width, (JDIMENSION)height, (JDIMENSION)1);
 520     if (cinfo->progress != NULL) {
 521       cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
 522       progress->total_extra_passes++; /* count file input as separate pass */
 523     }
 524     source->pub.get_pixel_rows = load_interlaced_image;
 525   } else {
 526     source->pub.get_pixel_rows = get_pixel_rows;
 527   }
 528
 529   if (cinfo->in_color_space != JCS_GRAYSCALE) {
 530     cinfo->in_color_space = JCS_RGB;
 531     cinfo->input_components = NUMCOLORS;
 532   }
 533
 534   /* Create compressor input buffer. */
 535   source->pub._buffer = (_JSAMPARRAY)(*cinfo->mem->alloc_sarray)
 536     ((j_common_ptr)cinfo, JPOOL_IMAGE,
 537      (JDIMENSION)width * cinfo->input_components, (JDIMENSION)1);
 538   source->pub.buffer_height = 1;
 539
 540   /* Pad colormap for safety. */
 541   for (c = colormaplen; c < source->clear_code; c++) {
 542     source->colormap[CM_RED][c]   =
 543     source->colormap[CM_GREEN][c] =
 544     source->colormap[CM_BLUE][c]  = _CENTERJSAMPLE;
 545   }
 546
 547   /* Return info about the image. */
 548   cinfo->data_precision = BITS_IN_JSAMPLE; /* we always rescale data to this */
 549   cinfo->image_width = width;
 550   cinfo->image_height = height;
 551
 552   TRACEMS3(cinfo, 1, JTRC_GIF, width, height, colormaplen);
 553 }
 554
 555
 556 /*
 557  * Read one row of pixels.
 558  * This version is used for noninterlaced GIF images:
 559  * we read directly from the GIF file.
 560  */
 561
 562 METHODDEF(JDIMENSION)
 563 get_pixel_rows(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 564 {
 565   gif_source_ptr source = (gif_source_ptr)sinfo;
 566   register int c;
 567   register _JSAMPROW ptr;
 568   register JDIMENSION col;
 569   register _JSAMPARRAY colormap = source->colormap;
 570
 571   ptr = source->pub._buffer[0];
 572   if (cinfo->in_color_space == JCS_GRAYSCALE) {
 573     for (col = cinfo->image_width; col > 0; col--) {
 574       c = LZWReadByte(source);
 575       *ptr++ = colormap[CM_RED][c];
 576     }
 577   } else {
 578     for (col = cinfo->image_width; col > 0; col--) {
 579       c = LZWReadByte(source);
 580       *ptr++ = colormap[CM_RED][c];
 581       *ptr++ = colormap[CM_GREEN][c];
 582       *ptr++ = colormap[CM_BLUE][c];
 583     }
 584   }
 585   return 1;
 586 }
 587
 588
 589 /*
 590  * Read one row of pixels.
 591  * This version is used for the first call on get_pixel_rows when
 592  * reading an interlaced GIF file: we read the whole image into memory.
 593  */
 594
 595 METHODDEF(JDIMENSION)
 596 load_interlaced_image(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 597 {
 598   gif_source_ptr source = (gif_source_ptr)sinfo;
 599   register _JSAMPROW sptr;
 600   register JDIMENSION col;
 601   JDIMENSION row;
 602   cd_progress_ptr progress = (cd_progress_ptr)cinfo->progress;
 603
 604   /* Read the interlaced image into the virtual array we've created. */
 605   for (row = 0; row < cinfo->image_height; row++) {
 606     if (progress != NULL) {
 607       progress->pub.pass_counter = (long)row;
 608       progress->pub.pass_limit = (long)cinfo->image_height;
 609       (*progress->pub.progress_monitor) ((j_common_ptr)cinfo);
 610     }
 611     sptr = *(_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
 612       ((j_common_ptr)cinfo, source->interlaced_image, row, (JDIMENSION)1,
 613        TRUE);
 614     for (col = cinfo->image_width; col > 0; col--) {
 615       *sptr++ = (_JSAMPLE)LZWReadByte(source);
 616     }
 617   }
 618   if (progress != NULL)
 619     progress->completed_extra_passes++;
 620
 621   /* Replace method pointer so subsequent calls don't come here. */
 622   source->pub.get_pixel_rows = get_interlaced_row;
 623   /* Initialize for get_interlaced_row, and perform first call on it. */
 624   source->cur_row_number = 0;
 625   source->pass2_offset = (cinfo->image_height + 7) / 8;
 626   source->pass3_offset = source->pass2_offset + (cinfo->image_height + 3) / 8;
 627   source->pass4_offset = source->pass3_offset + (cinfo->image_height + 1) / 4;
 628
 629   return get_interlaced_row(cinfo, sinfo);
 630 }
 631
 632
 633 /*
 634  * Read one row of pixels.
 635  * This version is used for interlaced GIF images:
 636  * we read from the virtual array.
 637  */
 638
 639 METHODDEF(JDIMENSION)
 640 get_interlaced_row(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 641 {
 642   gif_source_ptr source = (gif_source_ptr)sinfo;
 643   register int c;
 644   register _JSAMPROW sptr, ptr;
 645   register JDIMENSION col;
 646   register _JSAMPARRAY colormap = source->colormap;
 647   JDIMENSION irow;
 648
 649   /* Figure out which row of interlaced image is needed, and access it. */
 650   switch ((int)(source->cur_row_number & 7)) {
 651   case 0:                       /* first-pass row */
 652     irow = source->cur_row_number >> 3;
 653     break;
 654   case 4:                       /* second-pass row */
 655     irow = (source->cur_row_number >> 3) + source->pass2_offset;
 656     break;
 657   case 2:                       /* third-pass row */
 658   case 6:
 659     irow = (source->cur_row_number >> 2) + source->pass3_offset;
 660     break;
 661   default:                      /* fourth-pass row */
 662     irow = (source->cur_row_number >> 1) + source->pass4_offset;
 663   }
 664   sptr = *(_JSAMPARRAY)(*cinfo->mem->access_virt_sarray)
 665     ((j_common_ptr)cinfo, source->interlaced_image, irow, (JDIMENSION)1,
 666      FALSE);
 667   /* Scan the row, expand colormap, and output */
 668   ptr = source->pub._buffer[0];
 669   if (cinfo->in_color_space == JCS_GRAYSCALE) {
 670     for (col = cinfo->image_width; col > 0; col--) {
 671       c = *sptr++;
 672       *ptr++ = colormap[CM_RED][c];
 673     }
 674   } else {
 675     for (col = cinfo->image_width; col > 0; col--) {
 676       c = *sptr++;
 677       *ptr++ = colormap[CM_RED][c];
 678       *ptr++ = colormap[CM_GREEN][c];
 679       *ptr++ = colormap[CM_BLUE][c];
 680     }
 681   }
 682   source->cur_row_number++;     /* for next time */
 683   return 1;
 684 }
 685
 686
 687 /*
 688  * Finish up at the end of the file.
 689  */
 690
 691 METHODDEF(void)
 692 finish_input_gif(j_compress_ptr cinfo, cjpeg_source_ptr sinfo)
 693 {
 694   /* no work */
 695 }
 696
 697
 698 /*
 699  * The module selection routine for GIF format input.
 700  */
 701
 702 GLOBAL(cjpeg_source_ptr)
 703 _jinit_read_gif(j_compress_ptr cinfo)
 704 {
 705   gif_source_ptr source;
 706
 707   if (cinfo->data_precision != BITS_IN_JSAMPLE)
 708     ERREXIT1(cinfo, JERR_BAD_PRECISION, cinfo->data_precision);
 709
 710   /* Create module interface object */
 711   source = (gif_source_ptr)
 712     (*cinfo->mem->alloc_small) ((j_common_ptr)cinfo, JPOOL_IMAGE,
 713                                 sizeof(gif_source_struct));
 714   source->cinfo = cinfo;        /* make back link for subroutines */
 715   /* Fill in method ptrs, except get_pixel_rows which start_input sets */
 716   source->pub.start_input = start_input_gif;
 717   source->pub.finish_input = finish_input_gif;
 718 #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
 719   source->pub.max_pixels = 0;
 720 #endif
 721
 722   return (cjpeg_source_ptr)source;
 723 }
 724
 725 #endif /* defined(GIF_SUPPORTED) &&
 726           (BITS_IN_JSAMPLE != 16 || defined(C_LOSSLESS_SUPPORTED)) */