home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / rexx / library2 / gbmrexx / gbm / gbm.c < prev    next >
C/C++ Source or Header  |  1993-06-15  |  5KB  |  218 lines
  1. /*
  2.  
  3. GBM.C  General Bitmap Code
  4.  
  5. */
  6.  
  7. /*...sincludes:0:*/
  8. #include <stdio.h>
  9. #include <ctype.h>
  10. #include <stddef.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <memory.h>
  14. #include "standard.h"
  15. #include "gbm.h"
  16.  
  17. /*...vgbm\46\h:0:*/
  18. /*...e*/
  19.  
  20. /*...sentrypoints:0:*/
  21. #include "gbmpgm.h"
  22. #include "gbmppm.h"
  23. #include "gbmbmp.h"
  24. #include "gbmtga.h"
  25. #include "gbmkps.h"
  26. #include "gbmiax.h"
  27. #include "gbmpcx.h"
  28. #include "gbmtif.h"
  29. #include "gbmlbm.h"
  30. #include "gbmvid.h"
  31. #include "gbmgif.h"
  32. #include "gbmxbm.h"
  33. #include "gbmspr.h"
  34.  
  35. /*...vgbmpgm\46\h:0:*/
  36. /*...vgbmppm\46\h:0:*/
  37. /*...vgbmbmp\46\h:0:*/
  38. /*...vgbmtga\46\h:0:*/
  39. /*...vgbmkps\46\h:0:*/
  40. /*...vgbmiax\46\h:0:*/
  41. /*...vgbmpcx\46\h:0:*/
  42. /*...vgbmtif\46\h:0:*/
  43. /*...vgbmlbm\46\h:0:*/
  44. /*...vgbmvid\46\h:0:*/
  45. /*...vgbmgif\46\h:0:*/
  46. /*...vgbmxbm\46\h:0:*/
  47. /*...vgbmspr\46\h:0:*/
  48.  
  49. typedef struct
  50.     {
  51.     GBM_ERR (*query_filetype)(GBMFT *gbmft);
  52.     GBM_ERR (*read_header )(char *fn, int fd, GBM *gbm, char *opt);
  53.     GBM_ERR (*read_palette)(int fd, GBM *gbm, GBMRGB *gbmrgb);
  54.     GBM_ERR (*read_data   )(int fd, GBM *gbm, byte *data);
  55.     GBM_ERR (*write       )(char *fn, int fd, GBM *gbm, GBMRGB *gbmrgb, byte *data, char *opt);
  56.     char *  (*err         )(GBM_ERR rc);
  57.     } FT;
  58.  
  59. static FT fts [] =
  60.     {
  61.     bmp_qft, bmp_rhdr, bmp_rpal, bmp_rdata, bmp_w, bmp_err,
  62.     gif_qft, gif_rhdr, gif_rpal, gif_rdata, gif_w, gif_err,
  63.     pcx_qft, pcx_rhdr, pcx_rpal, pcx_rdata, pcx_w, pcx_err,
  64.     tif_qft, tif_rhdr, tif_rpal, tif_rdata, tif_w, tif_err,
  65.     tga_qft, tga_rhdr, tga_rpal, tga_rdata, tga_w, tga_err,
  66.     lbm_qft, lbm_rhdr, lbm_rpal, lbm_rdata, lbm_w, lbm_err,
  67.     vid_qft, vid_rhdr, vid_rpal, vid_rdata, vid_w, vid_err,
  68.     pgm_qft, pgm_rhdr, pgm_rpal, pgm_rdata, pgm_w, pgm_err,
  69.     ppm_qft, ppm_rhdr, ppm_rpal, ppm_rdata, ppm_w, ppm_err,
  70.     kps_qft, kps_rhdr, kps_rpal, kps_rdata, kps_w, kps_err,
  71.     iax_qft, iax_rhdr, iax_rpal, iax_rdata, iax_w, iax_err,
  72.     xbm_qft, xbm_rhdr, xbm_rpal, xbm_rdata, xbm_w, xbm_err,
  73.     spr_qft, spr_rhdr, spr_rpal, spr_rdata, spr_w, spr_err,
  74.     };
  75.  
  76. #define    N_FT    (sizeof(fts) / sizeof(fts [0]))
  77. /*...e*/
  78.  
  79. /*...sextension:0:*/
  80. static char *extension(char *fn)
  81.     {
  82.     char    *dot, *slash;
  83.  
  84.     if ( (dot = strrchr(fn, '.')) == NULL )
  85.         return ( NULL );
  86.  
  87.     if ( (slash = strpbrk(fn, "/\\")) == NULL )
  88.         return ( dot + 1 );
  89.  
  90.     return ( ( slash < dot ) ? dot + 1 : NULL );
  91.     }
  92. /*...e*/
  93. /*...ssame:0:*/
  94. static BOOLEAN same(char *s1, char *s2, int n)
  95.     {
  96.     for ( ; n--; s1++, s2++ )
  97.         if ( tolower(*s1) != tolower(*s2) )
  98.             return ( FALSE );
  99.     return ( TRUE );
  100.     }
  101. /*...e*/
  102.  
  103. /*...sgbm_init:0:*/
  104. GBM_ERR gbm_init(void)
  105.     {
  106.     return ( GBM_ERR_OK );
  107.     }
  108. /*...e*/
  109. /*...sgbm_deinit:0:*/
  110. GBM_ERR gbm_deinit(void)
  111.     {
  112.     return ( GBM_ERR_OK );
  113.     }
  114. /*...e*/
  115. /*...sgbm_query_n_filetypes:0:*/
  116. GBM_ERR gbm_query_n_filetypes(int *n_ft)
  117.     {
  118.     *n_ft = N_FT;
  119.     return ( GBM_ERR_OK );
  120.     }
  121. /*...e*/
  122. /*...sgbm_guess_filetype:0:*/
  123. GBM_ERR    gbm_guess_filetype(char *fn, int *ft)
  124.     {
  125.     int    i;
  126.     char    *ext = extension(fn);
  127.  
  128.     if ( ext == NULL )
  129.         ext = "";
  130.  
  131.     for ( i = 0; i < N_FT; i++ )
  132.         {
  133.         GBMFT    gbmft;
  134.         char    buf [100+1], *s;
  135.  
  136.         fts [i].query_filetype(&gbmft);
  137.         for ( s  = strtok(strcpy(buf, gbmft.extensions), " \t,");
  138.               s != NULL;
  139.               s  = strtok(NULL, " \t,") )
  140.             if ( same(s, ext, strlen(ext) + 1) )
  141.                 {
  142.                 *ft = i;
  143.                 return ( GBM_ERR_OK );
  144.                 }
  145.         }
  146.     return ( GBM_ERR_NOT_FOUND );
  147.     }
  148. /*...e*/
  149.  
  150. /*...sgbm_query_filetype:0:*/
  151. GBM_ERR gbm_query_filetype(int ft, GBMFT *gbmft)
  152.     {
  153.     return ( (*fts [ft].query_filetype)(gbmft) );
  154.     }
  155. /*...e*/
  156. /*...sgbm_read_header:0:*/
  157. GBM_ERR gbm_read_header(char *fn, int fd, int ft, GBM *gbm, char *opt)
  158.     {
  159.     return ( (*fts [ft].read_header)(fn, fd, gbm, opt) );
  160.     }
  161. /*...e*/
  162. /*...sgbm_read_palette:0:*/
  163. GBM_ERR gbm_read_palette(int fd, int ft, GBM *gbm, GBMRGB *gbmrgb)
  164.     {
  165.     return ( (*fts [ft].read_palette)(fd, gbm, gbmrgb) );
  166.     }
  167. /*...e*/
  168. /*...sgbm_read_data:0:*/
  169. GBM_ERR gbm_read_data(int fd, int ft, GBM *gbm, byte *data)
  170.     {
  171.     return ( (*fts [ft].read_data)(fd, gbm, data) );
  172.     }
  173. /*...e*/
  174. /*...sgbm_write:0:*/
  175. GBM_ERR gbm_write(char *fn, int fd, int ft, GBM *gbm, GBMRGB *gbmrgb, byte *data, char *opt)
  176.     {
  177.     return ( (*fts [ft].write)(fn, fd, gbm, gbmrgb, data, opt) );
  178.     }
  179. /*...e*/
  180. /*...sgbm_err:0:*/
  181. char *gbm_err(GBM_ERR rc)
  182.     {
  183.     int ft;
  184.  
  185.     switch ( (int) rc )
  186.         {
  187.         case GBM_ERR_OK:
  188.             return ( "ok" );
  189.         case GBM_ERR_MEM:
  190.             return ( "out of memory" );
  191.         case GBM_ERR_NOT_SUPP:
  192.             return ( "not supported" );
  193.         case GBM_ERR_BAD_OPTION:
  194.             return ( "bad option(s)" );
  195.         case GBM_ERR_NOT_FOUND:
  196.             return ( "not found" );
  197.         case GBM_ERR_BAD_MAGIC:
  198.             return ( "bad magic number / signiture block" );
  199.         case GBM_ERR_BAD_SIZE:
  200.             return ( "bad bitmap size" );
  201.         case GBM_ERR_READ:
  202.             return ( "can't read file" );
  203.         case GBM_ERR_WRITE:
  204.             return ( "can't write file" );
  205.         }
  206.  
  207.     for ( ft = 0; ft < N_FT; ft++ )
  208.         {
  209.         char *s;
  210.  
  211.         if ( (s = (*fts [ft].err)(rc)) != NULL )
  212.             return ( s );
  213.         }
  214.  
  215.     return ( "general error" );
  216.     }
  217. /*...e*/
  218.