/*

 * Convert a GEM .img file to PBM

 *

 * Author: Diomidis D. Spinellis

 * (C) Copyright 1988 Diomidis D. Spinellis.

 *

 * 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 file is provided AS IS with no warranties of any kind.  The author

 * shall have no liability with respect to the infringement of copyrights,

 * trade secrets or any patents by this file or any part thereof.  In no

 * event will the author be liable for any lost revenue or profits or

 * other special, indirect and consequential damages.

 *

 * Comments and additions should be sent to the author:

 *

 *                     Diomidis D. Spinellis

 *                     1 Myrsinis Str.

 *                     GR-145 62 Kifissia

 *                     GREECE

 *

 * 92/07/11 Johann Haider

 * Changed to read from stdin if file is omitted

 * Changed to handle line length not a multipe of 8

 *

 * 94/01/31 Andreas Schwab (schwab@ls5.informatik.uni-dortmund.de)

 * Changed to remove architecture dependency and conform to

 * PBM coding standard.

 * Added more tests for garbage.

 *

 * 2000/04/30 John Elliott <jce@seasip.demon.co.uk> Added ability to

 * read 4-plane color IMG files.  Therefore changed from PBM to PPM.

 * Bryan changed it further to use the PNM facilities so it outputs

 * both PBM and PPM in the Netpbm tradition.  Name changed from

 * gemtopbm to gemtopnm.  

 */

#include <assert.h>

#include "pnm.h"

#define MAXVAL 3

#define LIGHT  2

#define DARK   1

#define BLACK  0

char pattern[8];

static void getinit ARGS ((FILE *file, int *colsP, int *rowsP, int *padrightP,

			   int *patlenP, int *planesP));

int

main(argc, argv)

	int             argc;

	char           *argv[];

{

	int     debug = 0;

	FILE    *f;

    int     row;

	int     rows, cols, padright, patlen, planes;

      /* attributes of input image */

    int type;  /* The format type (PBM/PPM) of the output image */

	bit	*bitrow[4];

      /* One row of input, one or four planes.  (If one, only [0] is defined)*/

    xel * xelrow;  /* One row of output */

	const char * const usage = "[-debug] [gem IMG file]";

	int argn;

/* Process multiple planes by maintaining a separate row of bits for each

 * plane. In a single-plane image, all we have to do is write out the 

 * first plane; in a multiple-plane image, we combine them just before writing

 * out the row.

 */

	pnm_init( &argc, argv );

    argn = 1;

	while (argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0')

	  {

	    if (pm_keymatch(argv[1], "-debug", 2))

	      debug = 1;

	    else

	      pm_usage (usage);

	    ++argn;

	  }

	if (argc == argn)

		f = stdin;

	else {

		f = pm_openr (argv[argn]);

		++argn;

	}

	if (argn != argc)

	  pm_usage (usage);

	getinit (f, &cols, &rows, &padright, &patlen, &planes);

    if (planes == 1) 

        type = PBM_TYPE;

    else 

        type = PPM_TYPE;

	pnm_writepnminit( stdout, cols, rows, MAXVAL, type, 0 );

    overflow_add(cols, padright);

    { 

        /* allocate input row data structure */

        int plane;

        for (plane = 0; plane < planes; plane++) 

            bitrow[plane] = malloc (cols + padright);

    }

    xelrow = pnm_allocrow(cols+padright);   /* Output row */

	for (row = 0; row < rows; ) {

      int linerep;

      int plane;

	  linerep = 1;

	  for (plane = 0; plane < planes; plane++) {

        int col;

		col = 0;

		while (col < cols) {

            int c;

			switch (c = getc(f)) {

			case 0x80:	/* Bit String */

            {

                int j;

				c = getc(f);	/* Byte count */

				if (debug)

                  pm_message("bit string of %d bytes", c);

				if (col + c * 8 > cols + padright)

				  pm_error ("bad byte count");

				for (j = 0; j < c; ++j) {

                    int cc, k;

					cc = getc(f);

					for (k = 0x80; k; k >>= 1) {

						bitrow[plane][col] = (k & cc) ? 0 : 1;

						++col;

					}

				}

            }

            break;

			case 0:		/* Pattern run */

            {

                int j, l;

				c = getc(f);	/* Repeat count */

				if (debug)

					pm_message("pattern run of %d repetitions",	c);

                /* line repeat */

                if (c == 0) {

                    c = getc(f);

                    if (c != 0x00ff)

                        pm_error( "badly formed line repeat" );

                    linerep = getc(f);

                    break;

                }

				fread (pattern, 1, patlen, f);

				if (col + c * patlen * 8 > cols + padright)

				  pm_error ("bad pattern repeat count");

				for (j = 0; j < c; ++j)

					for (l = 0; l < patlen; ++l) {

                        int k;

						for (k = 0x80; k; k >>= 1) {

							bitrow[plane][col] = (k & pattern[l]) ? 0 : 1;

							++col;

						}

                    }

            }

            break;

			default:	/* Solid run */

            {

                int l, j;

				if (debug)

					pm_message("solid run of %d bytes %s", c & 0x7f,

                               c & 0x80 ? "on" : "off" );

                /* each byte had eight bits DSB */

                l = (c & 0x80) ? 0: 1;

                c = (c & 0x7f) * 8;

                if (col + c > cols + padright)

                    pm_error ("bad solid run repeat count");

                for (j = 0; j < c; ++j) {

                    bitrow[plane][col] = l;

					++col;

                }

            }

				break;

			case EOF:	/* End of file */

				pm_error( "end of file reached" );

			}

		}

                if ( debug )

                        pm_message( "EOL plane %d row %d", plane, row );

                if (col != cols + padright)

                        pm_error( "EOL beyond edge" );

	  }

	  if (planes == 4) {

          /* Construct a pixel from the 4 planes of bits for this row */

          int col;

          for (col = 0; col < cols; col++) {

            int r, g, b, i;

            const int r_bit = !bitrow[0][col];

            const int g_bit = !bitrow[1][col];

            const int b_bit = !bitrow[2][col];

            i = bitrow[3][col];

			/* Deal with weird GEM palette - white/black/gray are

               encoded oddly 

            */

			if (r_bit == g_bit && g_bit == b_bit) {

                /* It's black, white, or gray */

				if (r_bit && i) r = LIGHT;

				else if (r_bit) r = BLACK;

				else if (i) r = MAXVAL;

				else r = DARK;

				g = b = r;	

			} else {

                /* It's one of the twelve colored colors */

                if (!i) {

                    /* Low intensity */

                    r = r_bit * LIGHT; 

                    g = g_bit * LIGHT;

                    b = b_bit * LIGHT;

                } else {

                    /* Normal intensity */

                    r = r_bit * MAXVAL;

                    g = g_bit * MAXVAL;

                    b = b_bit * MAXVAL;

                }

            }

            PPM_ASSIGN(xelrow[col], r, g, b);

		}

	  } else {

          int col;

          for (col = 0; col < cols; col++) 

              PNM_ASSIGN1(xelrow[col], bitrow[0][col]);

      }

	  while (linerep--) {

		pnm_writepnmrow( stdout, xelrow, cols, MAXVAL, type, 0 );

		++row;

	  }

	}

    pnm_freerow(xelrow);

	pm_close( f );

	pm_close( stdout );

	exit(0);

}

static void

getinit (file, colsP, rowsP, padrightP, patlenP, planesP)

     FILE *file;

     int *colsP;

     int *rowsP;

     int *padrightP;

     int *patlenP;

     int *planesP;

{

  short s;

  short headlen;

  if (pm_readbigshort (file, &s) == -1) /* Image file version */

    pm_error ("EOF / read error");

  if (s != 1)

    pm_error ("unknown version number (%d)", (int) s);

  if (pm_readbigshort (file, &headlen) == -1) /* Header length in words */

    pm_error ("EOF / read error");

  if (headlen < 8)

    pm_error ("short header (%d)", (int) headlen);

  if (pm_readbigshort (file, &s) == -1) /* Number of planes */

    pm_error ("EOF / read error");

  if (s != 4 && s != 1)

    pm_error ("This program can interpret IMGs with only 1 or 4 planes");

  *planesP = s;

  if (pm_readbigshort (file, &s) == -1) /* Pattern definition length (bytes) */

    pm_error ("EOF / read error");

  if (s < 1 || s > 8)

    pm_error ("illegal pattern length (%d)", (int) s);

  *patlenP = (int) s;

  if (pm_readbigshort (file, &s) == -1 /* Pixel height (microns) */

      || pm_readbigshort (file, &s) == -1 /* Pixel height (microns) */

      || pm_readbigshort (file, &s) == -1) /* Scan line width */

    pm_error ("EOF / read error");

  *colsP = (int) s;

  if (pm_readbigshort (file, &s) == -1) /* Number of scan line items */

    pm_error ("EOF / read error");

  *rowsP = (int) s;

  *padrightP = 7 - ((*colsP + 7) & 7);

  headlen -= 8;

  while (headlen-- > 0)

    {

      (void) getc (file);

      (void) getc (file);

    }

}