getap.c

/*
 * This software is copyrighted as noted below.  It may be freely copied,
 * modified, and redistributed, provided that the copyright notice is 
 * preserved on all copies.
 * 
 * There is no warranty or other guarantee of fitness for this software,
 * it is provided solely "as is".  Bug reports or fixes may be sent
 * to the author, who may or may not act on them as he desires.
 *
 * You may not include this software in a program or other software product
 * without supplying the source, or without informing the end-user that the 
 * source is available for no extra charge.
 *
 * If you modify this software, you should include a notice giving the
 * name of the person performing the modification, the date of modification,
 * and the reason for such modification.
 */
/* 
 * getap.c - Read RLE files onto apollo screens.
 * 
 * Author:	John W. Peterson
 * 		Computer Science Dept.
 * 		University of Utah
 * Date:	Fri Jun 27 1986
 * Copyright (c) 1986 John W. Peterson
 *
 * Revision 1.1  87/05/26  13:22:30  Clark
 * Add window name overhead to create window call and fix y calculation in
 * put_line.
 * Revision 1.2  87/10/01  10:38:00  Clark
 * Add code to wait for user input, quit when user types "q"
 * and to screen dump a GMR bitmap file if user types "d"
 * Revision 1.3  88/01/07  08:28:30  Clark
 * Add code to put file name in window legend and fix for obscured
 * window, add flag for no border and x,y position
 * Revision 1.4  88/01/08  08:10:30  Clark
 * Add code for adding text to image
 * Revision 1.5  88/02/25  01:54:00  Clark
 * Re-instate BW code, and add suport for 4 bit plane workstations.
 * Revision 1.6  88/02/29  11:33:50  Clark
 * Use all available bit planes for gray scale. Use 16x16 dither
 * for BW nodes instead of 8x8 S. Kitaoka Grey table
 *
 *
 * Some code lifted from an old getX by Spencer Thomas and showbw
 * by Jim Schimpf.
 *
 * Flags are:
 *   -l		Linear map
 *   -g gam	Gammap map, use gamma of gam (floating point number)
 *   -b		Use full 24 bit mode (DN550, DN560, DN660 only)
 *   -w         Black and white
 *   -r		Flip white on black/black on white for grayscale display.
 *   -x left	X coordinate of window
 *   -y top	Y coordinate of window
 *   -t text	Add text to bottom of image
 *   -n 	No border or legend
 *
 * NOTE: This version applies the color map if present.
 */

#include <stdio.h>
#include <math.h>
#include "rle.h"

#include "/sys/ins/base.ins.c"
#include "/sys/ins/gpr.ins.c"
#include "/sys/ins/error.ins.c"
#include "/sys/ins/pad.ins.c"

#define RASTERSIZE 1023
#define COLMAP_OFFSET 16

#define sysdebug if ((status.all)!=0) error_$print(status)

/* Scanline storage & RLE row pointers */
rle_pixel **rows;
#define DMAP(v,x,y)	(modN[v]>dm16[x][y] ? divN[v] + 1 : divN[v])
int dm16[16][16];
int modN[256], divN[256];
float gam = 2.0;		/* Default gamma */
int inverse_flag = false;	/* If true, swap bits on B&W displays */
int gray_flag = false;		/* True if making BW image on color screen */
int borrow_mode = false;	/* DN560/660 imaging mode (borrow screen)) */
int 
    linear_flag = false,	/* Color map flags */
    gam_flag = true;
int four_flag = false;		/* If true, workstation has only 4 planes */
int bw_flag = false;		/* If true, workstation is BW */
int x_flag = false;		/* True if X coord specified */ 
int y_flag = false;		/* True if Y coord specified */ 
int no_border_flag = false;     /* True if no border or legend */
int left = 0;			/* Default window X coord */
int top = 0;			/* Default window Y coord */
gpr_$pixel_value_t dest_pixels[RASTERSIZE];  /* avoid bludging stack */
gpr_$offset_t size;
short font_id;
short middle;
status_$t status;
gpr_$keyset_t keyset = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 
                         0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff };
char key;
gpr_$position_t position;
boolean obs;
gpr_$event_t event;
gpr_$version_t version;
gpr_$offset_t dump_size;
gpr_$window_t dump_window;
gpr_$attribute_desc_t attribs;
gpr_$bitmap_desc_t bitmap;
gpr_$bitmap_desc_t dump_bitmap;
boolean created;
gpr_$bmf_group_header_array_t header;
gpr_$color_vector_t color_map;
short map[3][256];

/* Image header. */
rle_hdr	hdr;

main(argc, argv)
int argc;
char **argv;
{
    int i;
    short len;
    int row;
    unsigned n;
    char * fname = NULL;
    char * text = NULL;
    int text_flag = 0;
    short namelen, tok_count;
    char gstring[20];

    set_sbrk_size( 1000000 );

    hdr = *rle_hdr_init( (rle_hdr *)NULL );

    if (! scanargs( argc, argv,
		   "% b%- l%- r%- w%- n%- g%-gamma!f x%-left!d y%-top!d t%-text!s file%s",
		   &borrow_mode, &linear_flag, &inverse_flag,
		   &gray_flag, &no_border_flag, &gam_flag, &gam,
		   &x_flag, &left, &y_flag, &top, &text_flag, &text, &fname ))          
	exit( 1 );
    rle_names( &hdr, cmd_name( argv ), fname, 0 );
    hdr.rle_file = rle_open_f(hdr.cmd, fname, "r");

    switch( (int) rle_get_setup( &hdr ) )
    {
    case 0:
	break;			/* successful open */
    case -1:			/* not an RLE file */
    case -4:			/* or header is short */
	fprintf( stderr, "getap: %s is not an RLE file\n", fname );
	exit(-4);
	break;
    case -2:
	fprintf( stderr, "getap: malloc failed\n" );
	exit(-2);
	break;
    case -3:
	fprintf( stderr, "getap: input file is empty\n" );
	exit(-3);
	break;
    }

/*    RLE_CLR_BIT( hdr, RLE_ALPHA );	/* No alpha channel */

    rle_row_alloc( &hdr, &rows );

    if (borrow_mode)
    {
	borrow_setup();
	borrow_color_map(); 
	if (hdr.ymax > 511)
	    hdr.ymax = 511;
    }
    else
    {
	setup_scr(hdr.xmax, hdr.ymax);
	window_color_map();
	if (hdr.ymax > RASTERSIZE)
	    hdr.ymax = RASTERSIZE;
    }

    if (bw_flag) gray_flag = true;

    for (i = hdr.ymin; i <= hdr.ymax; i++)
    {
	rle_getrow( &hdr, rows );
	if (borrow_mode)
	    put_line_borrow(i);
	else
	{
	    if (gray_flag)
		put_linebw(i);
	    else
	    {
		if (four_flag)
		    put_line4(i);
		else
		    put_line8(i);
	    }
	}
    }
    if (text_flag)
    {
	if (!borrow_mode) gpr_$acquire_display( status ) ;
	gpr_$load_font_file( "nonie.r.16", (short) 10, font_id, status );
	gpr_$set_text_font( font_id, status );
	gpr_$set_text_background_value( (int) -1, status );
	gpr_$set_text_value( (int) 17, status );
	gpr_$inq_text_extent( *text, (short) strlen(text),
			      size, status );
	middle = (hdr.xmax/2) - (size.x_size/2);
	if (middle < 0) middle=0;
	gpr_$move( middle, (short)(hdr.ymax-15), status);
	gpr_$text( *text, (short) strlen(text), status);
	if (!borrow_mode) gpr_$release_display( status ) ;
    }
    do
    {
	if (!borrow_mode) gpr_$acquire_display( status ) ;
	gpr_$enable_input( gpr_$keystroke, keyset, status ) ;
	obs = gpr_$event_wait ( event, key, position, status ) ;
	if (!borrow_mode) gpr_$release_display( status ) ;
	if ( (event == gpr_$keystroke) && ( (key == 'd') || (key == 'D') ) )
	{
	    if (borrow_mode)
	    {
		gpr_$inq_bitmap( bitmap, status ) ;
		sysdebug;
		gpr_$allocate_attribute_block(attribs,status);
		sysdebug;
		header[0].n_sects	= 8;
		header[0].pixel_size     = 1;
		header[0].allocated_size = 0;
		header[0].bytes_per_line = 0;
		header[0].bytes_per_sect = 0;
		dump_size.x_size = 1024;
		dump_size.y_size = 1024;
		gpr_$open_bitmap_file(gpr_$create,"screen_dump",(short)11,version,
		    dump_size,(short)1,header,attribs,dump_bitmap,created,status);
		if (status.all == 0)
		{
		    gpr_$set_bitmap(dump_bitmap,status);
		    sysdebug;
		    gpr_$inq_color_map((int)0,256,color_map,status);
		    sysdebug;
		    gpr_$set_bitmap_file_color_map(dump_bitmap,0,256,color_map,status);
		    sysdebug;
		    dump_window.window_base.x_coord = 0;
		    dump_window.window_base.y_coord = 0;
		    dump_window.window_size.x_size = 1024;
		    dump_window.window_size.y_size = 1024;
		    gpr_$set_imaging_format(gpr_$interactive, status );
		    sysdebug;
		    gpr_$pixel_blt(bitmap,dump_window,dump_window.window_base,status);
		    sysdebug;
		    gpr_$set_imaging_format(gpr_$imaging_512x512x24, status );
		    sysdebug;
		}
		else
		{
		    fprintf(stderr, "getap: Could not open bitmap file screen_dump - ");
		    error_$print(status);
		}
	    }
	    else
	    {   
		pad_$dm_cmd ((short)1, "CPO /COM/CPSCR SCREEN_DUMP -GPR", (short)31, status ) ;
		sysdebug;
	    }
	}
	if ( (event == gpr_$keystroke) && ( (key == 'p') || (key == 'P') && (!borrow_mode) ) )
	{
	    pad_$dm_cmd ((short)1, "WP", (short)2, status ) ;
	    sysdebug;
	}
    }
    while ( !( (event == gpr_$keystroke) && ( (key == 'q') || (key == 'Q') ) ) );
    if (borrow_mode)
    {
	gpr_$set_imaging_format(gpr_$interactive, status );
	sysdebug;
    }
    if (!borrow_mode && four_flag)
    {
	gpr_$acquire_display( status ) ;
	gpr_$set_color_map((int)0,8,color_map,status);
	gpr_$release_display( status ) ;
    }
}

/*
 * Initialize the GPR package to imaging mode
 */
borrow_setup()
{
    gpr_$offset_t size;
    gpr_$bitmap_desc_t main_bitmap;      /* Master bitmap */

    size.x_size = 1024;
    size.y_size = 1024;			/* GPR will shrink to fit */

    gpr_$init(gpr_$borrow, 1, size, 7, main_bitmap, status );
    sysdebug;

    gpr_$set_imaging_format( gpr_$imaging_512x512x24, status );
    sysdebug;
    if (status.all != status_$ok)
    {
	fprintf(stderr, "getap: Wrong hardware?\n");
	exit(-1);
    }
}

/* Set up the color map (imaging mode) */
borrow_color_map()
{
    unsigned int value;
    unsigned int intgam;
    int i, map_offset;
    gpr_$color_vector_t colmap;
    
    if ( hdr.ncmap )	/* Must read color map */
    {
	map_offset = 1 << hdr.cmaplen;

	/* This needs more thought; handle ncmap = 1, etc. */
	if (hdr.ncmap == 3)

	for (i=0; i < 256; i++)
	{
            /* This is bogus, we need to index cmap!... */
	    
	    value = (((hdr.cmap[i]>> 8) & 0xFF) << 16);
	    value |= (((hdr.cmap[i+map_offset] >> 8) & 0xFF) << 8);
	    value |= ((hdr.cmap[i+2*map_offset] >> 8) & 0xFF);
	    colmap[i] = value;
	}
    }
    else
    {	  
	if (gam_flag)
	{
	    for (i = 0; i < 256; i++)
	    {
		intgam = (int)(0.5 + 255 * pow( i / 255.0, 1.0/gam ));
		value = intgam;
		value |= (intgam << 8);
		value |= (intgam << 16);
		colmap[i] = value;
	    }
	}
	else
	{			/* Default is linear map */
	    for (i=0; i < 256; i++)
	    {
		value = (i << 16);
		value |= (i << 8); 
		value |= i;
		colmap[i] = value;
	    }
	}
    }
	    
	  
    gpr_$set_color_map( (int) 0, 256, colmap, status );
    sysdebug;
}

/*
 * Initialize the 8 bit color map.  Use gamma corrected map.
 */
window_color_map()
{
    int i, j, k, l, planes, map_offset;
    unsigned int value;
    unsigned int intgam;
    status_$t status;
    static gpr_$color_vector_t colmap;
    gpr_$display_config_t config;

    if ( hdr.ncmap )	/* Must read color map */
    {
	map_offset = 1 << hdr.cmaplen;

	/* This needs more thought; handle ncmap = 1, etc. */
	if (hdr.ncmap == 3)

	for (i=0; i < 256; i++)
	{
            /* This is bogus, we need to index cmap!... */
	    
	    map[0][i] = ((hdr.cmap[i]>> 8) & 0xFF);
	    map[1][i] = ((hdr.cmap[i+map_offset] >> 8) & 0xFF);
	    map[2][i] = ((hdr.cmap[i+2*map_offset] >> 8) & 0xFF);
	}
    }
    else
    {	  
	if (gam_flag)
	{
	    for (i = 0; i < 256; i++)
	    {
		intgam = (int)(0.5 + 255 * pow( i / 255.0, 1.0/gam ));
		map[0][i] = intgam;
		map[1][i] = intgam;
		map[2][i] = intgam;
	    }
	}
	else
	{			/* Default is linear map */
	    for (i=0; i < 256; i++)
	    {
		map[0][i] = i;
		map[1][i] = i;
		map[2][i] = i;
	    }
	}
    }

    gpr_$inq_config( config, status );
    if ((config == gpr_$color_1024x1024x4) ||
	(config == gpr_$color_1024x800x4) ||
	(config == gpr_$color2_1024x800x4)) four_flag = true;
    if ((config == gpr_$bw_800x1024) ||
	(config == gpr_$bw_1024x800) ||
	(config == gpr_$bw_1280x1024)) bw_flag = true;

    if (four_flag && !bw_flag && !gray_flag)    
    {
	/* 
	 * Set up the 4-bit color map entries.
	 */
	for(i = 0; i < 8; i++) {
	    colmap[i] = ((i%2) * 255) << 16;
	    colmap[i] |= (((i/2)%2) * 255) << 8;
	    colmap[i] |= (((i/4)%2) * 255);
	}

	/* Save DM window colors */
	gpr_$acquire_display( status );
	gpr_$inq_color_map((int)0,8,color_map,status);
	gpr_$set_color_map( (int)0, 8, colmap, status );
	gpr_$release_display( status );

	make_square( 2.0, divN, modN, dm16 );
    }
    else if (four_flag && !bw_flag && gray_flag)
    {
        bwdithermap( 8, gam, colmap, divN, modN, dm16);

	for(i = 0; i < 8; i++) {
            j = colmap[i];
	    colmap[i] = j << 16;
	    colmap[i] |= j << 8;
	    colmap[i] |= j;
	}
	/* Save DM window colors */
	gpr_$acquire_display( status );
	gpr_$inq_color_map((int)0,8,color_map,status);
	gpr_$set_color_map( (int)0, 8, colmap, status );
	gpr_$release_display( status );

    }
    else if (!bw_flag && !gray_flag)
    {
	/* 
	 * Set up the 8 bit color map entries.  We don't yet know the location
	 * in the map at which each will reside, so init it to 0.
	 */
	for(i = 0; i < 216; i++) {
	    colmap[i] = ((i%6) * 51) << 16;
	    colmap[i] |= (((i/6)%6) * 51) << 8;
	    colmap[i] |= (((i/36)%6) * 51);
	}

	/* Offset from DM window colors */
	gpr_$acquire_display( status );
	gpr_$set_color_map( (int) COLMAP_OFFSET, 256 - COLMAP_OFFSET,
        	           colmap, status );
	gpr_$release_display( status );

	/* Compute tables */
	make_square( 6.0, divN, modN, dm16 );
    }
    else if (!bw_flag)
    {
        bwdithermap( 240, gam, colmap, divN, modN, dm16);

	for(i = 0; i < 240; i++) {
            j = colmap[i];
	    colmap[i] = j << 16;
	    colmap[i] |= j << 8;
	    colmap[i] |= j;
	}
	/* Offset from DM window colors */
	gpr_$acquire_display( status );
	gpr_$set_color_map( (int) COLMAP_OFFSET, 256 - COLMAP_OFFSET,
        	           colmap, status );
	gpr_$release_display( status );
    }
    else
    {
        bwdithermap( 2, gam, colmap, divN, modN, dm16);
    }
}

/* All the fun stuff to set up an apollo window */
setup_scr(hsize,vsize)
int hsize,vsize;
{
    gpr_$offset_t size;
    gpr_$color_vector_t colmap;
    gpr_$attribute_desc_t hidden_desc;
    unsigned int value;
    int i;
    name_$pname_t output_file;
    short len, w, h;
    pad_$window_desc_t window_shape;
    static gpr_$bitmap_desc_t main_bitmap;
    short fontid;
    static stream_$id_t out_stream;

    /* Open a separate window to display the results */

    window_shape.top = 0;
    window_shape.left = 0;
    if ( !no_border_flag )
    {
	w = 11;
	h = 34;
    }
    else
    {
	w = 1;
	h = 1;
    }
    window_shape.width = (short)hsize + w;
    window_shape.height = (short)vsize + h;

    pad_$create_window( "", (short) 0, pad_$transcript, (short) 1,
			window_shape, out_stream, status );

    if ( no_border_flag ) pad_$set_border( out_stream, (short) 1, false, status );

    window_shape.top = top;
    window_shape.left = left;
    pad_$set_full_window( out_stream, (short) 1, window_shape, status );

    pad_$set_auto_close( out_stream, (short) 1, true, status );

    size.x_size = 1024;  /* GPR will shrink to fit */
    size.y_size = 1024;

    /* Initialize the graphics primitives package */

    gpr_$init(gpr_$direct,
              out_stream,               /* "unit" */
              size,                     /* size of the initial bitmap */
              7,                        /* identifier of the heightest
                                           numbered bitmap plane */
              main_bitmap,              /* resulting bitmap descriptor */
              status);

    gpr_$set_auto_refresh( true, status );  /* all yours, DM. */

    gpr_$set_obscured_opt( gpr_$block_if_obs, status );

    gpr_$acquire_display( status ) ;

    /* set the new bitmap descriptor to be the 'current bitmap' */
    gpr_$set_bitmap(main_bitmap,status);
    gpr_$clear( gpr_$black, status );

    gpr_$release_display( status );
}

/* Write a scanline to the frame buffer using full 24 bit mode */
put_line_borrow(y)
int y;
{
    int i;
    gpr_$window_t dest_box;
    unsigned char *redptr, *grnptr, *bluptr;


    dest_box.window_base.x_coord = 0;
    dest_box.window_base.y_coord = 511 - y;
    dest_box.window_size.x_size = 511;
    dest_box.window_size.y_size = 1;

    redptr = rows[RLE_RED];
    if (hdr.ncolors == 3)
    { 
        grnptr = rows[RLE_GREEN];
        bluptr = rows[RLE_BLUE];
    }
    else	/* If only one channel, get all from same one  */
    {
        grnptr = rows[0];
        bluptr = rows[0];
    }
    for (i = hdr.xmin; i <= hdr.xmax; i++)
    {
	dest_pixels[i] = (gpr_$pixel_value_t) ((*redptr) << 16);
	dest_pixels[i] |= (gpr_$pixel_value_t) ((*grnptr) << 8);
	dest_pixels[i] |= (gpr_$pixel_value_t) (*bluptr);
	redptr++;  grnptr++; bluptr++;
    }
    gpr_$write_pixels( dest_pixels, dest_box, status );
    sysdebug;
}

/*
 * Map a 24 bit scanline to 4 bits through the dither matrix.
 */

put_line4( y )
int y;
{
    register unsigned char *r, *g, *b;
    register int i, col, row;
    gpr_$window_t dest_box;
    int n = hdr.xmax;

    r = rows[RLE_RED];
    if (hdr.ncolors == 3)
    { 
        g = rows[RLE_GREEN];
        b = rows[RLE_BLUE];
    }
    else
    {
        g = rows[0];
        b = rows[0];
    }

    for ( row = y % 16, col = 0, i = 0;
	 i <= n; i++, r++, g++, b++, col = ((col + 1) & 15) )
	dest_pixels[i] = DMAP(map[0][*r], col, row) +
	    		 DMAP(map[1][*g], col, row) * 2 +
			 DMAP(map[2][*b], col, row) * 4;

    dest_box.window_base.x_coord = hdr.xmin;
    dest_box.window_base.y_coord = hdr.ymax - y;
    dest_box.window_size.x_size = hdr.xmin + hdr.xmax + 1;
    dest_box.window_size.y_size = 1;

    gpr_$acquire_display( status ) ;
    gpr_$write_pixels( dest_pixels, dest_box, status ); 
    gpr_$release_display( status );

}

/*
 * Map a 24 bit scanline to 8 bits through the dither matrix.
 */

put_line8( y )
int y;
{
    register unsigned char *r, *g, *b;
    register int i, col, row;
    gpr_$window_t dest_box;
    int n = hdr.xmax;

    r = rows[RLE_RED];
    if (hdr.ncolors == 3)
    { 
        g = rows[RLE_GREEN];
        b = rows[RLE_BLUE];
    }
    else
    {
        g = rows[0];
        b = rows[0];
    }

    for ( row = y % 16, col = 0, i = 0;
	 i <= n; i++, r++, g++, b++, col = ((col + 1) & 15) )
	dest_pixels[i] = DMAP(map[0][*r], col, row) +
	    		 DMAP(map[1][*g], col, row) * 6 +
			 DMAP(map[2][*b], col, row) * 36 + COLMAP_OFFSET;

    dest_box.window_base.x_coord = hdr.xmin;
    dest_box.window_base.y_coord = hdr.ymax - y;
    dest_box.window_size.x_size = hdr.xmin + hdr.xmax + 1;
    dest_box.window_size.y_size = 1;

    gpr_$acquire_display( status ) ;
    gpr_$write_pixels( dest_pixels, dest_box, status ); 
    gpr_$release_display( status );

}

/*
 * Map a 24 bit scanline through to get dithered black and white
 */

put_linebw( y )
int y;
{
    register unsigned char *r, *g, *b;
    register int i, col, row;
    gpr_$window_t dest_box;
    int pixel;
    int n = hdr.xmax;
    gpr_$pixel_value_t B = 0, W = 1;

    r = rows[RLE_RED];
    if (hdr.ncolors == 3)
    { 
        g = rows[RLE_GREEN];
        b = rows[RLE_BLUE];
    }
    else
    {
        g = rows[0];
        b = rows[0];
    }

    if (bw_flag)
    {
        if (inverse_flag)
        {
	    B = 1; W = 0;		/* Swap meaning of Black and White */
        }

        for ( row = y % 16, col = 0, i = 0;
	     i <= n; i++, r++, g++, b++, col = ((col + 1) & 15) )
        {
	    /* Convert to BW (uses YIQ/percentage xformation) */
	    pixel = (35*map[0][*r] + 55*map[1][*g] + 10*map[2][*b]) / 100;
	    if (pixel < 0) pixel += 256;
	    dest_pixels[i] = ((DMAP(pixel, col, row) > 0) ? W : B);
	}
    }
    else
    {
        for ( row = y % 16, col = 0, i = 0;
	     i <= n; i++, r++, g++, b++, col = ((col + 1) & 15) )
        {
	    /* Convert to BW (uses YIQ/percentage xformation) */
	    pixel = (35*map[0][*r] + 55*map[1][*g] + 10*map[2][*b]) / 100;
	    if (pixel < 0) pixel += 256;
	    if (inverse_flag)
            {
	        pixel = ((~pixel) & 0xFF);		/* Swap meaning of Black and White */
            }
            if (four_flag)
            {
	        dest_pixels[i] = DMAP(pixel, col, row);
            }
            else
            {
		dest_pixels[i] = DMAP(pixel, col, row) + COLMAP_OFFSET;
	    }
	}
    }
    dest_box.window_base.x_coord = hdr.xmin;
    dest_box.window_base.y_coord = hdr.ymax - y;
    dest_box.window_size.x_size = hdr.xmin + hdr.xmax + 1;
    dest_box.window_size.y_size = 1;

    gpr_$acquire_display( status ) ;
    gpr_$write_pixels( dest_pixels, dest_box, status ); 
    gpr_$release_display( status );

}