Update to libjpeg_turbo 1.4.90

wrgif.c

 /*
  * wrgif.c
  *
+ * This file was part of the Independent JPEG Group's software:
  * Copyright (C) 1991-1997, Thomas G. Lane.
- * This file is part of the Independent JPEG Group's software.
- * For conditions of distribution and use, see the accompanying README file.
+ * libjpeg-turbo Modifications:
+ * Copyright (C) 2015, D. R. Commander.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
  *
  * This file contains routines to write output images in GIF format.
  *
  **************************************************************************
  * NOTE: to avoid entanglements with Unisys' patent on LZW compression,   *
  * this code has been modified to output "uncompressed GIF" files.        *
  * There is no trace of the LZW algorithm in this file.                   *
  **************************************************************************
  *
  * These routines may need modification for non-Unix environments or
@@ skipping 13 matching lines @@
  *    copyright notice and this permission notice appear in supporting
  *    documentation.  This software is provided "as is" without express or
  *    implied warranty.
  *
  * We are also required to state that
  *    "The Graphics Interchange Format(c) is the Copyright property of
  *    CompuServe Incorporated. GIF(sm) is a Service Mark property of
  *    CompuServe Incorporated."
  */
 
-#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
 
 #ifdef GIF_SUPPORTED
 
 
 /* Private version of data destination object */
 
 typedef struct {
-  struct djpeg_dest_struct pub; /* public fields */
+  struct djpeg_dest_struct pub; /* public fields */
 
-  j_decompress_ptr cinfo;       /* back link saves passing separate parm */
+  j_decompress_ptr cinfo;       /* back link saves passing separate parm */
 
   /* State for packing variable-width codes into a bitstream */
-  int n_bits;                   /* current number of bits/code */
-  int maxcode;                  /* maximum code, given n_bits */
-  INT32 cur_accum;              /* holds bits not yet output */
-  int cur_bits;                 /* # of bits in cur_accum */
+  int n_bits;                   /* current number of bits/code */
+  int maxcode;                  /* maximum code, given n_bits */
+  long cur_accum;               /* holds bits not yet output */
+  int cur_bits;                 /* # of bits in cur_accum */
 
   /* State for GIF code assignment */
-  int ClearCode;                /* clear code (doesn't change) */
-  int EOFCode;                  /* EOF code (ditto) */
-  int code_counter;             /* counts output symbols */
+  int ClearCode;                /* clear code (doesn't change) */
+  int EOFCode;                  /* EOF code (ditto) */
+  int code_counter;             /* counts output symbols */
 
   /* GIF data packet construction buffer */
-  int bytesinpkt;               /* # of bytes in current packet */
-  char packetbuf[256];          /* workspace for accumulating packet */
+  int bytesinpkt;               /* # of bytes in current packet */
+  char packetbuf[256];          /* workspace for accumulating packet */
 
 } gif_dest_struct;
 
-typedef gif_dest_struct * gif_dest_ptr;
+typedef gif_dest_struct *gif_dest_ptr;
 
 /* Largest value that will fit in N bits */
-#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
+#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
 
 
 /*
  * Routines to package finished data bytes into GIF data blocks.
  * A data block consists of a count byte (1..255) and that many data bytes.
  */
 
 LOCAL(void)
 flush_packet (gif_dest_ptr dinfo)
 /* flush any accumulated data */
 {
-  if (dinfo->bytesinpkt > 0) {  /* never write zero-length packet */
+  if (dinfo->bytesinpkt > 0) {  /* never write zero-length packet */
     dinfo->packetbuf[0] = (char) dinfo->bytesinpkt++;
     if (JFWRITE(dinfo->pub.output_file, dinfo->packetbuf, dinfo->bytesinpkt)
-        != (size_t) dinfo->bytesinpkt)
+        != (size_t) dinfo->bytesinpkt)
       ERREXIT(dinfo->cinfo, JERR_FILE_WRITE);
     dinfo->bytesinpkt = 0;
   }
 }
 
 
 /* Add a character to current packet; flush to disk if necessary */
 #define CHAR_OUT(dinfo,c)  \
-        { (dinfo)->packetbuf[++(dinfo)->bytesinpkt] = (char) (c);  \
-            if ((dinfo)->bytesinpkt >= 255)  \
-              flush_packet(dinfo);  \
-        }
+        { (dinfo)->packetbuf[++(dinfo)->bytesinpkt] = (char) (c);  \
+            if ((dinfo)->bytesinpkt >= 255)  \
+              flush_packet(dinfo);  \
+        }
 
 
 /* Routine to convert variable-width codes into a byte stream */
 
 LOCAL(void)
 output (gif_dest_ptr dinfo, int code)
 /* Emit a code of n_bits bits */
 /* Uses cur_accum and cur_bits to reblock into 8-bit bytes */
 {
-  dinfo->cur_accum |= ((INT32) code) << dinfo->cur_bits;
+  dinfo->cur_accum |= ((long) code) << dinfo->cur_bits;
   dinfo->cur_bits += dinfo->n_bits;
 
   while (dinfo->cur_bits >= 8) {
     CHAR_OUT(dinfo, dinfo->cur_accum & 0xFF);
     dinfo->cur_accum >>= 8;
     dinfo->cur_bits -= 8;
   }
 }
 
 
@@ skipping 46 matching lines @@
 {
   /* Output the given pixel value as a symbol. */
   output(dinfo, c);
   /* Issue Clear codes often enough to keep the reader from ratcheting up
    * its symbol size.
    */
   if (dinfo->code_counter < dinfo->maxcode) {
     dinfo->code_counter++;
   } else {
     output(dinfo, dinfo->ClearCode);
-    dinfo->code_counter = dinfo->ClearCode + 2; /* reset the counter */
+    dinfo->code_counter = dinfo->ClearCode + 2; /* reset the counter */
   }
 }
 
 
 LOCAL(void)
 compress_term (gif_dest_ptr dinfo)
 /* Clean up at end */
 {
   /* Send an EOF code */
   output(dinfo, dinfo->EOFCode);
@@ skipping 24 matching lines @@
 {
   putc(val, dinfo->pub.output_file);
   putc(val, dinfo->pub.output_file);
   putc(val, dinfo->pub.output_file);
 }
 
 
 LOCAL(void)
 emit_header (gif_dest_ptr dinfo, int num_colors, JSAMPARRAY colormap)
 /* Output the GIF file header, including color map */
-/* If colormap==NULL, synthesize a gray-scale colormap */
+/* If colormap==NULL, synthesize a grayscale colormap */
 {
   int BitsPerPixel, ColorMapSize, InitCodeSize, FlagByte;
   int cshift = dinfo->cinfo->data_precision - 8;
   int i;
 
   if (num_colors > 256)
     ERREXIT1(dinfo->cinfo, JERR_TOO_MANY_COLORS, num_colors);
   /* Compute bits/pixel and related values */
   BitsPerPixel = 1;
   while (num_colors > (1 << BitsPerPixel))
     BitsPerPixel++;
   ColorMapSize = 1 << BitsPerPixel;
   if (BitsPerPixel <= 1)
     InitCodeSize = 2;
   else
     InitCodeSize = BitsPerPixel;
   /*
    * Write the GIF header.
    * Note that we generate a plain GIF87 header for maximum compatibility.
    */
   putc('G', dinfo->pub.output_file);
   putc('I', dinfo->pub.output_file);
   putc('F', dinfo->pub.output_file);
   putc('8', dinfo->pub.output_file);
   putc('7', dinfo->pub.output_file);
   putc('a', dinfo->pub.output_file);
   /* Write the Logical Screen Descriptor */
   put_word(dinfo, (unsigned int) dinfo->cinfo->output_width);
   put_word(dinfo, (unsigned int) dinfo->cinfo->output_height);
-  FlagByte = 0x80;              /* Yes, there is a global color table */
+  FlagByte = 0x80;              /* Yes, there is a global color table */
   FlagByte |= (BitsPerPixel-1) << 4; /* color resolution */
-  FlagByte |= (BitsPerPixel-1); /* size of global color table */
+  FlagByte |= (BitsPerPixel-1); /* size of global color table */
   putc(FlagByte, dinfo->pub.output_file);
   putc(0, dinfo->pub.output_file); /* Background color index */
   putc(0, dinfo->pub.output_file); /* Reserved (aspect ratio in GIF89) */
   /* Write the Global Color Map */
   /* If the color map is more than 8 bits precision, */
   /* we reduce it to 8 bits by shifting */
   for (i=0; i < ColorMapSize; i++) {
     if (i < num_colors) {
       if (colormap != NULL) {
-        if (dinfo->cinfo->out_color_space == JCS_RGB) {
-          /* Normal case: RGB color map */
-          putc(GETJSAMPLE(colormap[0][i]) >> cshift, dinfo->pub.output_file);
-          putc(GETJSAMPLE(colormap[1][i]) >> cshift, dinfo->pub.output_file);
-          putc(GETJSAMPLE(colormap[2][i]) >> cshift, dinfo->pub.output_file);
-        } else {
-          /* Grayscale "color map": possible if quantizing grayscale image */
-          put_3bytes(dinfo, GETJSAMPLE(colormap[0][i]) >> cshift);
-        }
+        if (dinfo->cinfo->out_color_space == JCS_RGB) {
+          /* Normal case: RGB color map */
+          putc(GETJSAMPLE(colormap[0][i]) >> cshift, dinfo->pub.output_file);
+          putc(GETJSAMPLE(colormap[1][i]) >> cshift, dinfo->pub.output_file);
+          putc(GETJSAMPLE(colormap[2][i]) >> cshift, dinfo->pub.output_file);
+        } else {
+          /* Grayscale "color map": possible if quantizing grayscale image */
+          put_3bytes(dinfo, GETJSAMPLE(colormap[0][i]) >> cshift);
+        }
       } else {
-        /* Create a gray-scale map of num_colors values, range 0..255 */
-        put_3bytes(dinfo, (i * 255 + (num_colors-1)/2) / (num_colors-1));
+        /* Create a grayscale map of num_colors values, range 0..255 */
+        put_3bytes(dinfo, (i * 255 + (num_colors-1)/2) / (num_colors-1));
       }
     } else {
       /* fill out the map to a power of 2 */
       put_3bytes(dinfo, 0);
     }
   }
   /* Write image separator and Image Descriptor */
   putc(',', dinfo->pub.output_file); /* separator */
-  put_word(dinfo, 0);           /* left/top offset */
+  put_word(dinfo, 0);           /* left/top offset */
   put_word(dinfo, 0);
   put_word(dinfo, (unsigned int) dinfo->cinfo->output_width); /* image size */
   put_word(dinfo, (unsigned int) dinfo->cinfo->output_height);
   /* flag byte: not interlaced, no local color map */
   putc(0x00, dinfo->pub.output_file);
   /* Write Initial Code Size byte */
   putc(InitCodeSize, dinfo->pub.output_file);
 
   /* Initialize for "compression" of image data */
   compress_init(dinfo, InitCodeSize+1);
@@ skipping 16 matching lines @@
 }
 
 
 /*
  * Write some pixel data.
  * In this module rows_supplied will always be 1.
  */
 
 METHODDEF(void)
 put_pixel_rows (j_decompress_ptr cinfo, djpeg_dest_ptr dinfo,
-                JDIMENSION rows_supplied)
+                JDIMENSION rows_supplied)
 {
   gif_dest_ptr dest = (gif_dest_ptr) dinfo;
   register JSAMPROW ptr;
   register JDIMENSION col;
 
   ptr = dest->pub.buffer[0];
   for (col = cinfo->output_width; col > 0; col--) {
     compress_pixel(dest, GETJSAMPLE(*ptr++));
   }
 }
@@ skipping 26 matching lines @@
  */
 
 GLOBAL(djpeg_dest_ptr)
 jinit_write_gif (j_decompress_ptr cinfo)
 {
   gif_dest_ptr dest;
 
   /* Create module interface object, fill in method pointers */
   dest = (gif_dest_ptr)
       (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
-                                  SIZEOF(gif_dest_struct));
-  dest->cinfo = cinfo;          /* make back link for subroutines */
+                                  sizeof(gif_dest_struct));
+  dest->cinfo = cinfo;          /* make back link for subroutines */
   dest->pub.start_output = start_output_gif;
   dest->pub.put_pixel_rows = put_pixel_rows;
   dest->pub.finish_output = finish_output_gif;
 
   if (cinfo->out_color_space != JCS_GRAYSCALE &&
       cinfo->out_color_space != JCS_RGB)
     ERREXIT(cinfo, JERR_GIF_COLORSPACE);
 
   /* Force quantization if color or if > 8 bits input */
   if (cinfo->out_color_space != JCS_GRAYSCALE || cinfo->data_precision > 8) {
@@ skipping 11 matching lines @@
 
   /* Create decompressor output buffer. */
   dest->pub.buffer = (*cinfo->mem->alloc_sarray)
     ((j_common_ptr) cinfo, JPOOL_IMAGE, cinfo->output_width, (JDIMENSION) 1);
   dest->pub.buffer_height = 1;
 
   return (djpeg_dest_ptr) dest;
 }
 
 #endif /* GIF_SUPPORTED */