home *** CD-ROM | disk | FTP | other *** search
/ GRIPS 2: Government Rast…rocessing Software & Data / GRIPS_2.cdr / dos / imcomp / display.c < prev    next >
C/C++ Source or Header  |  1990-12-29  |  9KB  |  424 lines
  1. /* =======================================================================*
  2.  *     imcomp.c   (from imgiotar.c and others)            by Dai 5/11/87*
  3.  * =======================================================================*/
  4. /* Modified by M. Krogh, NCSA, June 3, 1988                               */
  5. /* This source will make either the display driver for the Number Nine    */
  6. /* Revolution 512 Graphics board or the Targa M8 Graphics board.  Both    */
  7. /* boards are designed to work in an IBM PC or compatible.                */
  8.  
  9. /* If 'TARGAM8' is defined, this source will compile for the M8 board.    */
  10. /* If 'NINE8' is defined, this source will compile for the #9 board.      */
  11. #define TARGAM8 1
  12. /* #define NINE8 1 */
  13.  
  14.  
  15. #include "def.h"
  16. #include <fcntl.h>
  17. #define DISKIO 1
  18. #include "diskio.h"
  19. #include "tardev.h"
  20. #include "targah.h"
  21. #ifdef TARGAM8
  22. int sw= 0;
  23. #else
  24. int sw= 1;  /* for number 9 need to flip image */
  25. #endif
  26. #ifdef TARGAM8
  27. struct M8Struct  *m8;    
  28. /* krogh - next line added. */
  29. extern struct TARStruct *targa;
  30. #endif
  31. /*-------------------------------------------------------------------------*/
  32. COLSIZE rbuff[1024];
  33. COLSIZE bline[1024],gbuff[256];
  34.  
  35. main(argc,argv)
  36. int argc; char *argv[];
  37. {
  38.     char fnam[20];
  39.     if (--argc)
  40.         {
  41.         strcpy(fnam,*(++argv));
  42.         }
  43.     else
  44.         {
  45.         printf("syntax: imcomp filename.ext\n");
  46.         exit(1);
  47.         }
  48. #ifdef TARGAM8
  49.     GraphInit(-1);            /* INITIALIZE TARGA BOARD */
  50. #endif
  51.     slutone();
  52.     zgetimg(fnam);
  53.     exit(0);
  54. }
  55.  
  56.  
  57.  
  58. /**********************
  59.  *     GETIMAGE       *
  60.  **********************/
  61. /*=======================================================================*/
  62.   zgetimg(fname)
  63.   char *fname;
  64. /*=======================================================================*/
  65. {
  66.     register int fd;
  67.     int i, xstart, ystart, xsize, ysize, y, nbytes;
  68.     unsigned char *r, *g, *b;
  69.     unsigned char *q, *rz;
  70.        int x;
  71.     int sx,sy,j,k;
  72.     int lutarr = 0;
  73.     unsigned int temp;
  74.     char tst[20];
  75.  
  76.     if ((fd = open(fname,O_RDONLY|O_BINARY)) == ERROR)
  77.         {
  78.         fprintf(stderr,"can't open file %s\n",fname);
  79.         return;
  80.         }
  81.     if (read(fd,tst,16) == ERROR)
  82.         {
  83.         close(fd);
  84.         fprintf(stderr,"read error\n");
  85.         return;
  86.            }
  87.     for(sx= 0; sx<8; sx++)
  88.         {
  89.         if (tst[sx]==' ')
  90.             tst[sx] = '0';
  91.         }
  92.     sx = tst[0] - '0';
  93.     sx = sx + (tst[1] - '0') * 10;
  94.     sx = sx + (tst[2] - '0') * 100;
  95.     sx = sx + (tst[3] - '0') * 1000;
  96.     sy = tst[4] - '0';
  97.     sy = sy + (tst[5] - '0') * 10;
  98.     sy = sy + (tst[6] - '0') * 100;
  99.     sy = sy + (tst[7] - '0') * 1000;
  100.     lseek(fd,(long)(1024+16),0);
  101.     xsize = sx;
  102.     ysize = sy;
  103.     xstart = 0;
  104.     ystart = 0;
  105.     sy = sy / 4;
  106.     nbytes = 1<<TNUMB;
  107.     q = (unsigned char *)bline;
  108.     if (tst[11] == 'I' && tst[10] == 'F' && tst[9] == '8')
  109.         {
  110.         if (sw)
  111.             {
  112.                 for(y= ystart+ysize-1; y>=ystart; --y)
  113.                 {
  114.                    if (read(fd,q,nbytes*xsize) == ERROR)
  115.                     {
  116.                     close(fd);
  117.                     fprintf(stderr,"read error\n");
  118.                     return;
  119.                        }
  120.                     pline(xstart,y,bline,xsize,0);
  121.                    }
  122.             }
  123.         else
  124.             {
  125.                 for(y= ystart; y <= ystart+ysize-1; ++y)
  126.                    {  
  127.                    if (read(fd,q,nbytes*xsize) == ERROR)
  128.                     { 
  129.                     close(fd);
  130.                     fprintf(stderr,"read error\n");
  131.                     return;
  132.                     }
  133.                     pline(xstart,y,bline,xsize,0);
  134.                    }
  135.             }
  136.            }
  137.     else if(tst[11] == 'I' && tst[10] == 'F' && tst[9] == '2')
  138.         {
  139.         if (sw)
  140.             y = ystart + ysize - 1;
  141.         else
  142.             y = ystart;
  143.         for(; sy>0; sy--)
  144.             {
  145.             if (read(fd,q,sx) == ERROR)
  146.                 {
  147.                 close(fd);
  148.                 fprintf(stderr,"read error\n");
  149.                 return;
  150.                   }
  151.             for(i= 3; i>=0; i--)
  152.                 {
  153.                 k = 0;
  154.                 for(j= 0; j<sx; j= j+4)
  155.                     {
  156.                     rz = (char *) &temp;
  157.                     *rz++ = bline[j+2];
  158.                     *rz = bline[j+3];
  159.                     temp = temp >> (i * 4);
  160.                     if (temp & 010) rbuff[k++] = bline[j+1];
  161.                     else            rbuff[k++] = bline[j];
  162.                     if (temp & 04)  rbuff[k++] = bline[j+1];
  163.                     else            rbuff[k++] = bline[j];
  164.                     if (temp & 02)  rbuff[k++] = bline[j+1];
  165.                     else            rbuff[k++] = bline[j];
  166.                     if (temp & 01)  rbuff[k++] = bline[j+1];
  167.                     else            rbuff[k++] = bline[j];
  168.                     }   /* for j  */
  169.                 pline(xstart,y,rbuff,xsize,0);
  170.                 if (sw)
  171.                     y--;
  172.                 else
  173.                     y++;
  174.                 }   /* for i */
  175.             }   /* for ; */
  176.               }
  177.     else
  178.         {
  179.         close(fd);
  180.         fprintf(stderr,"wrong image file\n");
  181.         return;
  182. /*        return(cerror(-1,"wrong image file")); */
  183.         }
  184.     lseek(fd,(long)(16),0);
  185.     if (read(fd,bline,1024) == ERROR)
  186.         {
  187.         close(fd);
  188.         fprintf(stderr,"read error\n");
  189.         return;
  190.         }
  191.     r = (unsigned char *) rbuff;
  192.     g = (unsigned char *) gbuff;
  193.     b = (unsigned char *) fname;
  194.     for(i = 0; i < 1024; ++r,++g,++b)
  195.         {
  196.         *b = bline[i++];
  197.         *g = bline[i++];
  198.         *r = bline[i++];
  199.         i++;
  200.         }
  201.     r = r - 256;
  202.     g = g - 256;
  203.     b = b - 256;
  204.     zputmap(0,r,g,b,0);
  205.     close(fd);
  206.     return;
  207.  
  208. }   /* zgetimg::end  TARGAM8 */
  209.  
  210.  
  211.  
  212.  
  213. /**************** pline *********************
  214.  * copy a horizontal run of pixels from memory
  215.  * onto the screen.
  216.  *********************************************/
  217. pline(x, y, bl, xs, xm)
  218. int x, y, xs, xm;
  219. COLSIZE *bl;
  220. {      
  221.    register COLSIZE *addr;
  222.  
  223.    addr = POINT(x,y);
  224.     memcpy(addr,bl,xs<<TNUMB);
  225. }
  226.  
  227.  
  228.  
  229. #ifdef TARGAM8
  230. zgetmap(io,r,g,b, num)
  231. char *r, *g, *b;
  232. int num, io;
  233. {
  234.     int tempMap;
  235.  
  236.     SetM8Index(0);        /*  Select the starting index  */
  237.     SetM8Function(11);    /*  access the input lookup table (*/
  238.     tempMap  = m8->inMap;
  239.     FASTVWait();        /*  wait for vertical blanking */
  240.     SetM8OutMap(num&7);    /*  select the desired map     */
  241.  
  242.     SetM8Function(8);
  243.     getmap(targa->iobase+M8READ,256,r);
  244.     SetM8Index(0);        /*  Select the starting index  */
  245.     SetM8Function(9);
  246.     getmap(targa->iobase+M8READ,256,g);
  247.     SetM8Index(0);        /*  Select the starting index  */
  248.     SetM8Function(10);
  249.     getmap(targa->iobase+M8READ,256,b);
  250.  
  251.     SetM8InMap(tempMap);
  252. }
  253.  
  254.  
  255. zputmap(io,r,g,b, num)
  256. char *r, *g, *b;
  257. int num, io;
  258. {
  259.     int tempMap;
  260.     if(io)          /* if input map load... */
  261.         {
  262.         SetM8Index(0);    /*  Select the starting index  */
  263.          if ( (tempMap  = m8->inMap) != num ) 
  264.              {
  265.                 FASTVWait();        /*  wait for vertical blanking */
  266.              SetM8InMap(num);    /*  select the desired map     */
  267.             SetM8Function(8);
  268.             }
  269.          else
  270.             {
  271.             SetM8Function(8);
  272.             FASTVWait();
  273.             }
  274.              putmap(targa->iobase+M8WRITE,256,r);
  275.              SetM8InMap(tempMap);
  276.          return;
  277.         }
  278.     else    /* output a map */
  279.         {
  280.         tempMap  = m8->inMap;
  281.          FASTVwait();
  282.                SetM8Index(0);        /*  Select the starting index  */
  283.          SetM8Function(11);    /*  access the input lookup table (*/
  284.          SetM8OutMap(num & 7);   /*  select the desired map     */
  285.          SetM8Function(8);
  286.                 pputmap(targa->iobase+M8WRITE,256,r);
  287.          SetM8Function(9);
  288.          pputmap(targa->iobase+M8WRITE,256,g);
  289.  
  290.         SetM8Function(10);
  291.         pputmap(targa->iobase+M8WRITE,256,b);
  292.         SetM8InMap(tempMap);
  293.         return;
  294.         }
  295. }
  296.  
  297.  
  298. /*
  299.  *    FASTVWait:    Wait for next Border Region at the
  300.  *           Bottom of a Screen
  301.  *
  302.  */
  303.  
  304. extern  int  GetLine();
  305.  
  306. FASTVwait()
  307. {
  308.     while (GetLine(RASTERREG) <240);
  309. }
  310.  
  311. pputmap(io, count, array)
  312. int   io;         /* array in IO space to Write to */
  313. int   count;           /*  Number of bytes to read  */
  314. char  *array;         /*  pointer to byte array    */
  315. {
  316. int i,j;
  317. for(j=0; j<8; j++)
  318.     {
  319.     FASTVwait();
  320.     for (i=0; i<32; i++)
  321.         OUTPORTB(io,*(array++));
  322.     }
  323. return;
  324. }
  325. #endif
  326.  
  327.  
  328. #ifdef NINE8
  329. zputmap(io,r,g,b, num)
  330. char *r, *g, *b;
  331. int num, io;
  332. {
  333. /*    char *memcpy(); */
  334.     while(!(*NNSTATS & NNVBIT));
  335.     memcpy(NNRED,r,256);
  336.     while(!(*NNSTATS & NNVBIT));
  337.     memcpy(NNGRN,g,256);
  338.     while(!(*NNSTATS & NNVBIT));
  339.     memcpy(NNBLU,b,256);
  340. }
  341. #endif
  342.  
  343.  
  344. slutone()
  345. {
  346. #ifdef TARGAM8
  347.     int i;
  348.     unsigned char r[256], g[256], b[256], bw[256];
  349.  
  350.     for (i = 0; i < 64; i++)
  351.         bw[i] = i;
  352.     for (i =  0; i < 64; i++) {
  353.         r[i] = g[i] = b[i] = i*4;   /*  black and white */
  354.     }
  355.     for (i =  64; i < 96; i++) {
  356.         r[i] = (i-64)*8;   /*  RED */
  357.         g[i] = b[i] = 0;
  358.     }
  359.     for (i =  96; i <128; i++) {
  360.         g[i] = (i-96)*8;   /*  green */
  361.         r[i] = b[i] = 0;
  362.     }
  363.     for (i = 128; i <160; i++) {
  364.         b[i] = (i-128)*8;   /*  BLUE */
  365.         g[i] = r[i] = 0;
  366.     }
  367.     for (i = 160; i <192; i++) {
  368.         r[i] = b[i] = (i-160)*8;   /*  magenta */
  369.         g[i] = 0;
  370.     }
  371.     for (i = 192; i < 224; i++) {
  372.         b[i] = g[i] = (i-192)*8;   /*  CYAN */
  373.         r[i] = 0;
  374.     }
  375.     for (i =  224; i < 256; i++) {
  376.         g[i] = r[i] = (i-224)*8;   /*  YELLOW */
  377.         b[i] = 0;
  378.     }
  379.  
  380. /* write it out */
  381. /*    PutM8BWAll(0,0); setup input map */
  382.     zputmap(1,bw,bw,bw,1);
  383.     zputmap(0,bw,bw,bw,1);
  384.     zputmap(0,r,g,b,0);      /* first arg is output/input */
  385.     return;
  386. #endif
  387. #ifdef NINE8
  388.     int i;
  389.     unsigned char r[256], g[256], b[256];
  390.  
  391.     for (i =  0; i < 64; i++) {
  392.         r[i] = g[i] = b[i] = i*4;   /*  black and white */
  393.     }
  394.     for (i =  64; i < 96; i++) {
  395.         r[i] = (i-64)*8;   /*  RED */
  396.         g[i] = b[i] = 0;
  397.     }
  398.     for (i =  96; i <128; i++) {
  399.         g[i] = (i-96)*8;   /*  green */
  400.         r[i] = b[i] = 0;
  401.     }
  402.     for (i = 128; i <160; i++) {
  403.         b[i] = (i-128)*8;   /*  BLUE */
  404.         g[i] = r[i] = 0;
  405.     }
  406.     for (i = 160; i <192; i++) {
  407.         r[i] = b[i] = (i-160)*8;   /*  magenta */
  408.         g[i] = 0;
  409.     }
  410.     for (i = 192; i < 224; i++) {
  411.         b[i] = g[i] = (i-192)*8;   /*  CYAN */
  412.         r[i] = 0;
  413.     }
  414.     for (i =  224; i < 256; i++) {
  415.         g[i] = r[i] = (i-224)*8;   /*  YELLOW */
  416.         b[i] = 0;
  417.     }
  418. /* write it out */
  419.     zputmap(0,r,g,b,0);
  420. #endif
  421.  
  422. }
  423.  
  424.