home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / graphic / dkb / source / raw.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-24  |  11.3 KB  |  354 lines
  1. /*****************************************************************************
  2. *
  3. *                                     raw.c
  4. *
  5. *   from DKBTrace (c) 1990  David Buck
  6. *
  7. *  This module contains the code to read and write the default file format
  8. *  generated by DKBTrace.  The format is as follows:
  9. *
  10. *
  11. *  (header:)
  12. *    wwww hhhh       - Width, Height (16 bits, LSB first)
  13. *
  14. *  (each scanline:)
  15. *    llll            - Line number (16 bits, LSB first)
  16. *    rr rr rr ...    - Red data for line (8 bits per pixel,
  17. *                       left to right, 0-255 (255=bright, 0=dark))
  18. *    gg gg gg ...    - Green data for line (8 bits per pixel,
  19. *                       left to right, 0-255 (255=bright, 0=dark))
  20. *    bb bb bb ...    - Blue data for line (8 bits per pixel,
  21. *                       left to right, 0-255 (255=bright, 0=dark))
  22. *
  23. * This software is freely distributable. The source and/or object code may be
  24. * copied or uploaded to communications services so long as this notice remains
  25. * at the top of each file.  If any changes are made to the program, you must
  26. * clearly indicate in the documentation and in the programs startup message
  27. * who it was who made the changes. The documentation should also describe what
  28. * those changes were. This software may not be included in whole or in
  29. * part into any commercial package without the express written consent of the
  30. * author.  It may, however, be included in other public domain or freely
  31. * distributed software so long as the proper credit for the software is given.
  32. *
  33. * This software is provided as is without any guarantees or warranty. Although
  34. * the author has attempted to find and correct any bugs in the software, he
  35. * is not responsible for any damage caused by the use of the software.  The
  36. * author is under no obligation to provide service, corrections, or upgrades
  37. * to this package.
  38. *
  39. * Despite all the legal stuff above, if you do find bugs, I would like to hear
  40. * about them.  Also, if you have any comments or questions, you may contact me
  41. * at the following address:
  42. *
  43. *     David Buck
  44. *     22C Sonnet Cres.
  45. *     Nepean Ontario
  46. *     Canada, K2H 8W7
  47. *
  48. *  I can also be reached on the following bulleton boards:
  49. *
  50. *     OMX              (613) 731-3419
  51. *     Mystic           (613) 596-4249  or  (613) 596-4772
  52. *
  53. *  Fidonet:   1:163/109.9
  54. *  Internet:  dbuck@ccs.carleton.ca
  55. *  The "You Can Call Me RAY" BBS    (708) 358-5611
  56. *
  57. *  IBM Port by Aaron A. Collins. Aaron may be reached on the following BBS'es:
  58. *
  59. *     The "You Can Call Me RAY" BBS (708) 358-5611
  60. *     The Information Exchange BBS  (708) 945-5575
  61. *
  62. *****************************************************************************/
  63.  
  64. #include "frame.h"
  65. #include "dkbproto.h"
  66.  
  67. struct Raw_File_Handle_Struct {
  68.    FILE_HANDLE root;
  69.    FILE *Red_File, *Green_File, *Blue_File;
  70.    char *Red_Buffer, *Green_Buffer, *Blue_Buffer;
  71.    int line_number;
  72.    };
  73.  
  74. typedef struct Raw_File_Handle_Struct RAW_FILE_HANDLE;
  75.  
  76. FILE_HANDLE *Get_Raw_File_Handle()
  77.    {
  78.    RAW_FILE_HANDLE *handle;
  79.  
  80.    if ((handle = (RAW_FILE_HANDLE *) malloc(sizeof(RAW_FILE_HANDLE))) == NULL) {
  81.       PRINT ("Cannot allocate memory for output file handle\n");
  82.       return(NULL);
  83.       }
  84.  
  85.    handle->root.Default_File_Name_p = Default_Raw_File_Name;
  86.    handle->root.Open_File_p = Open_Raw_File;
  87.    handle->root.Write_Line_p = Write_Raw_Line;
  88.    handle->root.Read_Line_p = Read_Raw_Line;
  89.    handle->root.Close_File_p = Close_Raw_File;
  90.    return ((FILE_HANDLE *) handle);
  91.    }
  92.  
  93. char *Default_Raw_File_Name()
  94.    {
  95.    return ("data");
  96.    }
  97.  
  98. int Open_Raw_File (handle, name, width, height, buffer_size, mode)
  99.    FILE_HANDLE *handle;
  100.    char *name;
  101.    int *width;
  102.    int *height;
  103.    int buffer_size;
  104.    int mode;
  105.    {
  106.    RAW_FILE_HANDLE *raw_handle;
  107.    char file_name[256];
  108.  
  109.    handle->mode = mode;
  110.    handle->filename = name;
  111.    raw_handle = (RAW_FILE_HANDLE *) handle;
  112.    raw_handle->line_number = 0;
  113.  
  114.    switch (mode) {
  115.       case READ_MODE:
  116.          strcpy (file_name, name);
  117.          strcat (file_name, RED_RAW_FILE_EXTENSION);
  118.  
  119.          if ((raw_handle->Red_File = fopen (file_name, "rb")) == NULL)
  120.             return(0);
  121.  
  122.          strcpy (file_name, name);
  123.          strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  124.  
  125.          if ((raw_handle->Green_File = fopen (file_name, "rb")) == NULL)
  126.             return(0);
  127.  
  128.          strcpy (file_name, name);
  129.          strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  130.  
  131.          if ((raw_handle->Blue_File = fopen (file_name, "rb")) == NULL)
  132.             return(0);
  133.  
  134.          if (buffer_size != 0) {
  135.             if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  136.                return(0);
  137.  
  138.             setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  139.             }
  140.  
  141.          if (buffer_size != 0) {
  142.             if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  143.                return(0);
  144.  
  145.             setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  146.             }
  147.  
  148.          if (buffer_size != 0) {
  149.             if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  150.                return(0);
  151.  
  152.             setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  153.             }
  154.  
  155.          handle->width = *width;
  156.          handle->height = *height;
  157.          handle->buffer_size = buffer_size;
  158.          break;
  159.  
  160.       case WRITE_MODE:
  161.          strcpy (file_name, name);
  162.          strcat (file_name, RED_RAW_FILE_EXTENSION);
  163.  
  164.          if ((raw_handle->Red_File = fopen (file_name, "wb")) == NULL)
  165.             return(0);
  166.  
  167.          if (buffer_size != 0) {
  168.             if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  169.                return(0);
  170.  
  171.             setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  172.             }
  173.  
  174.          strcpy (file_name, name);
  175.          strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  176.  
  177.          if ((raw_handle->Green_File = fopen (file_name, "wb")) == NULL)
  178.             return(0);
  179.  
  180.          if (buffer_size != 0) {
  181.             if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  182.                return(0);
  183.  
  184.             setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  185.             }
  186.  
  187.          strcpy (file_name, name);
  188.          strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  189.  
  190.          if ((raw_handle->Blue_File = fopen (file_name, "wb")) == NULL)
  191.             return(0);
  192.  
  193.          if (buffer_size != 0) {
  194.             if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  195.                return(0);
  196.  
  197.             setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  198.             }
  199.  
  200.          handle->width = *width;
  201.          handle->height = *height;
  202.          handle->buffer_size = buffer_size;
  203.  
  204.          break;
  205.  
  206.       case APPEND_MODE:
  207.          strcpy (file_name, name);
  208.          strcat (file_name, RED_RAW_FILE_EXTENSION);
  209.  
  210.          if ((raw_handle->Red_File = fopen (file_name, "ab")) == NULL)
  211.             return(0);
  212.  
  213.          if (buffer_size != 0) {
  214.             if ((raw_handle->Red_Buffer = malloc (buffer_size)) == NULL)
  215.                return(0);
  216.  
  217.             setvbuf (raw_handle->Red_File, raw_handle->Red_Buffer, _IOFBF, buffer_size);
  218.             }
  219.  
  220.          strcpy (file_name, name);
  221.          strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  222.  
  223.          if ((raw_handle->Green_File = fopen (file_name, "ab")) == NULL)
  224.             return(0);
  225.  
  226.          if (buffer_size != 0) {
  227.             if ((raw_handle->Green_Buffer = malloc (buffer_size)) == NULL)
  228.                return(0);
  229.  
  230.             setvbuf (raw_handle->Green_File, raw_handle->Green_Buffer, _IOFBF, buffer_size);
  231.             }
  232.  
  233.          strcpy (file_name, name);
  234.          strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  235.  
  236.          if ((raw_handle->Blue_File = fopen (file_name, "ab")) == NULL)
  237.             return(0);
  238.  
  239.          if (buffer_size != 0) {
  240.             if ((raw_handle->Blue_Buffer = malloc (buffer_size)) == NULL)
  241.                return(0);
  242.  
  243.             setvbuf (raw_handle->Blue_File, raw_handle->Blue_Buffer, _IOFBF, buffer_size);
  244.             }
  245.  
  246.          handle->width = *width;
  247.          handle->height = *height;
  248.          handle->buffer_size = buffer_size;
  249.  
  250.          break;
  251.       }
  252.    return(1);
  253.    }
  254.  
  255. void Write_Raw_Line (handle, line_data, line_number)
  256.    FILE_HANDLE *handle;
  257.    COLOUR *line_data;
  258.    int line_number;
  259.    {
  260.    register int x;
  261.    RAW_FILE_HANDLE *raw_handle;
  262.    char file_name[256];
  263.  
  264.    raw_handle = (RAW_FILE_HANDLE *) handle;
  265.  
  266.    for (x = 0 ; x < handle->width ; x++)
  267.       putc((int) floor (line_data[x].Red * 255.0), raw_handle->Red_File);
  268.  
  269.    for (x = 0 ; x < handle->width ; x++)
  270.       putc((int) floor (line_data[x].Green * 255.0), raw_handle->Green_File);
  271.  
  272.    for (x = 0 ; x < handle->width ; x++)
  273.       putc((int) floor (line_data[x].Blue * 255.0), raw_handle->Blue_File);
  274.  
  275.    if (handle->buffer_size == 0) {
  276.       fflush(raw_handle->Red_File);                       /* close and reopen file for */
  277.       strcpy (file_name, handle->filename);
  278.       strcat (file_name, RED_RAW_FILE_EXTENSION);
  279.       raw_handle->Red_File = freopen(file_name, "ab",
  280.                     raw_handle->Red_File);                /* integrity in case we crash*/
  281.  
  282.       fflush(raw_handle->Green_File);                       /* close and reopen file for */
  283.       strcpy (file_name, handle->filename);
  284.       strcat (file_name, GREEN_RAW_FILE_EXTENSION);
  285.       raw_handle->Green_File = freopen(file_name, "ab",
  286.                     raw_handle->Green_File);                /* integrity in case we crash*/
  287.  
  288.       fflush(raw_handle->Blue_File);                       /* close and reopen file for */
  289.       strcpy (file_name, handle->filename);
  290.       strcat (file_name, BLUE_RAW_FILE_EXTENSION);
  291.       raw_handle->Blue_File = freopen(file_name, "ab",
  292.                     raw_handle->Blue_File);                /* integrity in case we crash*/
  293.       }
  294.    }
  295.  
  296. int Read_Raw_Line (handle, line_data, line_number)
  297.    FILE_HANDLE *handle;
  298.    COLOUR *line_data;
  299.    int *line_number;
  300.    {
  301.    int data, i;
  302.    RAW_FILE_HANDLE *raw_handle;
  303.    
  304.    raw_handle = (RAW_FILE_HANDLE *) handle;
  305.  
  306.    for (i = 0 ; i < handle->width ; i++) {
  307.       if ((data = getc(raw_handle->Red_File)) == EOF) {
  308.          if (i == 0)
  309.             return(0);
  310.          else
  311.             return(-1);
  312.          }
  313.  
  314.       line_data[i].Red = (DBL) data / 255.0;
  315.       }
  316.  
  317.    for (i = 0 ; i < handle->width ; i++) {
  318.       if ((data = getc(raw_handle->Green_File)) == EOF)
  319.          return(-1);
  320.  
  321.       line_data[i].Green = (DBL) data / 255.0;
  322.       }
  323.  
  324.    for (i = 0 ; i < handle->width ; i++) {
  325.       if ((data = getc(raw_handle->Blue_File)) == EOF)
  326.          return(-1);
  327.  
  328.       line_data[i].Blue = (DBL) data / 255.0;
  329.       }
  330.  
  331.    *line_number = raw_handle->line_number++;
  332.    return (1);
  333.    }
  334.  
  335. void Close_Raw_File (handle)
  336.    FILE_HANDLE *handle;
  337.    {
  338.    RAW_FILE_HANDLE *raw_handle;
  339.  
  340.    raw_handle = (RAW_FILE_HANDLE *) handle;
  341.  
  342.    fclose (raw_handle->Red_File);
  343.    fclose (raw_handle->Green_File);
  344.    fclose (raw_handle->Blue_File);
  345.  
  346.    if (handle->buffer_size != 0) {
  347.       free (raw_handle->Red_Buffer);
  348.       free (raw_handle->Green_Buffer);
  349.       free (raw_handle->Blue_Buffer);
  350.       }
  351.     free (handle);
  352.    }
  353.  
  354.