home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / povsrc.sit / SOURCE / RAW.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-03  |  9.5 KB  |  327 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 1992 Persistence of Vision Team
  22. *---------------------------------------------------------------------------
  23. *  Copying, distribution and legal info is in the file povlegal.doc which
  24. *  should be distributed with this file. If povlegal.doc is not available
  25. *  or for more info please contact:
  26. *
  27. *       Drew Wells [POV-Team Leader] 
  28. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  29. *       Phone: (213) 254-4041
  30. * 
  31. * This program is based on the popular DKB raytracer version 2.12.
  32. * DKBTrace was originally written by David K. Buck.
  33. * DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
  34. *
  35. *****************************************************************************/
  36.  
  37. #include "frame.h"
  38. #include "povproto.h"
  39.  
  40. struct Raw_File_Handle_Struct {
  41.    FILE_HANDLE root;
  42.    FILE *Red_File, *Green_File, *Blue_File;
  43.    char *Red_Buffer, *Green_Buffer, *Blue_Buffer;
  44.    int line_number;
  45. };
  46.  
  47. typedef struct Raw_File_Handle_Struct RAW_FILE_HANDLE;
  48.  
  49. FILE_HANDLE *Get_Raw_File_Handle()
  50. {
  51.    RAW_FILE_HANDLE *handle;
  52.  
  53.    if ((handle = (RAW_FILE_HANDLE *) malloc(sizeof(RAW_FILE_HANDLE))) == NULL) {
  54.       fprintf (stderr, "Cannot allocate memory for output file handle\n");
  55.       return(NULL);
  56.    }
  57.  
  58.    handle->root.Default_File_Name_p = Default_Raw_File_Name;
  59.    handle->root.Open_File_p = Open_Raw_File;
  60.    handle->root.Write_Line_p = Write_Raw_Line;
  61.    handle->root.Read_Line_p = Read_Raw_Line;
  62.    handle->root.Close_File_p = Close_Raw_File;
  63.    return ((FILE_HANDLE *) handle);
  64. }
  65.  
  66. char *Default_Raw_File_Name()
  67. {
  68.    return ("data");
  69. }
  70.  
  71. int Open_Raw_File (handle, name, width, height, buffer_size, mode)
  72. FILE_HANDLE *handle;
  73. char *name;
  74. int *width;
  75. int *height;
  76. int buffer_size;
  77. int mode;
  78. {
  79.    RAW_FILE_HANDLE *raw_handle;
  80.    char file_name[256];
  81.  
  82.    handle->mode = mode;
  83.    handle->filename = name;
  84.    raw_handle = (RAW_FILE_HANDLE *) handle;
  85.    raw_handle->line_number = 0;
  86.  
  87.    switch (mode) {
  88.    case READ_MODE:
  89.       strcpy (file_name, name);
  90.       strcat (file_name, RED_RAW_FILE_EXTENSION);
  91.  
  92.       if ((raw_handle->Red_File=fopen(file_name,READ_FILE_STRING)) == NULL)
  93.          return(0);
  94.  
  95.       strcpy (file_name, name);
  96.       strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  97.  
  98.       if ((raw_handle->Green_File=fopen(file_name,READ_FILE_STRING))==NULL)
  99.          return(0);
  100.  
  101.       strcpy (file_name, name);
  102.       strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  103.  
  104.       if ((raw_handle->Blue_File=fopen(file_name,READ_FILE_STRING))== NULL)
  105.          return(0);
  106.  
  107.       if (buffer_size != 0) {
  108.          if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  109.             return(0);
  110.  
  111.          setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  112.       }
  113.  
  114.       if (buffer_size != 0) {
  115.          if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  116.             return(0);
  117.  
  118.          setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  119.       }
  120.  
  121.       if (buffer_size != 0) {
  122.          if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  123.             return(0);
  124.  
  125.          setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  126.       }
  127.  
  128.       handle->width = *width;
  129.       handle->height = *height;
  130.       handle->buffer_size = buffer_size;
  131.       break;
  132.  
  133.    case WRITE_MODE:
  134.       strcpy (file_name, name);
  135.       strcat (file_name, RED_RAW_FILE_EXTENSION);
  136.  
  137.       if ((raw_handle->Red_File = fopen (file_name, WRITE_FILE_STRING)) == NULL)
  138.          return(0);
  139.  
  140.       if (buffer_size != 0) {
  141.          if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  142.             return(0);
  143.  
  144.          setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  145.       }
  146.  
  147.       strcpy (file_name, name);
  148.       strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  149.  
  150.       if ((raw_handle->Green_File = fopen (file_name, WRITE_FILE_STRING)) == NULL)
  151.          return(0);
  152.  
  153.       if (buffer_size != 0) {
  154.          if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  155.             return(0);
  156.  
  157.          setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  158.       }
  159.  
  160.       strcpy (file_name, name);
  161.       strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  162.  
  163.       if ((raw_handle->Blue_File = fopen (file_name, WRITE_FILE_STRING)) == NULL)
  164.          return(0);
  165.  
  166.       if (buffer_size != 0) {
  167.          if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  168.             return(0);
  169.  
  170.          setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  171.       }
  172.  
  173.       handle->width = *width;
  174.       handle->height = *height;
  175.       handle->buffer_size = buffer_size;
  176.  
  177.       break;
  178.  
  179.    case APPEND_MODE:
  180.       strcpy (file_name, name);
  181.       strcat (file_name, RED_RAW_FILE_EXTENSION);
  182.  
  183.       if ((raw_handle->Red_File=fopen(file_name,APPEND_FILE_STRING))==NULL)
  184.          return(0);
  185.  
  186.       if (buffer_size != 0) {
  187.          if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  188.             return(0);
  189.  
  190.          setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  191.       }
  192.  
  193.       strcpy (file_name, name);
  194.       strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  195.  
  196.       if ((raw_handle->Green_File=fopen(file_name,APPEND_FILE_STRING))==NULL)
  197.          return(0);
  198.  
  199.       if (buffer_size != 0) {
  200.          if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  201.             return(0);
  202.  
  203.          setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  204.       }
  205.  
  206.       strcpy (file_name, name);
  207.       strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  208.  
  209.       if ((raw_handle->Blue_File=fopen(file_name,APPEND_FILE_STRING))==NULL)
  210.          return(0);
  211.  
  212.       if (buffer_size != 0) {
  213.          if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  214.             return(0);
  215.  
  216.          setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  217.       }
  218.  
  219.       handle->width = *width;
  220.       handle->height = *height;
  221.       handle->buffer_size = buffer_size;
  222.  
  223.       break;
  224.    }
  225.    return(1);
  226. }
  227.  
  228. void Write_Raw_Line (handle, line_data, line_number)
  229. FILE_HANDLE *handle;
  230. COLOUR *line_data;
  231. int line_number;
  232. {
  233.    register int x;
  234.    RAW_FILE_HANDLE *raw_handle;
  235.    char file_name[256];
  236.  
  237.    raw_handle = (RAW_FILE_HANDLE *) handle;
  238.  
  239.    for (x = 0 ; x < handle->width ; x++)
  240.       putc((int) floor (line_data[x].Red * 255.0), raw_handle->Red_File);
  241.  
  242.    for (x = 0 ; x < handle->width ; x++)
  243.       putc((int) floor (line_data[x].Green * 255.0), raw_handle->Green_File);
  244.  
  245.    for (x = 0 ; x < handle->width ; x++)
  246.       putc((int) floor (line_data[x].Blue * 255.0), raw_handle->Blue_File);
  247.  
  248.    if (handle->buffer_size == 0) {
  249.       fflush(raw_handle->Red_File);                       /* close and reopen file for */
  250.       strcpy (file_name, handle->filename);
  251.       strcat (file_name, RED_RAW_FILE_EXTENSION);
  252.       raw_handle->Red_File = freopen(file_name, APPEND_FILE_STRING,
  253.          raw_handle->Red_File);                /* integrity in case we crash*/
  254.  
  255.       fflush(raw_handle->Green_File);                       /* close and reopen file for */
  256.       strcpy (file_name, handle->filename);
  257.       strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  258.       raw_handle->Green_File = freopen(file_name, APPEND_FILE_STRING,
  259.          raw_handle->Green_File);                /* integrity in case we crash*/
  260.  
  261.       fflush(raw_handle->Blue_File);                       /* close and reopen file for */
  262.       strcpy (file_name, handle->filename);
  263.       strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  264.       raw_handle->Blue_File = freopen(file_name, APPEND_FILE_STRING,
  265.          raw_handle->Blue_File);                /* integrity in case we crash*/
  266.    }
  267. }
  268.  
  269. int Read_Raw_Line (handle, line_data, line_number)
  270. FILE_HANDLE *handle;
  271. COLOUR *line_data;
  272. int *line_number;
  273. {
  274.    int data, i;
  275.    RAW_FILE_HANDLE *raw_handle;
  276.  
  277.    raw_handle = (RAW_FILE_HANDLE *) handle;
  278.  
  279.    for (i = 0 ; i < handle->width ; i++) {
  280.       if ((data = getc(raw_handle->Red_File)) == EOF) {
  281.          if (i == 0)
  282.             return(0);
  283.          else
  284.             return(-1);
  285.       }
  286.  
  287.       line_data[i].Red = (DBL) data / 255.0;
  288.    }
  289.  
  290.    for (i = 0 ; i < handle->width ; i++) {
  291.       if ((data = getc(raw_handle->Green_File)) == EOF)
  292.          return(-1);
  293.  
  294.       line_data[i].Green = (DBL) data / 255.0;
  295.    }
  296.  
  297.    for (i = 0 ; i < handle->width ; i++) {
  298.       if ((data = getc(raw_handle->Blue_File)) == EOF)
  299.          return(-1);
  300.  
  301.       line_data[i].Blue = (DBL) data / 255.0;
  302.    }
  303.  
  304.    *line_number = raw_handle->line_number++;
  305.    return (1);
  306. }
  307.  
  308. void Close_Raw_File (handle)
  309. FILE_HANDLE *handle;
  310. {
  311.    RAW_FILE_HANDLE *raw_handle;
  312.  
  313.    raw_handle = (RAW_FILE_HANDLE *) handle;
  314.    if(raw_handle->Red_File)
  315.       fclose (raw_handle->Red_File);
  316.    if(raw_handle->Green_File)
  317.       fclose (raw_handle->Green_File);
  318.    if(raw_handle->Blue_File)
  319.       fclose (raw_handle->Blue_File);
  320.  
  321.    if (handle->buffer_size != 0) {
  322.       free (raw_handle->Red_Buffer);
  323.       free (raw_handle->Green_Buffer);
  324.       free (raw_handle->Blue_Buffer);
  325.    }
  326. }
  327.