workbench/libs/jpeg/rdcolmap.c

   1 /*
   2  * rdcolmap.c
   3  *
   4  * Copyright (C) 1994-1996, Thomas G. Lane.
   5  * This file is part of the Independent JPEG Group's software.
   6  * For conditions of distribution and use, see the accompanying README file.
   7  *
   8  * This file implements djpeg's "-map file" switch.  It reads a source image
   9  * and constructs a colormap to be supplied to the JPEG decompressor.
  10  *
  11  * Currently, these file formats are supported for the map file:
  12  *   GIF: the contents of the GIF's global colormap are used.
  13  *   PPM (either text or raw flavor): the entire file is read and
  14  *      each unique pixel value is entered in the map.
  15  * Note that reading a large PPM file will be horrendously slow.
  16  * Typically, a PPM-format map file should contain just one pixel
  17  * of each desired color.  Such a file can be extracted from an
  18  * ordinary image PPM file with ppmtomap(1).
  19  *
  20  * Rescaling a PPM that has a maxval unequal to MAXJSAMPLE is not
  21  * currently implemented.
  22  */
  23
  24 #include "cdjpeg.h"             /* Common decls for cjpeg/djpeg applications */
  25
  26 #ifdef QUANT_2PASS_SUPPORTED    /* otherwise can't quantize to supplied map */
  27
  28 /* Portions of this code are based on the PBMPLUS library, which is:
  29 **
  30 ** Copyright (C) 1988 by Jef Poskanzer.
  31 **
  32 ** Permission to use, copy, modify, and distribute this software and its
  33 ** documentation for any purpose and without fee is hereby granted, provided
  34 ** that the above copyright notice appear in all copies and that both that
  35 ** copyright notice and this permission notice appear in supporting
  36 ** documentation.  This software is provided "as is" without express or
  37 ** implied warranty.
  38 */
  39
  40
  41 /*
  42  * Add a (potentially) new color to the color map.
  43  */
  44
  45 LOCAL(void)
  46 add_map_entry (j_decompress_ptr cinfo, int R, int G, int B)
  47 {
  48   JSAMPROW colormap0 = cinfo->colormap[0];
  49   JSAMPROW colormap1 = cinfo->colormap[1];
  50   JSAMPROW colormap2 = cinfo->colormap[2];
  51   int ncolors = cinfo->actual_number_of_colors;
  52   int index;
  53
  54   /* Check for duplicate color. */
  55   for (index = 0; index < ncolors; index++) {
  56     if (GETJSAMPLE(colormap0[index]) == R &&
  57         GETJSAMPLE(colormap1[index]) == G &&
  58         GETJSAMPLE(colormap2[index]) == B)
  59       return;                   /* color is already in map */
  60   }
  61
  62   /* Check for map overflow. */
  63   if (ncolors >= (MAXJSAMPLE+1))
  64     ERREXIT1(cinfo, JERR_QUANT_MANY_COLORS, (MAXJSAMPLE+1));
  65
  66   /* OK, add color to map. */
  67   colormap0[ncolors] = (JSAMPLE) R;
  68   colormap1[ncolors] = (JSAMPLE) G;
  69   colormap2[ncolors] = (JSAMPLE) B;
  70   cinfo->actual_number_of_colors++;
  71 }
  72
  73
  74 /*
  75  * Extract color map from a GIF file.
  76  */
  77
  78 LOCAL(void)
  79 read_gif_map (j_decompress_ptr cinfo, FILE * infile)
  80 {
  81   int header[13];
  82   int i, colormaplen;
  83   int R, G, B;
  84
  85   /* Initial 'G' has already been read by read_color_map */
  86   /* Read the rest of the GIF header and logical screen descriptor */
  87   for (i = 1; i < 13; i++) {
  88     if ((header[i] = getc(infile)) == EOF)
  89       ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
  90   }
  91
  92   /* Verify GIF Header */
  93   if (header[1] != 'I' || header[2] != 'F')
  94     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
  95
  96   /* There must be a global color map. */
  97   if ((header[10] & 0x80) == 0)
  98     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
  99
 100   /* OK, fetch it. */
 101   colormaplen = 2 << (header[10] & 0x07);
 102
 103   for (i = 0; i < colormaplen; i++) {
 104     R = getc(infile);
 105     G = getc(infile);
 106     B = getc(infile);
 107     if (R == EOF || G == EOF || B == EOF)
 108       ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 109     add_map_entry(cinfo,
 110                   R << (BITS_IN_JSAMPLE-8),
 111                   G << (BITS_IN_JSAMPLE-8),
 112                   B << (BITS_IN_JSAMPLE-8));
 113   }
 114 }
 115
 116
 117 /* Support routines for reading PPM */
 118
 119
 120 LOCAL(int)
 121 pbm_getc (FILE * infile)
 122 /* Read next char, skipping over any comments */
 123 /* A comment/newline sequence is returned as a newline */
 124 {
 125   register int ch;
 126
 127   ch = getc(infile);
 128   if (ch == '#') {
 129     do {
 130       ch = getc(infile);
 131     } while (ch != '\n' && ch != EOF);
 132   }
 133   return ch;
 134 }
 135
 136
 137 LOCAL(unsigned int)
 138 read_pbm_integer (j_decompress_ptr cinfo, FILE * infile)
 139 /* Read an unsigned decimal integer from the PPM file */
 140 /* Swallows one trailing character after the integer */
 141 /* Note that on a 16-bit-int machine, only values up to 64k can be read. */
 142 /* This should not be a problem in practice. */
 143 {
 144   register int ch;
 145   register unsigned int val;
 146
 147   /* Skip any leading whitespace */
 148   do {
 149     ch = pbm_getc(infile);
 150     if (ch == EOF)
 151       ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 152   } while (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r');
 153
 154   if (ch < '0' || ch > '9')
 155     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 156
 157   val = ch - '0';
 158   while ((ch = pbm_getc(infile)) >= '0' && ch <= '9') {
 159     val *= 10;
 160     val += ch - '0';
 161   }
 162   return val;
 163 }
 164
 165
 166 /*
 167  * Extract color map from a PPM file.
 168  */
 169
 170 LOCAL(void)
 171 read_ppm_map (j_decompress_ptr cinfo, FILE * infile)
 172 {
 173   int c;
 174   unsigned int w, h, maxval, row, col;
 175   int R, G, B;
 176
 177   /* Initial 'P' has already been read by read_color_map */
 178   c = getc(infile);             /* save format discriminator for a sec */
 179
 180   /* while we fetch the remaining header info */
 181   w = read_pbm_integer(cinfo, infile);
 182   h = read_pbm_integer(cinfo, infile);
 183   maxval = read_pbm_integer(cinfo, infile);
 184
 185   if (w <= 0 || h <= 0 || maxval <= 0) /* error check */
 186     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 187
 188   /* For now, we don't support rescaling from an unusual maxval. */
 189   if (maxval != (unsigned int) MAXJSAMPLE)
 190     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 191
 192   switch (c) {
 193   case '3':                     /* it's a text-format PPM file */
 194     for (row = 0; row < h; row++) {
 195       for (col = 0; col < w; col++) {
 196         R = read_pbm_integer(cinfo, infile);
 197         G = read_pbm_integer(cinfo, infile);
 198         B = read_pbm_integer(cinfo, infile);
 199         add_map_entry(cinfo, R, G, B);
 200       }
 201     }
 202     break;
 203
 204   case '6':                     /* it's a raw-format PPM file */
 205     for (row = 0; row < h; row++) {
 206       for (col = 0; col < w; col++) {
 207         R = getc(infile);
 208         G = getc(infile);
 209         B = getc(infile);
 210         if (R == EOF || G == EOF || B == EOF)
 211           ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 212         add_map_entry(cinfo, R, G, B);
 213       }
 214     }
 215     break;
 216
 217   default:
 218     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 219     break;
 220   }
 221 }
 222
 223
 224 /*
 225  * Main entry point from djpeg.c.
 226  *  Input: opened input file (from file name argument on command line).
 227  *  Output: colormap and actual_number_of_colors fields are set in cinfo.
 228  */
 229
 230 GLOBAL(void)
 231 read_color_map (j_decompress_ptr cinfo, FILE * infile)
 232 {
 233   /* Allocate space for a color map of maximum supported size. */
 234   cinfo->colormap = (*cinfo->mem->alloc_sarray)
 235     ((j_common_ptr) cinfo, JPOOL_IMAGE,
 236      (JDIMENSION) (MAXJSAMPLE+1), (JDIMENSION) 3);
 237   cinfo->actual_number_of_colors = 0; /* initialize map to empty */
 238
 239   /* Read first byte to determine file format */
 240   switch (getc(infile)) {
 241   case 'G':
 242     read_gif_map(cinfo, infile);
 243     break;
 244   case 'P':
 245     read_ppm_map(cinfo, infile);
 246     break;
 247   default:
 248     ERREXIT(cinfo, JERR_BAD_CMAP_FILE);
 249     break;
 250   }
 251 }
 252
 253 #endif /* QUANT_2PASS_SUPPORTED */