home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 174.lha / BezSurf / readilbm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-28  |  8.6 KB  |  397 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include "readilbm.h"
  4.  
  5. #define FALSE 0
  6. #define TRUE 1
  7.  
  8. #define RED 0
  9. #define GRN 1
  10. #define BLU 2
  11.  
  12.  /* color to grey conversion methods */
  13.  
  14. #define AVERAGE 0
  15. #define LUMIN    1
  16. #define DIST     2
  17. #define REDONLY  3
  18. #define GREENONLY 4
  19. #define BLUEONLY 5
  20.  
  21. #define MakeID(a,b,c,d) ( ((a)<<24) | ((b)<<16) | ((c)<<8) | (d) )
  22.  
  23. #define ID_FORM MakeID('F','O','R','M')
  24. #define ID_ILBM MakeID('I','L','B','M')
  25. #define ID_BMHD MakeID('B','M','H','D')
  26. #define ID_CMAP MakeID('C','M','A','P')
  27. #define ID_CAMG MakeID('C','A','M','G')
  28. #define ID_BODY MakeID('B','O','D','Y')
  29.  
  30. #define ROUNDUP(x) ( ((x)+1) & (~1L) )
  31.  
  32.  
  33.  
  34. static struct CHUNK {
  35.     unsigned long Id, Size;
  36. } Chunk;
  37.  
  38. static unsigned char   cmap[32][3];
  39.  
  40. struct BMHD {
  41.     short w,h,x,y;
  42.     char npl,mask,compress,pad1;
  43.     short transparentColor;
  44.     char xAspect,yAspect;
  45.     short pageWidth,pageHeight;
  46. };
  47.  
  48.  
  49. static short    Color[32],              /* output colors        */
  50.                 Method = AVERAGE;       /* color conversion     */
  51. static short     numcolors;
  52.  
  53. static
  54. FILE            *fin;                   /* input file           */
  55.  
  56. extern char     *malloc();
  57.  
  58. static void FRead();
  59. static void ReadBMHD();
  60. static void ReadChunk();
  61. static void RastOut();
  62. static void HamOut();
  63. static char GetIlbmVal();
  64. static void InitColorMappings();
  65. static short Convert();
  66. static void ReadDecomLine();
  67. static void ProcessRows();
  68.  
  69. #define ABORT(str) { OutErr(str); goto ErrorExit; }
  70.  
  71.  
  72. void SetGreyModel( model )
  73.     int model;
  74. {
  75.     Method = model;
  76. }
  77.  
  78.  /*
  79.   * main routine for reading in an iff file
  80.   */
  81.  
  82. void ReadIlbm(filename)
  83.     char *filename;
  84. {
  85.     struct BMHD bmhd;
  86.     long    ILBMid;
  87.     unsigned char cmapFlag = FALSE,
  88.                   bmhdFlag = FALSE;
  89.  
  90.  
  91.     if ((fin = fopen (filename, "r")) == NULL) {
  92.         OutErr ("ERROR: cannot open input file");
  93.         return;
  94.     }
  95.     /* read in iff file */
  96.  
  97.     ReadChunk ();
  98.     if (Chunk.Id != ID_FORM)
  99.         ABORT ("Not an IFF File");
  100.  
  101.     FRead (&ILBMid, 4);
  102.     if (ILBMid != ID_ILBM)
  103.         ABORT ("Not an ILBM File");
  104.  
  105.     while (1) {
  106.         long camgdata;
  107.  
  108.         ReadChunk ();
  109.  
  110.         if (Chunk.Id == ID_BODY)
  111.             break;
  112.  
  113.         if( feof( fin ) ) {
  114.             ABORT("reached end of file without seeing body\n");
  115.         }
  116.  
  117.         switch (Chunk.Id) {
  118.             case ID_CMAP:
  119.                 FRead (cmap, Chunk.Size);
  120.                 numcolors = Chunk.Size/3;
  121.                 cmapFlag = TRUE;
  122.                 break;
  123.             case ID_BMHD:
  124.                 ReadBMHD (&bmhd);
  125.                 bmhdFlag = TRUE;
  126.                 break;
  127.             case ID_CAMG:
  128.                 FRead( &camgdata, sizeof(camgdata) );
  129.                 break;
  130.             default:            /* unknown identifier */
  131.                 fseek( fin, Chunk.Size, 1);
  132.                 break;
  133.         }
  134.     }
  135.     if (!cmapFlag) {
  136.         ABORT("IFF file does not contain a CMAP chunk before the BODY\n");
  137.     }
  138.  
  139.     if (!bmhdFlag) {
  140.         ABORT("IFF file does not contain a BMHD chunk before the BODY\n");
  141.     }
  142.  
  143.     InitColorMappings();
  144.     if( OpenImgPix( bmhd.w, bmhd.h, Convert(0xf, 0xf, 0xf)) ) {
  145.         ProcessRows(&bmhd);
  146.     }
  147.  
  148.     ErrorExit:
  149.         fclose( fin);
  150. }
  151.  
  152. static void ProcessRows(bmhd)
  153.     struct BMHD *bmhd;
  154. {
  155.     char *rastlist[6];
  156.     char *Raster;
  157.     int depth, i, v, pixwidth;
  158.     int BytePerLine;
  159.  
  160.     depth = bmhd->npl;
  161.     pixwidth = bmhd->w;
  162.     BytePerLine =(pixwidth+7) / 8;
  163.  
  164.  
  165.     Raster = (char *) malloc (BytePerLine * depth);
  166.  
  167.     if(!Raster ) {
  168.         OutErr("ProcessRows:could not allocate Raster");
  169.         return;
  170.     }
  171.  
  172.     for( i = 0; i < depth; i++ ) {
  173.         rastlist[i] = Raster + BytePerLine*i;
  174.     }
  175.  
  176.     for( v = 0; v < bmhd->h; v++) {
  177.         switch (bmhd->compress) {
  178.             case 0:
  179.                 FRead (Raster, BytePerLine * depth);
  180.                 break;
  181.             case 1:
  182.                 for( i = 0; i < depth; i++) {
  183.                     ReadDecomLine( BytePerLine, rastlist[i]);
  184.                 }
  185.                 break;
  186.             default:
  187.                 ABORT ("Unknown Compression type in BODY");
  188.  
  189.         }
  190.         if(depth == 6 ) {
  191.             HamOut( rastlist, pixwidth, v);
  192.         }
  193.         else {
  194.             RastOut( rastlist, pixwidth, v, depth);
  195.         }
  196.     }
  197.  
  198.     ErrorExit:
  199.         if( Raster ) free(Raster);
  200. }
  201.  
  202.  
  203. static void ReadDecomLine(linebytes, rp)
  204.     int linebytes;
  205.     char *rp;
  206. {
  207.     int runlen;
  208.     char pixel;
  209.  
  210.     while (linebytes) {
  211.         runlen = getc (fin);
  212.         if (runlen > 127)
  213.             runlen -= 256;
  214.         if (runlen >= 0) {
  215.             runlen++;
  216.             FRead (rp, runlen);
  217.             rp += runlen;
  218.             linebytes -= runlen;
  219.         }
  220.         else {
  221.             runlen = -runlen + 1;
  222.             linebytes -= runlen;
  223.             pixel = getc (fin);
  224.             do
  225.                 *(rp++) = pixel;
  226.             while (--runlen);
  227.         }
  228.     }
  229. }
  230.  
  231.  /*
  232.   * Convert - convert (r,g,b) to hex greyscale.
  233.   */
  234.  
  235. static short Convert(r,g,b)
  236.     unsigned char   r,g,b;
  237. {
  238.     short   i,
  239.             rd, gd, bd,
  240.             min,
  241.             dist,
  242.             best;
  243.  
  244.  /* convert color according to 'Method' */
  245.     switch (Method) {
  246.         case AVERAGE:           /* average r,g,b to obtain grey level */
  247.             return ((r + g + b) / 3);
  248.         case LUMIN:             /* use NTSC luminescence as grey level */
  249.             return ((r * 30 + g * 59 + b * 11) / 100);
  250.         case DIST:          /* use grey with minimum distance in color */
  251.             min = 15*15 * 3;
  252.             for( i = 0; i < numcolors; i++ ) {
  253.                 rd = r -i;
  254.                 gd = g - i;
  255.                 bd = b - i;
  256.                 dist = rd * rd + gd * gd + bd * bd;
  257.                 if( dist < min ) {
  258.                     min = dist; best = i;
  259.                 }
  260.             }
  261.             return( best );
  262.         case REDONLY:
  263.             return(r);
  264.         case GREENONLY:
  265.             return(g);
  266.         case BLUEONLY:
  267.             return(b);
  268.  
  269.     }
  270. }                               /* Convert */
  271.  
  272. static void InitColorMappings()
  273. {
  274.     int     i;
  275.  
  276.  /* put colors in 4-bit range and Convert */
  277.     for (i = 0; i < 32; i++) {
  278.         cmap[i][RED] >>= 4;
  279.         cmap[i][GRN] >>= 4;
  280.         cmap[i][BLU] >>= 4;
  281.         Color[i] = Convert (cmap[i][RED], cmap[i][GRN], cmap[i][BLU]);
  282.     }
  283. }
  284.  
  285.  
  286. /*
  287.  * leftmost pixel of byte is in most significant bit of byte
  288.  */
  289. static char GetIlbmVal( rastlist, h, bpp )
  290.     char *rastlist[6];
  291.     int h, bpp;
  292. {
  293.     int i;
  294.     char value = 0;
  295.     short mask, bytep;
  296.  
  297.     mask = 0x80 >> ( h & 7);
  298.     bytep = h >> 3;
  299.  
  300.     for( i = bpp-1; i >= 0; i-- ) {
  301.         value <<= 1;
  302.         value |= (*(rastlist[i]+bytep) & mask) ? 1: 0;
  303.     }
  304.     return( value );
  305. }
  306.  
  307.  /*
  308.   * HamOut - output ham image in hex.
  309.   */
  310. static void HamOut(rastlist, pixwidth, v)
  311.     char *rastlist[6];
  312.     int pixwidth, v;
  313. {
  314.     unsigned char   lastred = 0,
  315.                     lastgreen = 0,
  316.                     lastblue = 0;
  317.     int     h;
  318.     char pixval;
  319.     for( h = 0; h <pixwidth; h++ ) {
  320.         short shade;
  321.  
  322.         shade = GetIlbmVal(rastlist, h, 6);
  323.         pixval = shade & 0x0F;
  324.         switch (shade & 0x30) {
  325.         case 0x00:
  326.             lastred = cmap[pixval][RED];
  327.             lastgreen = cmap[pixval][GRN];
  328.             lastblue = cmap[pixval][BLU];
  329.             shade = Color[pixval];
  330.             break;
  331.         case 0x10:
  332.             lastblue = pixval;
  333.             shade = Convert(lastred,lastgreen,lastblue);
  334.             break;
  335.         case 0x20:
  336.             lastred = pixval;
  337.             shade = Convert(lastred,lastgreen,lastblue);
  338.             break;
  339.         case 0x30:
  340.             lastgreen = pixval;
  341.             shade = Convert(lastred,lastgreen,lastblue);
  342.         }
  343.         SetImgPix(h, v, shade);
  344.     }
  345. }
  346.  
  347.  /*
  348.   * RastOut - handle normal bit mapped images
  349.   */
  350. static void RastOut(rastlist, pixwidth, v, depth)
  351.     char *rastlist[6];
  352.     int pixwidth, v, depth;
  353. {
  354.     int h, bit;
  355.     for( h = 0; h < pixwidth; h++ ) {
  356.         short shade;
  357.         shade = Color[GetIlbmVal( rastlist, h, depth)];
  358.         SetImgPix( h, v, shade);
  359.     }
  360. }
  361.  
  362.  /*
  363.   * ReadChunk - read in an IFF Chunk.
  364.   */
  365.  
  366. static void ReadChunk()
  367. {
  368.     FRead (&Chunk, sizeof (Chunk));
  369.  
  370. }                               /* ReadChunk */
  371.  
  372.  /*
  373.   * ReadBMHD - read the BMHD structure.
  374.   */
  375.  
  376. static void ReadBMHD(bmhd)
  377. struct BMHD *bmhd;
  378. {
  379.     FRead (bmhd, Chunk.Size);
  380. }                               /* ReadBMHD */
  381.  
  382.  
  383.  /*
  384.   * FRead - read 'len' bytes to 'pointer' while checking for an error.
  385.   */
  386.  
  387. static void FRead(pointer,len)
  388. char    *pointer;
  389. int     len;
  390. {
  391.     if (fread (pointer, len, 1, fin) == 0)  {
  392.         char outbuff[90];
  393.         sprintf(outbuff,"Fread Error in reading input file at %d ", ftell(fin));
  394.         OutErr(outbuff);
  395.     }
  396. }                               /* FRead */
  397.