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

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