/* ppmtoxpm.c - read a portable pixmap and produce a (version 3) X11 pixmap
**
** Copyright (C) 1990 by Mark W. Snitily
**
** 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.
**
** This tool was developed for Schlumberger Technologies, ATE Division, and
** with their permission is being made available to the public with the above
** copyright notice and permission notice.
**
** Upgraded to XPM2 by
**   Paul Breslaw, Mecasoft SA, Zurich, Switzerland (paul@mecazh.uu.ch)
**   Thu Nov  8 16:01:17 1990
**
** Upgraded to XPM version 3 by
**   Arnaud Le Hors (lehors@mirsa.inria.fr)
**   Tue Apr 9 1991
**
** Rainer Sinkwitz sinkwitz@ifi.unizh.ch - 21 Nov 91:
**  - Bug fix, should should malloc space for rgbn[j].name+1 in line 441
**    caused segmentation faults
**    
**  - lowercase conversion of RGB names def'ed out,
**    considered harmful.
*/

#include "ppm.h"
#include "ppmcmap.h"

/* Max number of colors allowed in ppm input. */
#define MAXCOLORS 256

/* Max number of rgb mnemonics allowed in rgb text file. */
#define MAX_RGBNAMES 1024

/* Lower bound and upper bound of character-pixels printed in XPM output.
** Be careful, don't want the character '"' in this range. */
/*#define LOW_CHAR  '#'  <-- minimum ascii character allowed */
/*#define HIGH_CHAR '~'  <-- maximum ascii character allowed */
#define LOW_CHAR  '`'
#define HIGH_CHAR 'z'

#define max(a,b) ((a) > (b) ? (a) : (b))


typedef struct {			/* rgb values and ascii names (from
					 * rgb text file) */
    int r, g, b;			/* rgb values, range of 0 -> 65535 */
    char* name;				/* color mnemonic of rgb value */
    } rgb_names;

typedef struct {			/* character-pixel mapping */
    char* cixel;			/* character string printed for
					 * pixel */
    char* rgbname;			/* ascii rgb color, either color
					 * mnemonic or #rgb value */
    } cixel_map;

/* Prototypes/forward reference. */
static void read_rgb_names( char*, rgb_names*, int* );
static char* gen_numstr( int, int, int );
static void gen_cmap( colorhist_vector, int, pixval, int, rgb_names*, int, cixel_map*, int* );

pixel** pixels;

int
main( int argc, char* argv[] )
    {
    FILE* ifd;
    register pixel* pP;
    int argn, rows, cols, ncolors, row, col, i;
    pixval maxval;			/* pixval == unsigned char or
					 * unsigned short */
    colorhash_table cht;
    colorhist_vector chv;

    /* Used for rgb value -> rgb mnemonic mapping. */
    int map_rgb_names = 0;
    rgb_names *rgbn;    /* rgb_names rgbn[MAX_RGBNAMES]; */
    int rgbn_max;

    /* Used for rgb value -> character-pixel string mapping. */
    cixel_map* cmap;    /* cixel_map cmap[MAXCOLORS]; */
    int charspp;			/* chars per pixel */

    char out_name[100], rgb_fname[100];
    char* cp;
    char* usage = "[-name <xpm-name>] [-rgb <rgb-textfile>] [ppmfile]";

    ppm_init( &argc, argv );
    out_name[0] = rgb_fname[0] = '\0';

    argn = 1;

    /* Check for command line options. */
    while ( argn < argc && argv[argn][0] == '-' )
	{
	/* Case "-", use stdin for input. */
	if ( argv[argn][1] == '\0' )
	    break;

	/* Case "-name <xpm-filename>", get output filename. */
	if ( strncmp( argv[argn], "-name", max( strlen( argv[argn] ), 2 ) ) == 0 )
	    {
	    ++argn;
	    if ( argn == argc || sscanf( argv[argn], "%s", out_name ) != 1 )
		pm_usage( usage );
	    }
	/* Case "-rgb <rgb-filename>", get rgb mnemonics filename. */
	else if ( strncmp( argv[argn], "-rgb", max( strlen( argv[argn] ), 2 ) ) == 0 )
	    {
	    ++argn;
	    if ( argn == argc || sscanf( argv[argn], "%s", rgb_fname ) != 1 )
		pm_usage( usage );
	    map_rgb_names = 1;
	    }
	/* Nothing else allowed... */
	else
	    pm_usage( usage );

	++argn;
	}

    /* Input file specified, open it and set output filename if necessary. */
    if ( argn < argc )
	{
	/* Open the input file. */
	ifd = pm_openr( argv[argn] );

	/* If output filename not specified, use input filename as default. */
	if ( out_name[0] == '\0' )
	    {
	    strcpy( out_name, argv[argn] );
	    if ( ( cp = strchr( out_name, '.' ) ) != (char*) 0 )
		*cp = '\0';		/* remove extension */
	    }

	/* If (1) input file was specified as "-" we're using stdin, or (2)
	** output filename was specified as "-", set output filename to the
	** default. 
	*/
	if ( ! strcmp( out_name, "-" ) )
	    strcpy( out_name, "noname" );

	++argn;
	}
    /* No input file specified.  Using stdin so set default output filename. */
    else
	{
	ifd = stdin;
	if ( out_name[0] == '\0' )
	    strcpy( out_name, "noname" );
	}

    /* Only 0 or 1 input files allowed. */
    if ( argn != argc )
	pm_usage( usage );

    /* "maxval" is the largest value that can be be found in the ppm file.
    ** All pixel components are relative to this value. 
    */
    pixels = ppm_readppm( ifd, &cols, &rows, &maxval );
    pm_closer( ifd );

    /* Figure out the colormap. */
    fprintf( stderr, " (Computing colormap...");
    fflush( stderr );
    chv = ppm_computecolorhist( pixels, cols, rows, MAXCOLORS, &ncolors );
    if ( chv == (colorhist_vector) 0 )
	pm_error(
	    "too many colors - try running the pixmap through 'ppmquant 256'" );
    fprintf( stderr, "  Done.  %d colors found.)\n", ncolors );

    /* Make a hash table for fast color lookup. */
    cht = ppm_colorhisttocolorhash( chv, ncolors );

    /* If a rgb text file was specified, read in the rgb mnemonics. Does not
    ** return if fatal error occurs. 
    */
    rgbn = (rgb_names*) malloc( MAX_RGBNAMES * sizeof(rgb_names) );
    if ( rgbn == (rgb_names*) 0 )
	pm_error( "out of memory" );

    if ( map_rgb_names )
	read_rgb_names( rgb_fname, rgbn, &rgbn_max );

    cmap = (cixel_map*) malloc( ncolors * sizeof(cixel_map) );
    if (cmap == (cixel_map *) NULL)
	pm_error( "out of memory" );
 
    /* Now generate the character-pixel colormap table. */
    gen_cmap(
	chv, ncolors, maxval, map_rgb_names, rgbn, rgbn_max, cmap, &charspp );

    /* Write out the XPM file. */

    printf( "/* XPM */\n" );
    printf( "static char *%s[] = {\n", out_name );
    printf( "/* width height ncolors chars_per_pixel */\n" );
    printf( "\"%d %d %d %d\",\n", cols, rows, ncolors, charspp );
    printf( "/* colors */\n" );
    for ( i = 0; i < ncolors; ++i )
	printf( "\"%s c %s\",\n", cmap[i].cixel, cmap[i].rgbname );
    printf( "/* pixels */\n" );
    for ( row = 0; row < rows; ++row )
	{
	printf("\"");
	for ( col = 0, pP = pixels[row]; col < cols; ++col, ++pP )
	    printf( "%s", cmap[ppm_lookupcolor( cht, pP )].cixel );
	printf( "\"%s\n", ( row == ( rows - 1 ) ? "" : "," ) );
	}
    printf( "};\n" );

    exit( 0 );
    }

/* This routine reads a rgb text file.  It stores the rgb values (0->65535)
** and the rgb mnemonics (malloc'ed) into the "rgbn" array.  Returns the
** number of entries stored in "rgbn_max".
*/
static void
read_rgb_names( char* rgb_fname, rgb_names* rgbn, int* rgbn_max )
    {
    FILE* rgbf;
    int i, items, red, green, blue;
    char line[512], name[512];
    char* rgbname;
#ifdef NAMESLOWCASE
    char* n;
    char* m;
#endif

    /* Open the rgb text file.  Abort if error. */
    if ( ( rgbf = fopen( rgb_fname, "r" ) ) == (FILE*) 0 )
	pm_error( "error opening rgb text file \"%s\"", rgb_fname );

    /* Loop reading each line in the file. */
    for ( i = 0; fgets( line, sizeof(line), rgbf) != (char*) 0; ++i)
	{
	/* Quit if rgb text file is too large. */
	if ( i == MAX_RGBNAMES )
	    {
	    pm_message(
	        "too many entries in rgb text file, truncated to %d entries.\n",
		MAX_RGBNAMES );
	    break;
	    }
	/* Read the line.  Skip if bad. */
	items = sscanf( line, "%d %d %d %[^\n]\n", &red, &green, &blue, name );
	if ( items != 4 )
	    {
	    pm_message( "rgb text file syntax error on line %d\n", i + 1 );
	    --i;
	    continue;
	    }
	/* Make sure rgb values are within 0->255 range.  Skip if bad. */
	if ( red < 0 || red > 0xFF ||
	     green < 0 || green > 0xFF ||
	     blue < 0 || blue > 0xFF)
	    {
	    pm_message(
		"rgb value for \"%s\" out of range, ignoring it\n", name);
	    --i;
	    continue;
	    }
	/* Allocate memory for ascii name.  Abort if error. */
	rgbname = (char*) malloc( strlen( name ) + 1 );
	if ( rgbname == (char*) 0 )
	    pm_error( "out of memory allocating rgb name" );
	    
#ifdef NAMESLOWCASE
	/* Copy string to ascii name and lowercase it. */
	for ( n = name, m = rgbname; *n; ++n )
	    *m++ = isupper( *n ) ? tolower( *n ) : *n;
	*m = '\0';
#else
	strcpy( rgbname, name );
#endif

	/* Save the rgb values and ascii name in the array. */
	rgbn[i].r = red << 8;
	rgbn[i].g = green << 8;
	rgbn[i].b = blue << 8;
	rgbn[i].name = rgbname;
	}

    /* Return the max number of rgb names. */
    *rgbn_max = i - 1;

    fclose( rgbf );
    }

/* Given a number and a base, (base == HIGH_CHAR-LOW_CHAR+1), this routine
** prints the number into a malloc'ed string and returns it.  The length of
** the string is specified by "digits".  The ascii characters of the printed
** number range from LOW_CHAR to HIGH_CHAR.  The string is LOW_CHAR filled,
** (e.g. if LOW_CHAR==0, HIGH_CHAR==1, digits==5, i=3, routine would return
** the malloc'ed string "00011").
*/
static char*
gen_numstr( int i, int base, int digits )
    {
    char* str;
    char* p;
    int d;

    /* Allocate memory for printed number.  Abort if error. */
    str = (char*) malloc( digits + 1 );
    if ( str == (char*) 0 )
	pm_error( "out of memory" );

    /* Generate characters starting with least significant digit. */
    p = str + digits;
    *p-- = '\0';			/* nul terminate string */
    while ( p >= str )
	{
	d = i % base;
	i /= base;
	*p-- = (char) ( (int) LOW_CHAR + d );
	}

    return str;
    }

/* This routine generates the character-pixel colormap table. */
static void
gen_cmap(
/* input: */
    colorhist_vector chv,		/* contains rgb values for colormap */
    int ncolors,			/* number of entries in colormap */
    pixval maxval,			/* largest color value, all rgb
					 * values relative to this, (pixval
					 * == unsigned short) */
    int map_rgb_names,			/* == 1 if mapping rgb values to rgb
					 * mnemonics */
    rgb_names* rgbn,                    /* rgb mnemonics from rgb text file */
    int rgbn_max,			/* number of rgb mnemonics in table */
/* output: */
    cixel_map* cmap,                    /* pixel strings and ascii rgb
					 * colors */
    int* charspp )			/* characters per pixel */
    {
    int i, j, base, cpp, mval, red, green, blue, r, g, b, matched;
    char* str;

    /* Figure out how many characters per pixel we'll be using.  Don't want
    ** to be forced to link with libm.a, so using a division loop rather
    ** than a log function. 
    */
    base = (int) HIGH_CHAR - (int) LOW_CHAR + 1;
    for ( cpp = 0, j = ncolors; j; ++cpp )
	j /= base;
    *charspp = cpp;

    /* Determine how many hex digits we'll be normalizing to if the rgb
    ** value doesn't match a color mnemonic. 
    */
    mval = (int) maxval;
    if ( mval <= 0x000F )
	mval = 0x000F;
    else if ( mval <= 0x00FF )
	mval = 0x00FF;
    else if ( mval <= 0x0FFF )
	mval = 0x0FFF;
    else
	mval = 0xFFFF;

    /* Generate the character-pixel string and the rgb name for each
    ** colormap entry. 
    */
    for ( i = 0; i < ncolors; ++i )
	{
	/* The character-pixel string is simply a printed number in base
	** "base" where the digits of the number range from LOW_CHAR to
	** HIGH_CHAR and the printed length of the number is "cpp". 
	*/
	cmap[i].cixel = gen_numstr( i, base, cpp );

	/* Fetch the rgb value of the current colormap entry. */
	red = PPM_GETR( chv[i].color );
	green = PPM_GETG( chv[i].color );
	blue = PPM_GETB( chv[i].color );

	/* If the ppm color components are not relative to 15, 255, 4095,
	** 65535, normalize the color components here. 
	*/
	if ( mval != (int) maxval )
	    {
	    red = (red * mval) / (int) maxval;
	    green = (green * mval) / (int) maxval;
	    blue = (blue * mval) / (int) maxval;
	    }

	/* If the "-rgb <rgbfile>" option was specified, attempt to map the
	** rgb value to a color mnemonic. 
	*/
	if ( map_rgb_names )
	    {
	    /* The rgb values of the color mnemonics are normalized relative
	    ** to 255 << 8, (i.e. 0xFF00).  [That's how the original MIT
	    ** code did it, really should have been "v * 65535 / 255"
	    ** instead of "v << 8", but have to use the same scheme here or
	    ** else colors won't match...]  So, if our rgb values aren't
	    ** already 16-bit values, need to shift left. 
	    */
	    if ( mval == 0x000F )
		{
		r = red << 12;
		g = green << 12;
		b = blue << 12;
		/* Special case hack for "white". */
		if ( 0xF000 == r && r == g && g == b )
		    r = g = b = 0xFF00;
		}
	    else if ( mval == 0x00FF )
		{
		r = red << 8;
		g = green << 8;
		b = blue << 8;
		}
	    else if ( mval == 0x0FFF )
		{
		r = red << 4;
		g = green << 4;
		b = blue << 4;
		}
	    else
		{
		r = red;
		g = green;
		b = blue;
		}

	    /* Just perform a dumb linear search over the rgb values of the
	    ** color mnemonics.  One could speed things up by sorting the
	    ** rgb values and using a binary search, or building a hash
	    ** table, etc... 
	    */
	    for ( matched = 0, j = 0; j <= rgbn_max; ++j )
		if ( r == rgbn[j].r && g == rgbn[j].g && b == rgbn[j].b )
		    {
		    /* Matched.  Allocate string, copy mnemonic, and exit. */
		    str = (char*) malloc( strlen( rgbn[j].name ) + 1 );
		    if ( str == (char*) 0 )
			pm_error("out of memory" );
		    strcpy( str, rgbn[j].name );
		    cmap[i].rgbname = str;
		    matched = 1;
		    break;
		}
	    if ( matched )
		continue;
	    }

	/* Either not mapping to color mnemonics, or didn't find a match.
	** Generate an absolute #RGB value string instead. 
	*/
	str = (char*) malloc( mval == 0x000F ? 5 :
			      mval == 0x00FF ? 8 :
			      mval == 0x0FFF ? 11 :
			      14 );
	if ( str == (char*) 0 )
	    pm_error("out of memory" );

	sprintf(
	    str, mval == 0x000F ? "#%X%X%X" :
		 mval == 0x00FF ? "#%02X%02X%02X" :
		 mval == 0x0FFF ? "#%03X%03X%03X" :
		"#%04X%04X%04X", red, green, blue );
	cmap[i].rgbname = str;
	}
    }