/*	PCX.c -  Graphic Routines that operate on PCX pictures
*/


#include <stdio.h>
#include "lib.h"
#include "pcx.h"


int pcx_init();
int pcx_clear();
int pcx_set_point();
int pcx_clr_point();
int pcx_xor_point();
int pcx_write_row();
int pcx_select_plane();
int pcx_set_palette();
int pcx_mode();
int movmem();
int pokeb();
int peekb();
int pcx_get_point();

static int (*pcx_func[])() = {
	pcx_init,      pcx_clear,     pcx_set_point, pcx_clr_point,
	pcx_xor_point, pcx_get_point, pcx_write_row, pcx_select_plane,
	pcx_set_palette,pcx_mode,     movmem, peekb, pokeb };

PCXPIC *pcx_cpic;      /* current picture   */
static int cplane;     /* current plane     */
int	pcx_md;        /* 1 if CGA-type picture, 0 for HERC/EGA */


int pcx_init()
{
	movmem( pcx_func, vgr_func, sizeof(vgr_func) );

	VGR_NBPL = VGR_HRES = VGR_VRES = VGR_NCOLORS = cplane = 0;
	if ( pcx_cpic )
	{  VGR_HRES    = pcx_cpic->hdr.hres;
	   VGR_VRES    = pcx_cpic->hdr.vres;
	   VGR_NBPL    = pcx_cpic->hdr.bpl;
	   VGR_NCOLORS = pcx_cpic->hdr.bpp > 1 ? 
	                 0x01 << pcx_cpic->hdr.bpp :
	                 0x01 << pcx_cpic->hdr.nplanes;
	};

	return OK;
}


int pcx_select_plane( plane )
int plane;
{
	return cplane = plane & 0x03;
}


int pcx_write_row( row, prow, nbytes )
int nbytes, row;
char *prow;
{
	int i;

	i = pcx_cpic->hdr.hres / 8;
	movmem( prow, (pcx_cpic->rows[cplane][row]), 
	               nbytes <= i ? nbytes : i );
}


int pcx_clear()
{
	int plane, row, nplanes, nrows, bytes;

	nplanes =  pcx_cpic->hdr.nplanes;
	nrows   =  pcx_cpic->hdr.y2 - pcx_cpic->hdr.y1 +1;
	bytes   =  pcx_cpic->hdr.bpl;

	for ( plane=0; plane < nplanes; plane ++ )
	   for ( row=0; row < bytes; row++ )
	      setmem( (pcx_cpic->rows[plane][row]), bytes, 0 );
}


int pcx_mode( m )
int m;
{
	switch ( m )
	{  case MODE_APA0:   /* 640x350x16 */
	   case MODE_APA1:   /* 720x348x02 */
	   case MODE_APA2:   /* 640x200x02 */
	      /* all these modes save color information
	         1 bit per plane.
	      */
	      pcx_md = 0;
	      break;
	   case MODE_APA3:   /* 320x200x04 */
	      /* this mode puts two bits per pixel into the
	         same plane.
	      */
	      pcx_md = 1;
	      break;
	   default:          /* invalid!   */
	      return ERROR;
	};

	return OK;
}


int pcx_xor_point( x, y, color )
int x, y, color;
{
	return pcx_set_point( x, y, pcx_get_point( x, y ) ^ color );
}


int pcx_clr_point( x, y )
int x, y;
{
	return pcx_set_point( x, y, 0 );
}


int pcx_set_point( x, y, color )
int x, y, color;
{
	register unsigned char *p;
	unsigned char plane, b, o, mask;

	if ( pcx_md )
	{  o = (x & 3) << 1;
	   p = (unsigned char *)pcx_cpic->rows[0][y] + (x>>2);
	   *p = (*p & ~(0xc0 >> o)) | ((color & 0x03) << (6-o));
	   return OK;
	};

	o = x >> 3;
	b = (unsigned int)0x80 >> (x & 0x07);

	for ( mask=1,plane=0; plane < pcx_cpic->hdr.nplanes; plane++, mask<<=1 )
	{  p = (unsigned char *)pcx_cpic->rows[plane][y] + o;
	   if ( color & mask )
	      *p |= b;
	   else *p &= ~b;
	};

	return OK;
}


int pcx_get_point( x, y )
int x, y;
{
	unsigned char plane, b, o, color;

	if ( pcx_md )
	{  b = (x & 3) << 1;
	   return ( pcx_cpic->rows[0][y][x>>2] & (0xc0 >> b) ) >> (6-b);
	};

	o = x >> 3;
	b = (unsigned int)0x80 >> (x & 0x07);

	for ( color=plane=0; plane < pcx_cpic->hdr.nplanes; plane++ )
	   color |= !!(pcx_cpic->rows[plane][y][o] & b) << plane;

	return color;
}


/*	PCX Palette Settings.
*/

int pcx_set_palette( reg, red, green, blue )
unsigned char reg, red, green, blue;
{
	if ( pcx_md )
	{  pcx_cpic->hdr.triple[reg].red = red;
	   return OK;
	};

	/* why do we multiply by 85? */
	pcx_cpic->hdr.triple[reg].red   = red   * 85;
	pcx_cpic->hdr.triple[reg].green = green * 85;
	pcx_cpic->hdr.triple[reg].blue  = blue  * 85;
	return OK;
}


PCXPIC *pcx_init_pic( hres, vres, nplanes )
unsigned int hres, vres, nplanes;
{
	int y, p, bpl;
	PCXPIC *pic;
	char *calloc();
	static TRIPLET ega_pal[] = {  /* copied from a        */
	      0x00, 0x00, 0x00,       /* PBRUSH picture file  */
	      0x00, 0x00, 0xaa,
	      0x00, 0xaa, 0x00,
	      0x00, 0xaa, 0xaa,
	      0xaa, 0x00, 0x00,
	      0xaa, 0x00, 0xaa,
	      0xaa, 0xaa, 0x00,
	      0xaa, 0xaa, 0xaa,
	      0x55, 0x55, 0x55,
	      0x55, 0x55, 0xff,
	      0x55, 0xff, 0x55,
	      0x55, 0xff, 0xff,
	      0xff, 0x55, 0x55,
	      0xff, 0x55, 0xff,
	      0xff, 0xff, 0x55,
	      0xff, 0xff, 0xff        };

	static TRIPLET cga_pal[] = {
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0,
	        0,0,0, 255,0,0        };

	if ( !(pic = (PCXPIC *) calloc( 1, sizeof(PCXPIC) )) )
	   return NULL; /* out of memory */

	pic->hdr.x2 = hres -1;
	pic->hdr.y2 = vres -1;

	pic->hdr.maker     = 10;
	pic->hdr.version   =  5;
	pic->hdr.code      =  1;
	pic->hdr.bpp       =  1 + pcx_md;
	pic->hdr.bpl       = bpl = (hres * (1+pcx_md)) / 8;

	VGR_HRES    = pic->hdr.hres    = hres;
	VGR_VRES    = pic->hdr.vres    = vres;
	VGR_NBPL    = bpl;
	VGR_NCOLORS = 1 << (pic->hdr.nplanes = nplanes);

	movmem( (pcx_md ? cga_pal : ega_pal), 
	         pic->hdr.triple, sizeof(pic->hdr.triple) );

	for ( p=0; p < nplanes; p++ )
	{  if ( ! (pic->rows[p] = (uchar **)calloc( 1, sizeof(char *) * vres)) )
	      return pcx_free_pic( pic ), (PCXPIC *)0;
	   for ( y=0; y < vres; y++ )
	      if ( !(pic->rows[p][y] = (uchar *)calloc( 1, bpl )) )
	         return pcx_free_pic( pic ), (PCXPIC *)0;
	};

	return pic;
}


int pcx_free_pic( pic )
PCXPIC *pic;
{
	int row, plane, nrows, nplan;

	nrows = pic->hdr.y2 - pic->hdr.y1 +1;
	nplan = pic->hdr.nplanes;

	VGR_MODE( MODE_TEXT0 );
	printf("At pcx_free_pic, probably out of memory...\n");

	for ( plane = 0; plane < nplan; plane++ )
	{  for ( row = 0; row < nrows; row++ )
	      allocf( pic->rows[plane][row] );
	   allocf( pic->rows[plane] );
	};

	allocf( pic );
	return NULL;
}


void map_not( map, len )
register unsigned int *map, len;
{
	for ( ; len--; map++ )
	   *map = ~ *map;
}


void pcx_invert_pic( pic )
PCXPIC *pic;
{
	int p, r, i;

	for ( p=0; p < pic->hdr.nplanes; p++ )
	   for ( r=0; r < (pic->hdr.y2 - pic->hdr.y1); r++ )
	      map_not( pic->rows[p][r], pic->hdr.bpl / 2 );
}


allocf( p )
char *p;
{
	if ( !p )
	   return OK;

	if ( free(p) == -1 )
	   CRASH( "heap munged" );
}

#ifdef MAIN

/*	Manx 'C stack/heap size adjustment -
	The vgr_fill() function uses an enourmous amount of stack,
	and we're going to need enough heap space to allocate
	4 bit maps for the EGA board.
*/
uint	__STKLOW = 0,
    	__STKSIZ = 4096,
    	__HEAPSIZ = 8192;

int 	cga_init(), ega_init(), herc_init();
int	board, (*board_init)(), md;

/*	This structure is used here to facilitate drawing the
	simple X and complex box that are used to test the
	dot, line and fill functions.
*/
typedef struct {
   int x,y;
} OBJ;

static OBJ obj[] = { 
100, 100, 150, 200, 200, 100, 250, 150, 175, 250, 250, 350, 200, 400, 150, 300, 
100, 400,  50, 350, 125, 250,  50, 150, 100, 100 };

static OBJ obj2[] = {
  0,  0,280,  0,280,140,240,140,240, 20,200, 20,200,280,240,280,240,160, 
280,160,280,300,  0,300,  0,160, 40,160, 40,280, 80,280, 80, 20, 40, 20, 
 40,140,  0,140,  0,  0 };
	   
static OBJ obj3[] = {
	   120,20, 160,20, 160,280, 120,280, 120,20 };


main( argc, argv )
char **argv;
int argc;
{
	void pcx_showpic();
	FILE *fp, *fopen();
	int c, h, v, p;

	printf("PCX test routine.\n");
	if ( argc == 1 )
	   printf("Try \"PCX xx\" for help\n" );

	board = vgr_get_board();

	if ( argc >= 2 )
	{       if ( !strcmp(argv[1], "ega") )
	           board = TYPE_EGA;
	   else if ( !strcmp(argv[1], "cga") )
	           board = TYPE_CGA;
	   else if ( !strcmp(argv[1], "herc") )
	           board = TYPE_HERC;
	   else if ( !strcmp(argv[1], "cga2") )
	           board = 9;
	   else {  printf("\
usage: PCX\n\
or     PCX <board>\n\
or     PCX <board> <pcx_file_name>\n\n\
 func: Excercises the board & PCX routines.\n\
       <board> may be one of:\n\
       	   cga - 640x200x2 CGA\n\
       	   cga2- 320x200x4 CGA\n\
       	   herc- Hercules Hi-Res\n\
       	   ega - 640x350x16 EGA\n\
       <pcx_file_name> may be any file name,\n\
       although an extension of .PCX is\n\
       appropriate.\n" );
 	           exit(1);
 	        };
	};

	switch( board )
	{  case TYPE_UNKNOWN:
	   case TYPE_MDA:
	      CRASH("unable to detect a HERC, CGA or EGA board");
	   case TYPE_CGA:
	      printf("CGA board detected\n");
	      board_init = cga_init;
	      md = MODE_APA2, c = 1, h = 640, v=200, p=1;
	      break;
	   case 9:
	      printf("CGA/APA3 Selected\n");
	      board_init = cga_init;
	      md = MODE_APA3, c = 2, h = 320, v=200, p=1;
	      break;
	   case TYPE_EGA:
	      printf("EGA board detected\n");
	      board_init = ega_init;
	      md = MODE_APA0, c = 9, h = 640, v=350, p=4;
	      break;
	   case TYPE_HERC:
	      printf("HERC board detected\n");
	      board_init = herc_init;
	      md = MODE_APA1, c = 1, h = 720, v=348, p=1;
	      break;
	   default:
	      CRASH("bug: invalid board type number");
	};

	printf("Hit return to continue:");
	getchar();

	/* pcx_init_pic needs to know what mode it's in
	*/
	pcx_init();
	pcx_mode( md );   
	if ( !(pcx_cpic = pcx_init_pic( h, v, p )) )
	   CRASH("out of memory");

	pcx_init();
	if ( VGR_MODE( md ) )
	   CRASH( "error in mode selection" );

	printf("HRES=%d, VRES=%d, NCOLORS=%d, NPLANES=%d, pcx_md=%d\n",
	      VGR_HRES, VGR_VRES, VGR_NCOLORS, p, pcx_md );

	draw_it( (OBJ *)&obj,  NELEMS(obj) , 3, 3,   0, 0, c );
	printf(".");
	draw_it( (OBJ *)&obj2, NELEMS(obj2), 3, 3, 150, 0, c );
	printf(".");
	draw_it( (OBJ *)&obj3, NELEMS(obj3), 3, 3, 150, 0, c );
	printf(".");

	vgr_fill(  33, 40, c );
	printf(".");
	vgr_fill( 179, 19, c );

	printf("\nhit return to continue, then hit return again:");
	getchar();

	if ( (*board_init)() )
	   CRASH( "board init failed" );
	if ( VGR_MODE( md ) )
	   CRASH( "error in mode selection" );

	pcx_showpic( pcx_cpic, 0, 0, 0 );

	getchar();

	VGR_MODE( MODE_TEXT0 );

	if ( argc == 3 )
	{  if ( !(fp = fopen( argv[2], "w" )) )
	      CRASH( "error opening picture file" );
	   if ( pcx_write_pic( pcx_cpic, fp ) )
	      CRASH( "error writing picture file" );
	   fclose(fp);
	};

	exit(0);
}


draw_it( obj, n, divx, divy, ox, oy, c )
OBJ *obj;
int n, divx, divy;
{
	int x;

	vgr_point( obj[0].x / divx + ox, obj[0].y / divy + oy, -1 );
	for ( x=1; x < n; x++ )
	   vgr_point( obj[x].x / divx + ox, obj[x].y / divy + oy, c );
}


#endif