home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / IFF.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  10.1 KB  |  324 lines
  1. /****************************************************************************
  2. *                   iff.c
  3. *
  4. *  This file implements a simple IFF format file reader.
  5. *
  6. *  from Persistence of Vision Raytracer 
  7. *  Copyright 1992 Persistence of Vision Team
  8. *---------------------------------------------------------------------------
  9. *  Copying, distribution and legal info is in the file povlegal.doc which
  10. *  should be distributed with this file. If povlegal.doc is not available
  11. *  or for more info please contact:
  12. *
  13. *       Drew Wells [POV-Team Leader] 
  14. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  15. *       Phone: (213) 254-4041
  16. * 
  17. * This program is based on the popular DKB raytracer version 2.12.
  18. * DKBTrace was originally written by David K. Buck.
  19. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  20. *
  21. *****************************************************************************/
  22.  
  23.  
  24. #include "frame.h"
  25. #include "povproto.h"
  26.  
  27. static IMAGE_COLOUR *iff_colour_map;
  28. static int colourmap_size;
  29. static CHUNK_HEADER Chunk_Header;
  30.  
  31. #define FORM 0x464f524dL
  32. #define ILBM 0x494c424dL
  33. #define BMHD 0x424d4844L
  34. #define CAMG 0x43414d47L
  35. #define CMAP 0x434d4150L
  36. #define BODY 0x424f4459L
  37. #define CMPNONE 0
  38.  
  39. #define HAM 0x800
  40.  
  41. void iff_error()
  42. {
  43.    fprintf (stderr, "Invalid IFF file\n");
  44.    exit(1);
  45. }
  46.  
  47. int read_byte(f)
  48. FILE *f;
  49. {
  50.    int c;
  51.    if ((c = getc(f)) == EOF)
  52.       iff_error();
  53.    return (c);
  54. }
  55.  
  56. int read_word(f)
  57. FILE *f;
  58. {
  59.    int result;
  60.  
  61.    result = read_byte(f)*256;
  62.    result += read_byte(f);
  63.    return (result);
  64. }
  65.  
  66. long read_long(f)
  67. FILE *f;
  68. {
  69.    int i;
  70.    long result;
  71.  
  72.    result = 0;
  73.    for (i = 0 ; i < 4 ; i++)
  74.       result = result * 256 + read_byte(f);
  75.  
  76.    return (result);
  77. }
  78.  
  79. void Read_Chunk_Header (f, dest)
  80. FILE *f;
  81. CHUNK_HEADER *dest;
  82. {
  83.    dest->name = read_long(f);
  84.    dest->size = read_long(f);
  85. }
  86.  
  87. void Read_Iff_Image(Image, filename)
  88. IMAGE *Image;
  89. char *filename;
  90. {
  91.    FILE *f;
  92.    unsigned char **row_bytes;
  93.    int c, i, j, k, nBytes, nPlanes, compression,
  94.    mask, byte_index, count, viewmodes;
  95.    int Previous_Red, Previous_Green, Previous_Blue;
  96.    struct Image_Line *line;
  97.    unsigned long creg;
  98.  
  99.    if ((f = Locate_File(filename, READ_FILE_STRING)) == NULL) {
  100.       fprintf (stderr, "Cannot open IFF file %s\n", filename);
  101.       exit(1);
  102.    }
  103.  
  104.    Previous_Red = Previous_Green = Previous_Blue = 0;
  105.  
  106.    viewmodes = 0;
  107.    iff_colour_map = NULL;
  108.  
  109.    while (1) {
  110.       Read_Chunk_Header(f, &Chunk_Header);
  111.       switch ( IFF_SWITCH_CAST Chunk_Header.name) {
  112.       case FORM:  
  113.          if (read_long(f) != ILBM)
  114.             iff_error();
  115.          break;
  116.  
  117.       case BMHD:  
  118.          Image->iwidth = read_word(f);
  119.          Image->width = (DBL)Image->iwidth;
  120.          Image->iheight = read_word(f);
  121.          Image->height = (DBL)Image->iheight;
  122.  
  123.          read_word(f);  /* x position ignored */
  124.          read_word(f);  /* y position ignored */
  125.          nPlanes = read_byte(f);
  126.          colourmap_size = 1<<nPlanes;
  127.          read_byte(f);   /* masking ignored */
  128.          compression = read_byte(f);   /* masking ignored */
  129.          read_byte(f);   /* pad */
  130.          read_word(f);   /* Transparent colour ignored */
  131.          read_word(f);   /* Aspect ratio ignored */
  132.          read_word(f);   /* page width ignored */
  133.          read_word(f);   /* page height ignored */
  134.          break;
  135.  
  136.       case CAMG:  
  137.          viewmodes = (int) read_long(f);   /* Viewmodes */
  138.          if (viewmodes & HAM)
  139.             colourmap_size = 16;
  140.  
  141.          break;
  142.  
  143.       case CMAP:  
  144.          colourmap_size = (int) Chunk_Header.size / 3;
  145.  
  146.          if ((iff_colour_map = (IMAGE_COLOUR *) malloc(sizeof(IMAGE_COLOUR)*colourmap_size)) == NULL) {
  147.             fprintf(stderr, "Cannot allocate memory for IFF colour map\n");
  148.             exit(1);
  149.          }
  150.  
  151.          for (i = 0 ; i < colourmap_size ; i++) {
  152.             iff_colour_map[i].Red = read_byte(f);
  153.             iff_colour_map[i].Green = read_byte(f);
  154.             iff_colour_map[i].Blue = read_byte(f);
  155.             iff_colour_map[i].Alpha = 0;
  156.          }
  157.  
  158.          Previous_Red = iff_colour_map[0].Red;
  159.          Previous_Green = iff_colour_map[0].Green;
  160.          Previous_Blue = iff_colour_map[0].Blue;
  161.          for (i = colourmap_size * 3 ; (long) i < Chunk_Header.size ; i++)
  162.             read_byte(f);
  163.  
  164.          break;
  165.  
  166.       case BODY:  
  167.          if ((iff_colour_map == NULL) || (viewmodes & HAM)) {
  168.             Image->Colour_Map_Size = 0;
  169.             Image->Colour_Map = NULL;
  170.          }
  171.          else {
  172.             Image->Colour_Map_Size = colourmap_size;
  173.             Image->Colour_Map = iff_colour_map;
  174.          }
  175.  
  176.             if ((row_bytes = (unsigned char **) malloc (4*nPlanes)) == NULL) {
  177.                fprintf (stderr, "Cannot allocate memory for row bytes\n");
  178.                exit(1);
  179.             }
  180.  
  181.          for (i = 0 ; i < nPlanes ; i++)
  182.             if ((row_bytes[i] = (unsigned char *)
  183.                malloc((Image->iwidth+7)/8)) == NULL) {
  184.                fprintf (stderr, "Cannot allocate memory for row bytes\n");
  185.                exit(1);
  186.             }
  187.  
  188.          if (Image->Colour_Map == NULL) {
  189.             if ((Image->data.rgb_lines = (struct Image_Line *)
  190.                malloc(Image->iheight * sizeof (struct Image_Line)))==NULL) {
  191.                fprintf (stderr, "Cannot allocate memory for picture\n");
  192.                exit(1);
  193.             }
  194.          }
  195.          else {
  196.             if ((Image->data.map_lines = (unsigned char **)
  197.                malloc(Image->iheight * sizeof (unsigned char *)))==NULL) {
  198.                fprintf (stderr, "Cannot allocate memory for picture\n");
  199.                exit(1);
  200.             }
  201.          }
  202.  
  203.          for (i = 0 ; i < Image->iheight ; i++) {
  204.  
  205.             if (Image->Colour_Map == NULL) {
  206.                if (((Image->data.rgb_lines[i].red = (unsigned char *)
  207.                   malloc(Image->iwidth))==NULL) ||
  208.                   ((Image->data.rgb_lines[i].green = (unsigned char *)
  209.                   malloc(Image->iwidth))==NULL) ||
  210.                   ((Image->data.rgb_lines[i].blue = (unsigned char *)
  211.                   malloc(Image->iwidth))==NULL)) {
  212.                   fprintf (stderr, "Cannot allocate memory for picture\n");
  213.                   exit(1);
  214.                }
  215.             }
  216.             else {
  217.                if ((Image->data.map_lines[i] = (unsigned char *)
  218.                   malloc(Image->iwidth * sizeof(unsigned char))) == NULL) {
  219.                   fprintf (stderr, "Cannot allocate memory for picture\n");
  220.                   exit(1);
  221.                }
  222.             }
  223.  
  224.             for (j = 0 ; j < nPlanes ; j++)
  225.                if (compression == CMPNONE) {
  226.                   for (k = 0 ; k < (Image->iwidth+7)/8 ; k++)
  227.                      row_bytes[j][k] = (unsigned char)read_byte(f);
  228.                   if ((k & 1) != 0)
  229.                      read_byte(f);
  230.                }
  231.  
  232.                else {
  233.                   nBytes = 0;
  234.                   while (nBytes != (Image->iwidth+7)/8) {
  235.                      c = read_byte(f);
  236.                      if ((c >= 0) && (c <= 127))
  237.                         for (k = 0 ; k <= c ; k++)
  238.                            row_bytes[j][nBytes++] = (unsigned char)read_byte(f);
  239.                      else if ((c >= 129) && (c <= 255)) {
  240.                         count = 257-c;
  241.                         c = read_byte(f);
  242.                         for (k = 0 ; k < count ; k++)
  243.                            row_bytes[j][nBytes++] = (unsigned char)c;
  244.                      }
  245.                   }
  246.                }
  247.  
  248.             mask = 0x80;
  249.             byte_index = 0;
  250.             for (j = 0 ; j < Image->iwidth ; j++) {
  251.                creg = 0;
  252.                for (k = nPlanes-1 ; k >= 0 ; k--)
  253.                   if (row_bytes[k][byte_index] & mask)
  254.                      creg = creg*2 + 1;
  255.                   else
  256.                      creg *= 2;
  257.  
  258.  
  259.                if (viewmodes & HAM) {
  260.                   line = &Image->data.rgb_lines[i];
  261.                   switch (creg >> 4) {
  262.                   case 0:
  263.                      Previous_Red = line->red[j] = (unsigned char)iff_colour_map[creg].Red;
  264.                      Previous_Green = line->green[j] = (unsigned char)iff_colour_map[creg].Green;
  265.                      Previous_Blue = line->blue[j] = (unsigned char)iff_colour_map[creg].Blue;
  266.                      break;
  267.  
  268.                   case 1:
  269.                      line->red[j] = (unsigned char)Previous_Red;
  270.                      line->green[j] = (unsigned char)Previous_Green;
  271.                      line->blue[j] = (unsigned char)(((creg & 0xf)<<4) + (creg&0xf));
  272.                      Previous_Blue = (int) line->blue[j];
  273.                      break;
  274.  
  275.                   case 2:
  276.                      line->red[j] = (unsigned char)(((creg & 0xf)<<4) + (creg&0xf));
  277.                      Previous_Red = (int) line->red[j];
  278.                      line->green[j] = (unsigned char)Previous_Green;
  279.                      line->blue[j] = (unsigned char)Previous_Blue;
  280.                      break;
  281.  
  282.                   case 3:
  283.                      line->red[j] = (unsigned char)Previous_Red;
  284.                      line->green[j] = (unsigned char)(((creg & 0xf)<<4) + (creg&0xf));
  285.                      Previous_Green = (int) line->green[j];
  286.                      line->blue[j] = (unsigned char)Previous_Blue;
  287.                      break;
  288.                   }
  289.                }
  290.                else if (nPlanes == 24) {
  291.                   line = &Image->data.rgb_lines[i];
  292.                   line->red[j] = (unsigned char)((creg >> 16) & 0xFF);
  293.                   line->green[j] = (unsigned char)((creg >> 8) & 0xFF);
  294.                   line->blue[j] = (unsigned char)(creg & 0xFF);
  295.                }
  296.                else {
  297.                   if (creg > (unsigned long)Image->Colour_Map_Size) {
  298.                      fprintf (stderr, "Error - IFF Image Map Colour out of range\n");
  299.                      exit(1);
  300.                   }
  301.                   Image->data.map_lines[i][j] = (char)creg;
  302.                }
  303.  
  304.                mask >>= 1;
  305.                if (mask == 0) {
  306.                   mask = 0x80;
  307.                   byte_index++;
  308.                }
  309.             }
  310.          }
  311.  
  312.          free (row_bytes);
  313.          fclose (f);
  314.          return;
  315.  
  316.       default:
  317.          for (i = 0 ; (long) i < Chunk_Header.size ; i++)
  318.             if (getc(f) == EOF)
  319.                iff_error();
  320.          break;
  321.       }
  322.    }
  323. }
  324.