home *** CD-ROM | disk | FTP | other *** search
/ Chestnut's Multimedia Mania / MM_MANIA.ISO / graphics / povsrc20 / raw.c < prev    next >
C/C++ Source or Header  |  1993-07-29  |  10KB  |  346 lines
  1. /****************************************************************************
  2. *                raw.c
  3. *
  4. *  This module contains the code to read and write the RAW file format
  5. *  The format is as follows:
  6. *
  7. *
  8. *  (header:)
  9. *    wwww hhhh       - Width, Height (16 bits, LSB first)
  10. *
  11. *  (each scanline:)
  12. *    llll            - Line number (16 bits, LSB first)
  13. *    rr rr rr ...    - Red data for line (8 bits per pixel,
  14. *                       left to right, 0-255 (255=bright, 0=dark))
  15. *    gg gg gg ...    - Green data for line (8 bits per pixel,
  16. *                       left to right, 0-255 (255=bright, 0=dark))
  17. *    bb bb bb ...    - Blue data for line (8 bits per pixel,
  18. *                       left to right, 0-255 (255=bright, 0=dark))
  19. *
  20. *  from Persistence of Vision Raytracer
  21. *  Copyright 1993 Persistence of Vision Team
  22. *---------------------------------------------------------------------------
  23. *  NOTICE: This source code file is provided so that users may experiment
  24. *  with enhancements to POV-Ray and to port the software to platforms other 
  25. *  than those supported by the POV-Ray Team.  There are strict rules under
  26. *  which you are permitted to use this file.  The rules are in the file
  27. *  named POVLEGAL.DOC which should be distributed with this file. If 
  28. *  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
  29. *  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
  30. *  Forum.  The latest version of POV-Ray may be found there as well.
  31. *
  32. * This program is based on the popular DKB raytracer version 2.12.
  33. * DKBTrace was originally written by David K. Buck.
  34. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  35. *
  36. *****************************************************************************/
  37.  
  38. #include "frame.h"
  39. #include "povproto.h"
  40.  
  41.   struct Raw_File_Handle_Struct {
  42.   FILE_HANDLE root;
  43.   FILE *Red_File, *Green_File, *Blue_File;
  44.   char *Red_Buffer, *Green_Buffer, *Blue_Buffer;
  45.   int line_number;
  46.   };
  47.  
  48. typedef struct Raw_File_Handle_Struct RAW_FILE_HANDLE;
  49.  
  50. FILE_HANDLE *Get_Raw_File_Handle()
  51.   {
  52.   RAW_FILE_HANDLE *handle;
  53.  
  54.   if ((handle = (RAW_FILE_HANDLE *) malloc(sizeof(RAW_FILE_HANDLE))) == NULL) 
  55.     {
  56.     fprintf (stderr, "Cannot allocate memory for output file handle\n");
  57.     return(NULL);
  58.     }
  59.  
  60.   handle->root.Default_File_Name_p = Default_Raw_File_Name;
  61.   handle->root.Open_File_p = Open_Raw_File;
  62.   handle->root.Write_Line_p = Write_Raw_Line;
  63.   handle->root.Read_Line_p = Read_Raw_Line;
  64.   handle->root.Close_File_p = Close_Raw_File;
  65.   return ((FILE_HANDLE *) handle);
  66.   }
  67.  
  68. char *Default_Raw_File_Name()
  69.   {
  70.   return ("data");
  71.   }
  72.  
  73. int Open_Raw_File (handle, name, width, height, buffer_size, mode)
  74. FILE_HANDLE *handle;
  75. char *name;
  76. int *width;
  77. int *height;
  78. int buffer_size;
  79. int mode;
  80.   {
  81.   RAW_FILE_HANDLE *raw_handle;
  82.   char file_name[256];
  83.  
  84.   handle->mode = mode;
  85.   handle->filename = name;
  86.   raw_handle = (RAW_FILE_HANDLE *) handle;
  87.   raw_handle->line_number = 0;
  88.  
  89.   switch (mode) 
  90.   {
  91.   case READ_MODE:
  92.     strcpy (file_name, name);
  93.     strcat (file_name, RED_RAW_FILE_EXTENSION);
  94.  
  95.     if ((raw_handle->Red_File=fopen(file_name,READ_FILE_STRING)) == NULL)
  96.       return(0);
  97.  
  98.     strcpy (file_name, name);
  99.     strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  100.  
  101.     if ((raw_handle->Green_File=fopen(file_name,READ_FILE_STRING))==NULL)
  102.       return(0);
  103.  
  104.     strcpy (file_name, name);
  105.     strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  106.  
  107.     if ((raw_handle->Blue_File=fopen(file_name,READ_FILE_STRING))== NULL)
  108.       return(0);
  109.  
  110.     if (buffer_size != 0) 
  111.       {
  112.       if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  113.         return(0);
  114.  
  115.       setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  116.       }
  117.  
  118.     if (buffer_size != 0) 
  119.       {
  120.       if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  121.         return(0);
  122.  
  123.       setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  124.       }
  125.  
  126.     if (buffer_size != 0) 
  127.       {
  128.       if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  129.         return(0);
  130.  
  131.       setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  132.       }
  133.  
  134.     handle->width = *width;
  135.     handle->height = *height;
  136.     handle->buffer_size = buffer_size;
  137.     break;
  138.  
  139.   case WRITE_MODE:
  140.     strcpy (file_name, name);
  141.     strcat (file_name, RED_RAW_FILE_EXTENSION);
  142.  
  143.     if ((raw_handle->Red_File = fopen (file_name, WRITE_FILE_STRING)) == NULL)
  144.       return(0);
  145.  
  146.     if (buffer_size != 0) 
  147.       {
  148.       if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  149.         return(0);
  150.  
  151.       setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  152.       }
  153.  
  154.     strcpy (file_name, name);
  155.     strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  156.  
  157.     if ((raw_handle->Green_File = fopen (file_name, WRITE_FILE_STRING)) == NULL)
  158.       return(0);
  159.  
  160.     if (buffer_size != 0) 
  161.       {
  162.       if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  163.         return(0);
  164.  
  165.       setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  166.       }
  167.  
  168.     strcpy (file_name, name);
  169.     strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  170.  
  171.     if ((raw_handle->Blue_File = fopen (file_name, WRITE_FILE_STRING)) == NULL)
  172.       return(0);
  173.  
  174.     if (buffer_size != 0) 
  175.       {
  176.       if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  177.         return(0);
  178.  
  179.       setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  180.       }
  181.  
  182.     handle->width = *width;
  183.     handle->height = *height;
  184.     handle->buffer_size = buffer_size;
  185.  
  186.     break;
  187.  
  188.   case APPEND_MODE:
  189.     strcpy (file_name, name);
  190.     strcat (file_name, RED_RAW_FILE_EXTENSION);
  191.  
  192.     if ((raw_handle->Red_File=fopen(file_name,APPEND_FILE_STRING))==NULL)
  193.       return(0);
  194.  
  195.     if (buffer_size != 0) 
  196.       {
  197.       if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  198.         return(0);
  199.  
  200.       setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  201.       }
  202.  
  203.     strcpy (file_name, name);
  204.     strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  205.  
  206.     if ((raw_handle->Green_File=fopen(file_name,APPEND_FILE_STRING))==NULL)
  207.       return(0);
  208.  
  209.     if (buffer_size != 0) 
  210.       {
  211.       if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  212.         return(0);
  213.  
  214.       setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  215.       }
  216.  
  217.     strcpy (file_name, name);
  218.     strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  219.  
  220.     if ((raw_handle->Blue_File=fopen(file_name,APPEND_FILE_STRING))==NULL)
  221.       return(0);
  222.  
  223.     if (buffer_size != 0) 
  224.       {
  225.       if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  226.         return(0);
  227.  
  228.       setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  229.       }
  230.  
  231.     handle->width = *width;
  232.     handle->height = *height;
  233.     handle->buffer_size = buffer_size;
  234.  
  235.     break;
  236.   }
  237.   return(1);
  238.   }
  239.  
  240. void Write_Raw_Line (handle, line_data, line_number)
  241. FILE_HANDLE *handle;
  242. COLOUR *line_data;
  243. int line_number;
  244.   {
  245.   register int x;
  246.   RAW_FILE_HANDLE *raw_handle;
  247.   char file_name[256];
  248.  
  249.   raw_handle = (RAW_FILE_HANDLE *) handle;
  250.  
  251.   for (x = 0 ; x < handle->width ; x++)
  252.     putc((int) floor (line_data[x].Red * 255.0), raw_handle->Red_File);
  253.  
  254.   for (x = 0 ; x < handle->width ; x++)
  255.     putc((int) floor (line_data[x].Green * 255.0), raw_handle->Green_File);
  256.  
  257.   for (x = 0 ; x < handle->width ; x++)
  258.     putc((int) floor (line_data[x].Blue * 255.0), raw_handle->Blue_File);
  259.  
  260.   if (handle->buffer_size == 0) 
  261.     {
  262.     fflush(raw_handle->Red_File);                       /* close and reopen file for */
  263.     strcpy (file_name, handle->filename);
  264.     strcat (file_name, RED_RAW_FILE_EXTENSION);
  265.     raw_handle->Red_File = freopen(file_name, APPEND_FILE_STRING,
  266.       raw_handle->Red_File);                /* integrity in case we crash*/
  267.  
  268.     fflush(raw_handle->Green_File);                       /* close and reopen file for */
  269.     strcpy (file_name, handle->filename);
  270.     strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  271.     raw_handle->Green_File = freopen(file_name, APPEND_FILE_STRING,
  272.       raw_handle->Green_File);                /* integrity in case we crash*/
  273.  
  274.     fflush(raw_handle->Blue_File);                       /* close and reopen file for */
  275.     strcpy (file_name, handle->filename);
  276.     strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  277.     raw_handle->Blue_File = freopen(file_name, APPEND_FILE_STRING,
  278.       raw_handle->Blue_File);                /* integrity in case we crash*/
  279.     }
  280.   }
  281.  
  282. int Read_Raw_Line (handle, line_data, line_number)
  283. FILE_HANDLE *handle;
  284. COLOUR *line_data;
  285. int *line_number;
  286.   {
  287.   int data, i;
  288.   RAW_FILE_HANDLE *raw_handle;
  289.  
  290.   raw_handle = (RAW_FILE_HANDLE *) handle;
  291.  
  292.   for (i = 0 ; i < handle->width ; i++) 
  293.     {
  294.     if ((data = getc(raw_handle->Red_File)) == EOF) 
  295.       {
  296.       if (i == 0)
  297.         return(0);
  298.       else
  299.         return(-1);
  300.       }
  301.  
  302.     line_data[i].Red = (DBL) data / 255.0;
  303.     }
  304.  
  305.   for (i = 0 ; i < handle->width ; i++) 
  306.     {
  307.     if ((data = getc(raw_handle->Green_File)) == EOF)
  308.       return(-1);
  309.  
  310.     line_data[i].Green = (DBL) data / 255.0;
  311.     }
  312.  
  313.   for (i = 0 ; i < handle->width ; i++) 
  314.     {
  315.     if ((data = getc(raw_handle->Blue_File)) == EOF)
  316.       return(-1);
  317.  
  318.     line_data[i].Blue = (DBL) data / 255.0;
  319.     }
  320.  
  321.   *line_number = raw_handle->line_number++;
  322.   return (1);
  323.   }
  324.  
  325. void Close_Raw_File (handle)
  326. FILE_HANDLE *handle;
  327.   {
  328.   RAW_FILE_HANDLE *raw_handle;
  329.  
  330.   raw_handle = (RAW_FILE_HANDLE *) handle;
  331.  
  332.   if(raw_handle->Red_File)         
  333.     fclose (raw_handle->Red_File); 
  334.   if(raw_handle->Green_File)       
  335.     fclose (raw_handle->Green_File);
  336.   if(raw_handle->Blue_File)        
  337.     fclose (raw_handle->Blue_File);
  338.  
  339.   if (handle->buffer_size != 0) 
  340.     {
  341.     free (raw_handle->Red_Buffer);
  342.     free (raw_handle->Green_Buffer);
  343.     free (raw_handle->Blue_Buffer);
  344.     }
  345.   }
  346.