Update to libjpeg_turbo 1.4.90

rdcolmap.c

 /*
  * rdcolmap.c
  *
  * Copyright (C) 1994-1996, 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.
+ * For conditions of distribution and use, see the accompanying README.ijg
+ * file.
  *
  * This file implements djpeg's "-map file" switch.  It reads a source image
  * and constructs a colormap to be supplied to the JPEG decompressor.
  *
  * Currently, these file formats are supported for the map file:
  *   GIF: the contents of the GIF's global colormap are used.
  *   PPM (either text or raw flavor): the entire file is read and
  *      each unique pixel value is entered in the map.
  * Note that reading a large PPM file will be horrendously slow.
  * Typically, a PPM-format map file should contain just one pixel
  * of each desired color.  Such a file can be extracted from an
  * ordinary image PPM file with ppmtomap(1).
  *
  * Rescaling a PPM that has a maxval unequal to MAXJSAMPLE is not
  * currently implemented.
  */
 
-#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
+#include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
 
-#ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
+#ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
 
 /* Portions of this code are based on the PBMPLUS library, which is:
 **
 ** Copyright (C) 1988 by Jef Poskanzer.
 **
 ** Permission to use, copy, modify, and distribute this software and its
 ** documentation for any purpose and without fee is hereby granted, provided
 ** that the above copyright notice appear in all copies and that both that
 ** copyright notice and this permission notice appear in supporting
 ** documentation.  This software is provided "as is" without express or
@@ skipping 10 matching lines @@
 {
   JSAMPROW colormap0 = cinfo->colormap[0];
   JSAMPROW colormap1 = cinfo->colormap[1];
   JSAMPROW colormap2 = cinfo->colormap[2];
   int ncolors = cinfo->actual_number_of_colors;
   int index;
 
   /* Check for duplicate color. */
   for (index = 0; index < ncolors; index++) {
     if (GETJSAMPLE(colormap0[index]) == R &&
-        GETJSAMPLE(colormap1[index]) == G &&
-        GETJSAMPLE(colormap2[index]) == B)
-      return;                   /* color is already in map */
+        GETJSAMPLE(colormap1[index]) == G &&
+        GETJSAMPLE(colormap2[index]) == B)
+      return;                   /* color is already in map */
   }
 
   /* Check for map overflow. */
   if (ncolors >= (MAXJSAMPLE+1))
     ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE+1));
 
   /* OK, add color to map. */
   colormap0[ncolors] = (JSAMPLE) R;
   colormap1[ncolors] = (JSAMPLE) G;
   colormap2[ncolors] = (JSAMPLE) B;
   cinfo->actual_number_of_colors++;
 }
 
 
 /*
  * Extract color map from a GIF file.
  */
 
 LOCAL(void)
-read_gif_map (j_decompress_ptr cinfo, FILE * infile)
+read_gif_map (j_decompress_ptr cinfo, FILE *infile)
 {
   int header[13];
   int i, colormaplen;
   int R, G, B;
 
   /* Initial 'G' has already been read by read_color_map */
   /* Read the rest of the GIF header and logical screen descriptor */
   for (i = 1; i < 13; i++) {
     if ((header[i] = getc(infile)) == EOF)
       ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
@@ skipping 10 matching lines @@
   /* OK, fetch it. */
   colormaplen = 2 << (header[10] & 0x07);
 
   for (i = 0; i < colormaplen; i++) {
     R = getc(infile);
     G = getc(infile);
     B = getc(infile);
     if (R == EOF || G == EOF || B == EOF)
       ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
     add_map_entry(cinfo,
-                  R << (BITS_IN_JSAMPLE-8),
-                  G << (BITS_IN_JSAMPLE-8),
-                  B << (BITS_IN_JSAMPLE-8));
+                  R << (BITS_IN_JSAMPLE-8),
+                  G << (BITS_IN_JSAMPLE-8),
+                  B << (BITS_IN_JSAMPLE-8));
   }
 }
 
 
 /* Support routines for reading PPM */
 
 
 LOCAL(int)
-pbm_getc (FILE * infile)
+pbm_getc (FILE *infile)
 /* Read next char, skipping over any comments */
 /* A comment/newline sequence is returned as a newline */
 {
   register int ch;
-  
+
   ch = getc(infile);
   if (ch == '#') {
     do {
       ch = getc(infile);
     } while (ch != '\n' && ch != EOF);
   }
   return ch;
 }
 
 
 LOCAL(unsigned int)
-read_pbm_integer (j_decompress_ptr cinfo, FILE * infile)
+read_pbm_integer (j_decompress_ptr cinfo, FILE *infile)
 /* Read an unsigned decimal integer from the PPM file */
 /* Swallows one trailing character after the integer */
 /* Note that on a 16-bit-int machine, only values up to 64k can be read. */
 /* This should not be a problem in practice. */
 {
   register int ch;
   register unsigned int val;
-  
+
   /* Skip any leading whitespace */
   do {
     ch = pbm_getc(infile);
     if (ch == EOF)
       ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
   } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
-  
+
   if (ch < '0' || ch > '9')
     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
-  
+
   val = ch - '0';
   while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
     val *= 10;
     val += ch - '0';
   }
   return val;
 }
 
 
 /*
  * Extract color map from a PPM file.
  */
 
 LOCAL(void)
-read_ppm_map (j_decompress_ptr cinfo, FILE * infile)
+read_ppm_map (j_decompress_ptr cinfo, FILE *infile)
 {
   int c;
   unsigned int w, h, maxval, row, col;
   int R, G, B;
 
   /* Initial 'P' has already been read by read_color_map */
-  c = getc(infile);             /* save format discriminator for a sec */
+  c = getc(infile);             /* save format discriminator for a sec */
 
   /* while we fetch the remaining header info */
   w = read_pbm_integer(cinfo, infile);
   h = read_pbm_integer(cinfo, infile);
   maxval = read_pbm_integer(cinfo, infile);
 
   if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
   /* For now, we don't support rescaling from an unusual maxval. */
   if (maxval != (unsigned int) MAXJSAMPLE)
     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 
   switch (c) {
-  case '3':                     /* it's a text-format PPM file */
+  case '3':                     /* it's a text-format PPM file */
     for (row = 0; row < h; row++) {
       for (col = 0; col < w; col++) {
-        R = read_pbm_integer(cinfo, infile);
-        G = read_pbm_integer(cinfo, infile);
-        B = read_pbm_integer(cinfo, infile);
-        add_map_entry(cinfo, R, G, B);
+        R = read_pbm_integer(cinfo, infile);
+        G = read_pbm_integer(cinfo, infile);
+        B = read_pbm_integer(cinfo, infile);
+        add_map_entry(cinfo, R, G, B);
       }
     }
     break;
 
-  case '6':                     /* it's a raw-format PPM file */
+  case '6':                     /* it's a raw-format PPM file */
     for (row = 0; row < h; row++) {
       for (col = 0; col < w; col++) {
-        R = getc(infile);
-        G = getc(infile);
-        B = getc(infile);
-        if (R == EOF || G == EOF || B == EOF)
-          ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
-        add_map_entry(cinfo, R, G, B);
+        R = getc(infile);
+        G = getc(infile);
+        B = getc(infile);
+        if (R == EOF || G == EOF || B == EOF)
+          ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
+        add_map_entry(cinfo, R, G, B);
       }
     }
     break;
 
   default:
     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
     break;
   }
 }
 
 
 /*
  * Main entry point from djpeg.c.
  *  Input: opened input file (from file name argument on command line).
  *  Output: colormap and actual_number_of_colors fields are set in cinfo.
  */
 
 GLOBAL(void)
-read_color_map (j_decompress_ptr cinfo, FILE * infile)
+read_color_map (j_decompress_ptr cinfo, FILE *infile)
 {
   /* Allocate space for a color map of maximum supported size. */
   cinfo->colormap = (*cinfo->mem->alloc_sarray)
     ((j_common_ptr) cinfo, JPOOL_IMAGE,
      (JDIMENSION) (MAXJSAMPLE+1), (JDIMENSION) 3);
   cinfo->actual_number_of_colors = 0; /* initialize map to empty */
 
   /* Read first byte to determine file format */
   switch (getc(infile)) {
   case 'G':
     read_gif_map(cinfo, infile);
     break;
   case 'P':
     read_ppm_map(cinfo, infile);
     break;
   default:
     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
     break;
   }
 }
 
 #endif /* QUANT_2PASS_SUPPORTED */