GRIPS 2: Government Rast…rocessing Software & Data/GRIPS_2.cdr/dos/seq/src/seqp.c

C/C++ Source or Header | 1990-01-07 | 6.4 KB | 268 lines

/*
*
*  Raster image display program for the IBM PC
*
*    This program takes binary images, one byte per pixel, and displays them
*  on the PC's color graphics screen.  The dimensions of the image are
*  specified on the command line, each image is read from the file
*  with block reads, then displayed in the specified position on the screen.
*  Portions of the image that do not fit on the screen are clipped.
*
*  example use:    rev  256 256 -c -m pal.pal list.dat
*     the file 'list.dat' must contain a list of file names of the images
*     that are to be displayed in sequence.
*
*  The space bar pauses and restarts the display.  Return exits after any
*  image.
*
*  the mapfile is a sequence of bytes from 0 - 255.  There are 256 red values
*  followed by 256 green values followed by 256 blue values.  They are
*  divided by 16 before use because the PGA only has 16 intensities per gun.
*
*
*  National Center for Supercomputing Applications, University of Illinois
*  153 Water Resources Building
*  605 E. Springfield Ave.
*  Champaign, IL  61820     [phone]
*
*  Tim Krauskopf            July 1986
*
*/
#include "stdio.h"
#include "fcntl.h"

#define USAGE  printf("\nUsage: %s xdim ydim [-c][-p xwhere ywhere][-m mapfile] fileofnames\n",argv[0])

#define RAWSIZE 32000
#define SCRX 640
#define SCRY 480
#define LINEPUT    pgalinea(xwhere,ywhere+i,store[i],xshow,1)


FILE *fp;
int        i,j,c,xdim,ydim,file,xshow,xwhere=0,ywhere=0;

unsigned char raw[RAWSIZE],             /* for file buffering */
    rmap[256],gmap[256],bmap[256];        /* color map, if specified */
unsigned char filename[128];
unsigned char palfile[128] = {0,0};     /* starts out = NULL */


char *store[1024],              /* one per line of image */
    *malloc(),*p;

main(argc,argv)
    int argc;
    char *argv[];
    {
    if (argc < 4 ) {               /*  requires at least 2 parameters */
        USAGE;
        exit(1);
    }

    xdim = atoi(argv[1]);       /* required parms of x and y dimensions */
    if (xdim > SCRX)
        xshow = SCRX;           /* screen limits  */
    else
        xshow = xdim;

    ydim = atoi(argv[2]);

    if (xdim < 10 || ydim < 10) {
        puts("\n Huh? ");
        exit(1);
    }

    for (i=3; i<argc; i++) {      /* look at each parm */
        if (*argv[i] == '-')
            switch ( *(argv[i]+1)) {
                case 'c':                    /*  centering  */
                    xwhere = (SCRX-xdim)/2;
                    ywhere = (SCRY-ydim)/2;
                    if (xwhere < 0)
                        xwhere = 0;            /* if larger than screen, */
                    if (ywhere < 0)            /* don't center it */
                        ywhere = 0;
                    break;
                case 'p':                    /* special position */
                    xwhere = atoi(argv[++i]);
                    ywhere = atoi(argv[++i]);
                    if (xwhere > SCRX || ywhere > SCRY) {
                        puts("\n Invalid position ");
                        USAGE;
                        exit(1);
                    }
                    break;
                case 'm':                   /* color map definition */
                    strcpy(palfile,argv[i+1]);
                    break;
                default:
                    USAGE;
                    exit(1);
            }
    }

/*
*  allocate memory for the image, if not enough, then error
*/
    if (enoughspace(xdim,ydim)) {
        puts("\n Not enough memory for image to be stored");
        exit(1);
    }

/*
*  open file with list of file names to display
*/
    if ( NULL == (fp = fopen(argv[argc-1],"ra" ))) {
        printf("\n%s: Error opening %s",argv[0],argv[3]);
        exit(1);
    }

/*
*  graphics initialization
*/
    initpga();

    if (*palfile)                        /* if there is a palette specified */
        loadpal(palfile);


/*
*  cycle through all of the file names
*/
    *filename = '\0';

    while (NULL != fgets(filename,100,fp)) {     /* while there are files */

        if (*filename < 33)
            break;               /* exit the program if end of list */

        p = filename;

        while (*p > 32)          /*  find the first non printable char or sp*/
            p++;
        *p = '\0';               /*  truncate the file name for use by open */


        if ( 0 > (file = open(filename,O_RDONLY | O_RAW))) {
            printf("\n%s: Error opening image file: %s",argv[0],filename);
            restpga();
            exit(1);
        }

        readpic(file,xdim,ydim);        /* block read from disk */

        close(file);

        for (i=0; i<ydim; i++)          /* display the image */
            LINEPUT;

/*
*  see if we should pause because of keypress
*/
        if (kbhit()) {                     /* if key(s) is pressed */
            while (kbhit())
                c = getch();            /* empty backlog */

            if (c == ' ') {
                while (!kbhit()) ;      /* wait for another to restart */
                c = getch();            /* clear buffer */
            }

            if (c != ' ') {             /* RETURN will exit program */
                fclose(fp);
                restpga();
                exit(0);
            }
        }

    }

    fclose(fp);
    restpga();
    exit(0);
}

/*************************************************************************/
/*  readpic
*
*      block read the file and copy to main memory storage
*   Block reading the hard disk (or floppy) saves enough time to pay for
*   the extra memory-to-memory move and then some.
*
*/
readpic(file,len,lines)
    int file,len,lines;
    {
    int i,lno,readsize,readfact;
    char *p;

    readfact = RAWSIZE/len - 5;
    readsize =  readfact*len;      /* get good blocking factor */

    lno = 0;
    do {
        read(file,raw,readsize);        /* read one block */
        p = raw;                        /* point to that block */

/*
*  for this block, copy each line into it's own reserved memory
*/
        for (i=0; i < readfact && lno < lines; i++) {
            movmem(p,store[lno++],len);
            p += len;
        }

    } while (lno < lines);

}

/**********************************************************************/
/*  enoughspace
*
*   make enough room for maximum row,col size
*
*   Image memory is allocated line by line because of 64K data limitation
*   of the PC.
*
*   returns error code of 1 if not enough memory
*/
enoughspace(c,l)
    int l,c;
    {
    int i;

       for (i=0; i < l; i++) {                /* allocate each line separately */
        store[i] = malloc(c);

        if (store[i] == NULL)           /* malloc returned not enough */
            return(1);
    }

    return(0);                             /* successful return */

}



loadpal(s)
    char *s;
    {
    int i;
    FILE *pfp;

    if (NULL == (pfp = fopen(s,"rb"))) {        puts("Error on palette file open ");
        restpga();        exit(2);    }
    for (i=0; i < 256 ; i++) {        fread(rmap,1,256,pfp);        fread(gmap,1,256,pfp);        fread(bmap,1,256,pfp);   }
   fclose(pfp);
/*
*  divide by 16 to fit PGA
*/

    for (i=0; i< 256; i++) {
        mapcolor(i,rmap[i]>>4,gmap[i]>>4,bmap[i]>>4);
    }


}