home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 11 / 11.iso / m / m360 / 1.ddi / PCX-SHOW.C next >
Encoding:
C/C++ Source or Header  |  1990-11-23  |  6.5 KB  |  348 lines
  1. #include "conio.h"
  2. #include "malloc.h"
  3. #include "stdio.h"
  4. #include "stdlib.h"
  5. #include "graph.h"
  6.  
  7.  
  8. #define RGB(r,g,b) (( (long)((b)<<8|(g))<<8)|(r))
  9.  
  10.  
  11. int  pcx_show(char *, int, int, int);
  12. void pcx_header(char *);
  13. void pcx_write_1(char *, int, int, int);
  14. void pcx_write_8(char *, int, int, int);
  15.  
  16.  
  17. unsigned int WIDTH, HIGH, PLANES, BITS_PIXEL, BYTES_LINE,
  18.          SCREEN_X, SCREEN_Y,
  19.          PALETTE_PCX[256][3];
  20.  
  21.  
  22. int pcx_show(char *PCX_FILE_NAME, int pal_no, int x0, int y0)
  23. {
  24.   pcx_header(PCX_FILE_NAME);
  25.  
  26.   if (BITS_PIXEL ==1)
  27.      {
  28.       _setvideomode(_MAXRESMODE);
  29.       printf("OPEN pcx file [%s]",PCX_FILE_NAME);
  30.       pcx_write_1(PCX_FILE_NAME, pal_no, x0,y0);
  31.      }
  32.  
  33.   else
  34.      {if (BITS_PIXEL==8)
  35.      {
  36.       _setvideomode(_MAXCOLORMODE);
  37.       pcx_write_8(PCX_FILE_NAME, pal_no, x0,y0);
  38.      }
  39.       else
  40.      {printf("\nCan not creat Microsoft image file for this pcx file !!!");
  41.       getch();
  42.       return(2);
  43.      }
  44.      }
  45.  
  46.   return(0);
  47. }
  48.  
  49.  
  50. /**************** READ PCX FILE'S HEADER !!!*****************/
  51. void pcx_header(char PCX_FILE_NAME[])
  52. {
  53.   register unsigned int i,j;
  54.   unsigned FA, FB, FC;
  55.  
  56.   FILE *fp_in;
  57.  
  58.  
  59.   if ((fp_in=fopen(PCX_FILE_NAME,"rb"))==NULL)
  60.      { printf("\nCan't open pcx file ...[%s]",PCX_FILE_NAME);
  61.        getch();
  62.        exit(3);
  63.      }
  64.  
  65.   fseek(fp_in,0,SEEK_SET);
  66.     FA= fgetc(fp_in);
  67.     FB= fgetc(fp_in);
  68.     FC= fgetc(fp_in);
  69.  
  70.     if (!(FA==10 && FB==5 && FC==1))
  71.        {
  72.         printf("\nError reading Header of PCX file !!! =%2x%2x%2x",FA,FB,FC);
  73.         getch();
  74.         exit(4);
  75.        }
  76.  
  77.   fseek(fp_in,   3, SEEK_SET);  BITS_PIXEL  = fgetc(fp_in);
  78.   fseek(fp_in,   8, SEEK_SET);  WIDTH       = fgetc(fp_in) + fgetc(fp_in)*256 +1 ;
  79.   fseek(fp_in,0x0A, SEEK_SET);  HIGH        = fgetc(fp_in) + fgetc(fp_in)*256 +1 ;
  80.   fseek(fp_in,0x0C, SEEK_SET);  SCREEN_X    = fgetc(fp_in) + fgetc(fp_in)*256    ;
  81.   fseek(fp_in,0x0E, SEEK_SET);  SCREEN_Y    = fgetc(fp_in) + fgetc(fp_in)*256    ;
  82.   fseek(fp_in,0x41, SEEK_SET);  PLANES      = fgetc(fp_in);
  83.   fseek(fp_in,0x42, SEEK_SET);  BYTES_LINE  = fgetc(fp_in);
  84.  
  85.  
  86.   fseek(fp_in,0x10, SEEK_SET);
  87.   for (i=0; i<16; ++i)
  88.       {
  89.        for (j=0; j<3; ++j) PALETTE_PCX[i][j]=fgetc(fp_in);
  90.       }
  91.   fclose(fp_in);
  92.  
  93. }
  94.  
  95.  
  96. void pcx_write_1(char PCX_FILE_NAME[], int pal_no, int x0, int y0)
  97. {
  98.   unsigned register int i,j;
  99.  
  100.   unsigned int BYTES_LINE_TC, jn[4]={ 0, 1, 2, 3}, j_p;
  101.  
  102.   int CH, CHi, k, n;
  103.  
  104.   size_t size;
  105.  
  106.   long int palette[256];
  107.  
  108.   char *buf, null_ch, a_line[80];
  109.  
  110.   FILE *fp_in;
  111.  
  112.   struct videoconfig vc;
  113.  
  114.   struct rccoord xy;
  115.  
  116.  
  117.  
  118.   null_ch=0;
  119.  
  120.   _getvideoconfig(&vc);
  121.  
  122.   if (x0+WIDTH>vc.numxpixels) x0=0;
  123.   if (y0+HIGH >vc.numypixels) y0=0;
  124.  
  125.  
  126.   BYTES_LINE_TC=(WIDTH+7)/8;
  127.  
  128.   size = 4*BYTES_LINE_TC+4;
  129.  
  130.   buf = malloc(size);
  131.  
  132.   buf[0]=WIDTH-(WIDTH>>8)*0x100;
  133.   buf[1]=       WIDTH>>8;
  134.   buf[2]=1;
  135.   buf[3]=0;
  136.  
  137.  
  138.  
  139.  
  140.   if (pal_no>0)
  141.      {
  142.       if (x0 > 0 || y0 > 0)
  143.      {
  144.       _setcolor(pal_no);
  145.       _rectangle(_GBORDER,x0-1, y0-1, WIDTH+x0, HIGH+y0);
  146.      }
  147.      }
  148.  
  149.   if (PLANES>=3 || BITS_PIXEL==8)
  150.      {
  151.       for (i=0; i<vc.numcolors; i++)
  152.       {
  153.        palette[i]=RGB(PALETTE_PCX[i][0]/4, PALETTE_PCX[i][1]/4, PALETTE_PCX[i][2]/4);
  154.        _remappalette(i,palette[i]);
  155.       }
  156.       if (!_remapallpalette(palette))
  157.      {
  158.       printf("Microsoft C set color palette ERROR !!!");
  159.       getch();
  160.       exit(6);
  161.      }
  162.      }
  163.  
  164.   fp_in  = fopen(PCX_FILE_NAME,"rb");
  165.   fseek(fp_in,  0x80, SEEK_SET);
  166.  
  167.   for (i=0; i<HIGH; ++i)
  168.       {
  169.        /*_settextposition(2,1); printf("LINE:[%3d]",i);*/
  170.  
  171.        for (j=0; j<PLANES; ++j)
  172.        {
  173.         k=0;
  174.         do
  175.            {
  176.         CH=fgetc(fp_in);
  177.         if (CH < 0xC1)
  178.            {
  179.             a_line[k]=CH;
  180.             k=k+1;
  181.            }
  182.         else
  183.            {
  184.             n = CH-0xC0;
  185.             CHi = fgetc(fp_in);
  186.             do
  187.                {
  188.             a_line[k]=CHi;
  189.             n=n-1;
  190.             k=k+1;
  191.                }
  192.             while (n>0);
  193.            }
  194.            }
  195.         while (k<BYTES_LINE);
  196.  
  197.         switch (PLANES)
  198.            {
  199.             case 4 : j_p=jn[j] * BYTES_LINE_TC +4 ;
  200.                  for(k=0; k<BYTES_LINE_TC; ++k) buf[j_p++]=a_line[k];
  201.                  break;
  202.  
  203.             case 3 : j_p=jn[j] * BYTES_LINE_TC +4;
  204.                  for(k=0; k<BYTES_LINE_TC; ++k) buf[j_p]=a_line[k];
  205.                  if (j==2)
  206.                 {j_p=3 * BYTES_LINE_TC +4;
  207.                  for(k=0; k<BYTES_LINE_TC; ++k) buf[j_p++]=a_line[k];
  208.                 }
  209.                  break;
  210.  
  211.             case 2 : for (n=j*2; n<j*2+2; ++n)
  212.                  {j_p=n * BYTES_LINE_TC + 4;
  213.                   for(k=0; k<BYTES_LINE_TC; ++k) buf[j_p++]=a_line[k];
  214.                  }
  215.                  break;
  216.  
  217.             case 1 : for (n=j; n<4; ++n)
  218.                  {j_p=jn[n] * BYTES_LINE_TC +4;
  219.                   for(k=0; k<BYTES_LINE_TC; ++k) buf[j_p++]=a_line[k];
  220.                  }
  221.                  break;
  222.            }
  223.        }
  224.        _putimage( x0, y0+i, buf, _GPSET);
  225.       }
  226.  
  227.   fclose(fp_in);
  228.   free(buf);
  229.  
  230.  
  231. }
  232.  
  233.  
  234.  
  235.  
  236. void pcx_write_8(char PCX_FILE_NAME[], int pal_no, int x0, int y0)
  237. {
  238.   unsigned register int i,j;
  239.  
  240.   unsigned int BYTES_LINE_TC, j_p;
  241.  
  242.   int CH, CHi, k, n;
  243.  
  244.   size_t size;
  245.  
  246.   long int palette[256];
  247.  
  248.   char *buf, null_ch, a_line[512];
  249.  
  250.   FILE *fp_in;
  251.  
  252.   struct videoconfig vc;
  253.  
  254.   struct rccoord xy;
  255.  
  256.  
  257.  
  258.   null_ch=0;
  259.  
  260.   _getvideoconfig(&vc);
  261.  
  262.   if (x0+WIDTH>vc.numxpixels) x0=0;
  263.   if (y0+HIGH >vc.numypixels) y0=0;
  264.  
  265.   if (pal_no>0)
  266.      {
  267.       if (x0 > 0 || y0 > 0)
  268.      {
  269.       _setcolor(pal_no);
  270.       _rectangle(_GBORDER,x0-1, y0-1, WIDTH+x0, HIGH+y0);
  271.      }
  272.      }
  273.  
  274.   BYTES_LINE_TC=WIDTH;
  275.  
  276.   size = BYTES_LINE_TC+4;
  277.  
  278.   buf= malloc(size);
  279.  
  280.   fp_in  = fopen(PCX_FILE_NAME,"rb");
  281.   fseek(fp_in, 0x80, SEEK_SET);
  282.  
  283.   for (i=0; i<HIGH; ++i)
  284.       {
  285.        buf[0]=WIDTH*8-((WIDTH*8)>>8)<<8;
  286.        buf[1]=(WIDTH*8)>>8;
  287.        buf[2]=1;
  288.        buf[3]=0;
  289.        k=0;
  290.        do
  291.       {
  292.        CH=fgetc(fp_in);
  293.        if (CH < 0xC1)
  294.           {
  295.            a_line[k]=CH;
  296.            k=k+1;
  297.           }
  298.        else
  299.           {
  300.            n = CH-0xC0;
  301.            CHi = fgetc(fp_in);
  302.            do
  303.           {
  304.            a_line[k]=CHi;
  305.            n=n-1;
  306.            k=k+1;
  307.           }
  308.            while (n>0);
  309.           }
  310.       }
  311.        while (k<BYTES_LINE_TC);
  312.  
  313.        for(k=0,j_p=4; k<BYTES_LINE_TC; ++k) buf[j_p++]=a_line[k];
  314.        _putimage( x0, y0+i, buf, _GPSET);
  315.       }
  316.  
  317.   free(buf);
  318.  
  319.   do {} while (fgetc(fp_in)!=0xC);
  320.   for (i=0; i<256; i++)
  321.       {
  322.        for (j=0; j<3; ++j) PALETTE_PCX[i][j]=fgetc(fp_in);
  323.       }
  324.   fclose(fp_in);
  325.  
  326.   if (PLANES>=3 || BITS_PIXEL==8)
  327.      {
  328.       for (i=0; i<vc.numcolors; i++)
  329.       {
  330.        palette[i]=RGB(PALETTE_PCX[i][0]/4, PALETTE_PCX[i][1]/4, PALETTE_PCX[i][2]/4);
  331.        _remappalette(i,palette[i]);
  332.       }
  333.       if (!_remapallpalette(palette))
  334.      {
  335.       printf("Microsoft C set color palette ERROR !!!");
  336.       getch();
  337.       exit(6);
  338.      }
  339.      }
  340.  
  341. }
  342.  
  343.  
  344.  
  345.  
  346.  
  347.  
  348.