    /*
     * 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.
     *
     * 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 */

    #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
    ** implied warranty.
    */

    /*
     * Add a (potentially) new color to the color map.
     */

    LOCAL(void)
    add_map_entry (j_decompress_ptr cinfo, int R, int G, int B)
    {
      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 */
      }

      /* 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)
    {
      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);
      }

      /* Verify GIF Header */
      if (header[1] != 'I' || header[2] != 'F')
        ERREXIT(cinfo, JERR_BAD_CMAP_FILE);

      /* There must be a global color map. */
      if ((header[10] & 0x80) == 0)
        ERREXIT(cinfo, JERR_BAD_CMAP_FILE);

      /* 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));
      }
    }

    /* Support routines for reading PPM */

    LOCAL(int)
    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 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)
    {
      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 */

      /* 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 */
        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);
          }
        }
        break;

      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);
          }
        }
        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)
    {
      /* 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 */