home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / gbmsrc.zip / gbm.c < prev    next >
C/C++ Source or Header  |  1999-01-17  |  9KB  |  348 lines
  1. /*
  2.  
  3. gbm.c - Generalised Bitmap Module
  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. #if defined(AIX) || defined(LINUX)
  15. #include <unistd.h>
  16. #else
  17. #include <io.h>
  18. #endif
  19. #include <fcntl.h>
  20. #include <sys/types.h>
  21. #include <sys/stat.h>
  22. #include "gbm.h"
  23. #include "gbmhelp.h"
  24.  
  25. /*...vgbm\46\h:0:*/
  26. /*...vgbmhelp\46\h:0:*/
  27. /*...e*/
  28.  
  29. /*...sentrypoints:0:*/
  30. #include "gbmpgm.h"
  31. #include "gbmppm.h"
  32. #include "gbmbmp.h"
  33. #include "gbmtga.h"
  34. #include "gbmkps.h"
  35. #include "gbmiax.h"
  36. #include "gbmpcx.h"
  37. #include "gbmtif.h"
  38. #include "gbmlbm.h"
  39. #include "gbmvid.h"
  40. #include "gbmgif.h"
  41. #include "gbmxbm.h"
  42. #include "gbmspr.h"
  43. #include "gbmpsg.h"
  44. #include "gbmgem.h"
  45. #include "gbmcvp.h"
  46. #include "gbmjpg.h"
  47.  
  48. /*...vgbmpgm\46\h:0:*/
  49. /*...vgbmppm\46\h:0:*/
  50. /*...vgbmbmp\46\h:0:*/
  51. /*...vgbmtga\46\h:0:*/
  52. /*...vgbmkps\46\h:0:*/
  53. /*...vgbmiax\46\h:0:*/
  54. /*...vgbmpcx\46\h:0:*/
  55. /*...vgbmtif\46\h:0:*/
  56. /*...vgbmlbm\46\h:0:*/
  57. /*...vgbmvid\46\h:0:*/
  58. /*...vgbmgif\46\h:0:*/
  59. /*...vgbmxbm\46\h:0:*/
  60. /*...vgbmspr\46\h:0:*/
  61. /*...vgbmpsg\46\h:0:*/
  62. /*...vgbmgem\46\h:0:*/
  63. /*...vgbmcvp\46\h:0:*/
  64. /*...vgbmjpg\46\h:0:*/
  65.  
  66. typedef struct
  67.     {
  68.     GBM_ERR      (*query_filetype)(GBMFT *gbmft);
  69.     GBM_ERR      (*read_header )(const char *fn, int fd, GBM *gbm, const char *opt);
  70.     GBM_ERR      (*read_palette)(int fd, GBM *gbm, GBMRGB *gbmrgb);
  71.     GBM_ERR      (*read_data   )(int fd, GBM *gbm, byte *data);
  72.     GBM_ERR      (*write       )(const char *fn, int fd, const GBM *gbm, const GBMRGB *gbmrgb, const byte *data, const char *opt);
  73.     const char * (*err         )(GBM_ERR rc);
  74.     } FT;
  75.  
  76. static FT fts[] =
  77.     {
  78.     bmp_qft, bmp_rhdr, bmp_rpal, bmp_rdata, bmp_w, bmp_err,
  79.     gif_qft, gif_rhdr, gif_rpal, gif_rdata, gif_w, gif_err,
  80.     pcx_qft, pcx_rhdr, pcx_rpal, pcx_rdata, pcx_w, pcx_err,
  81.     tif_qft, tif_rhdr, tif_rpal, tif_rdata, tif_w, tif_err,
  82.     tga_qft, tga_rhdr, tga_rpal, tga_rdata, tga_w, tga_err,
  83.     lbm_qft, lbm_rhdr, lbm_rpal, lbm_rdata, lbm_w, lbm_err,
  84.     vid_qft, vid_rhdr, vid_rpal, vid_rdata, vid_w, vid_err,
  85.     pgm_qft, pgm_rhdr, pgm_rpal, pgm_rdata, pgm_w, pgm_err,
  86.     ppm_qft, ppm_rhdr, ppm_rpal, ppm_rdata, ppm_w, ppm_err,
  87.     kps_qft, kps_rhdr, kps_rpal, kps_rdata, kps_w, kps_err,
  88.     iax_qft, iax_rhdr, iax_rpal, iax_rdata, iax_w, iax_err,
  89.     xbm_qft, xbm_rhdr, xbm_rpal, xbm_rdata, xbm_w, xbm_err,
  90.     spr_qft, spr_rhdr, spr_rpal, spr_rdata, spr_w, spr_err,
  91.     psg_qft, psg_rhdr, psg_rpal, psg_rdata, psg_w, psg_err,
  92.     gem_qft, gem_rhdr, gem_rpal, gem_rdata, gem_w, gem_err,
  93.     cvp_qft, cvp_rhdr, cvp_rpal, cvp_rdata, cvp_w, cvp_err,
  94. #ifdef IJG
  95.     jpg_qft, jpg_rhdr, jpg_rpal, jpg_rdata, jpg_w, jpg_err,
  96. #endif
  97.     };
  98.  
  99. #define    N_FT (sizeof(fts) / sizeof(fts[0]))
  100. /*...e*/
  101. /*...sextension:0:*/
  102. static const char *extension(const char *fn)
  103.     {
  104.     const char *dot, *slash;
  105.  
  106.     if ( (dot = strrchr(fn, '.')) == NULL )
  107.         return NULL;
  108.  
  109.     if ( (slash = strpbrk(fn, "/\\")) == NULL )
  110.         return dot + 1;
  111.  
  112.     return ( slash < dot ) ? dot + 1 : NULL;
  113.     }
  114. /*...e*/
  115.  
  116. /*...sgbm_init:0:*/
  117. GBMEXPORT GBM_ERR GBMENTRY gbm_init(void)
  118.     {
  119.     return GBM_ERR_OK;
  120.     }
  121. /*...e*/
  122. /*...sgbm_deinit:0:*/
  123. GBMEXPORT GBM_ERR GBMENTRY gbm_deinit(void)
  124.     {
  125.     return GBM_ERR_OK;
  126.     }
  127. /*...e*/
  128. /*...sgbm_io_\42\:0:*/
  129. GBMEXPORT GBM_ERR GBMENTRY gbm_io_setup(
  130.     int  (*open  )(const char *fn, int mode),
  131.     int  (*create)(const char *fn, int mode),
  132.     void (*close )(int fd),
  133.     long (*lseek )(int fd, long pos, int whence),
  134.     int  (*read  )(int fd, void *buf, int len),
  135.     int  (*write )(int fd, const void *buf, int len)
  136.     )
  137.     {
  138.     gbm_file_open   = open  ;
  139.     gbm_file_create = create;
  140.     gbm_file_close  = close ;
  141.     gbm_file_lseek  = lseek ;
  142.     gbm_file_read   = read  ;
  143.     gbm_file_write  = write ;
  144.     return GBM_ERR_OK;
  145.     }
  146.  
  147. GBMEXPORT int  GBMENTRY gbm_io_open(const char *fn, int mode)
  148.     { return gbm_file_open(fn, mode); }
  149. GBMEXPORT int  GBMENTRY gbm_io_create(const char *fn, int mode)
  150.     { return gbm_file_create(fn, mode); }
  151. GBMEXPORT void GBMENTRY gbm_io_close(int fd)
  152.     { gbm_file_close(fd); }
  153. GBMEXPORT long GBMENTRY gbm_io_lseek(int fd, long pos, int whence)
  154.     { return gbm_file_lseek(fd, pos, whence); }
  155. GBMEXPORT int  GBMENTRY gbm_io_read (int fd, void *buf, int len)
  156.     { return gbm_file_read(fd, buf, len); }
  157. GBMEXPORT int  GBMENTRY gbm_io_write(int fd, const void *buf, int len)
  158.     { return gbm_file_write(fd, buf, len); }
  159. /*...e*/
  160. /*...sgbm_query_n_filetypes:0:*/
  161. GBMEXPORT GBM_ERR GBMENTRY gbm_query_n_filetypes(int *n_ft)
  162.     {
  163.     if ( n_ft == NULL )
  164.         return GBM_ERR_BAD_ARG;
  165.     *n_ft = N_FT;
  166.     return GBM_ERR_OK;
  167.     }
  168. /*...e*/
  169. /*...sgbm_guess_filetype:0:*/
  170. GBMEXPORT GBM_ERR GBMENTRY gbm_guess_filetype(const char *fn, int *ft)
  171.     {
  172.     int i;
  173.     const char *ext;
  174.  
  175.     if ( fn == NULL || ft == NULL )
  176.         return GBM_ERR_BAD_ARG;
  177.  
  178.     if ( (ext = extension(fn)) == NULL )
  179.         ext = "";
  180.  
  181.     for ( i = 0; i < N_FT; i++ )
  182.         {
  183.         GBMFT    gbmft;
  184.         char    buf[100+1], *s;
  185.  
  186.         fts[i].query_filetype(&gbmft);
  187.         for ( s  = strtok(strcpy(buf, gbmft.extensions), " \t,");
  188.               s != NULL;
  189.               s  = strtok(NULL, " \t,") )
  190.             if ( gbm_same(s, ext, (int) strlen(ext) + 1) )
  191.                 {
  192.                 *ft = i;
  193.                 return GBM_ERR_OK;
  194.                 }
  195.         }
  196.     return GBM_ERR_NOT_FOUND;
  197.     }
  198. /*...e*/
  199. /*...sgbm_query_filetype:0:*/
  200. GBMEXPORT GBM_ERR GBMENTRY gbm_query_filetype(int ft, GBMFT *gbmft)
  201.     {
  202.     if ( gbmft == NULL )
  203.         return GBM_ERR_BAD_ARG;
  204.     return (*fts[ft].query_filetype)(gbmft);
  205.     }
  206. /*...e*/
  207. /*...sgbm_read_header:0:*/
  208. GBMEXPORT GBM_ERR GBMENTRY gbm_read_header(const char *fn, int fd, int ft, GBM *gbm, const char *opt)
  209.     {
  210.     if ( fn == NULL || opt == NULL || gbm == NULL )
  211.         return GBM_ERR_BAD_ARG;
  212.     gbm_file_lseek(fd, 0L, SEEK_SET);
  213.     return (*fts[ft].read_header)(fn, fd, gbm, opt);
  214.     }
  215. /*...e*/
  216. /*...sgbm_read_palette:0:*/
  217. GBMEXPORT GBM_ERR GBMENTRY gbm_read_palette(int fd, int ft, GBM *gbm, GBMRGB *gbmrgb)
  218.     {
  219.     if ( gbm == NULL || gbmrgb == NULL )
  220.         return GBM_ERR_BAD_ARG;
  221.     return (*fts[ft].read_palette)(fd, gbm, gbmrgb);
  222.     }
  223. /*...e*/
  224. /*...sgbm_read_data:0:*/
  225. GBMEXPORT GBM_ERR GBMENTRY gbm_read_data(int fd, int ft, GBM *gbm, byte *data)
  226.     {
  227.     if ( gbm == NULL || data == NULL )
  228.         return GBM_ERR_BAD_ARG;
  229.     return (*fts[ft].read_data)(fd, gbm, data);
  230.     }
  231. /*...e*/
  232. /*...sgbm_write:0:*/
  233. GBMEXPORT GBM_ERR GBMENTRY gbm_write(const char *fn, int fd, int ft, const GBM *gbm, const GBMRGB *gbmrgb, const byte *data, const char *opt)
  234.     {
  235.     if ( fn == NULL || opt == NULL )
  236.         return GBM_ERR_BAD_ARG;
  237.     return (*fts[ft].write)(fn, fd, gbm, gbmrgb, data, opt);
  238.     }
  239. /*...e*/
  240. /*...sgbm_err:0:*/
  241. GBMEXPORT const char * GBMENTRY gbm_err(GBM_ERR rc)
  242.     {
  243.     int ft;
  244.  
  245.     switch ( (int) rc )
  246.         {
  247.         case GBM_ERR_OK:
  248.             return "ok";
  249.         case GBM_ERR_MEM:
  250.             return "out of memory";
  251.         case GBM_ERR_NOT_SUPP:
  252.             return "not supported";
  253.         case GBM_ERR_BAD_OPTION:
  254.             return "bad option(s)";
  255.         case GBM_ERR_NOT_FOUND:
  256.             return "not found";
  257.         case GBM_ERR_BAD_MAGIC:
  258.             return "bad magic number / signiture block";
  259.         case GBM_ERR_BAD_SIZE:
  260.             return "bad bitmap size";
  261.         case GBM_ERR_READ:
  262.             return "can't read file";
  263.         case GBM_ERR_WRITE:
  264.             return "can't write file";
  265.         case GBM_ERR_BAD_ARG:
  266.             return "bad argument to gbm function";
  267.         }
  268.  
  269.     for ( ft = 0; ft < N_FT; ft++ )
  270.         {
  271.         const char *s;
  272.  
  273.         if ( (s = (*fts[ft].err)(rc)) != NULL )
  274.             return s;
  275.         }
  276.  
  277.     return "general error";
  278.     }
  279. /*...e*/
  280. /*...sgbm_version:0:*/
  281. GBMEXPORT int GBMENTRY gbm_version(void)
  282.     {
  283.     return 110; /* 1.10 */
  284.     }
  285. /*...e*/
  286.  
  287. #ifdef OS2
  288. /*...s_System entrypoints:0:*/
  289. /* For GBM.DLL to be callable from IBM Smalltalk under OS/2, the entrypoints
  290.    must be of _System calling convention. These veneers help out here.
  291.    I can't just change the usual entrypoints because people depend on them. */
  292.  
  293. GBM_ERR _System Gbm_init(void)
  294.     { return gbm_init(); }
  295.  
  296. GBM_ERR _System Gbm_deinit(void)
  297.     { return gbm_deinit(); }
  298.  
  299. /* Gbm_io_setup omitted for now...
  300.    Implies GBM.DLL must call out to non-_Optlink callback routines. */
  301.  
  302. int _System Gbm_io_open(const char *fn, int mode)
  303.     { return gbm_io_open(fn, mode); }
  304.  
  305. int _System Gbm_io_create(const char *fn, int mode)
  306.     { return gbm_io_create(fn, mode); }
  307.  
  308. void _System Gbm_io_close(int fd)
  309.     { gbm_io_close(fd); }
  310.  
  311. long _System Gbm_io_lseek(int fd, long pos, int whence)
  312.     { return gbm_file_lseek(fd, pos, whence); }
  313.  
  314. int _System Gbm_io_read (int fd, void *buf, int len)
  315.     { return gbm_file_read(fd, buf, len); }
  316.  
  317. int _System Gbm_io_write(int fd, const void *buf, int len)
  318.     { return gbm_file_write(fd, buf, len); }
  319.  
  320. GBM_ERR _System Gbm_query_n_filetypes(int *n_ft)
  321.     { return gbm_query_n_filetypes(n_ft); }
  322.  
  323. GBM_ERR _System Gbm_guess_filetype(const char *fn, int *ft)
  324.     { return gbm_guess_filetype(fn, ft); }
  325.  
  326. GBM_ERR    _System Gbm_query_filetype(int ft, GBMFT *gbmft)
  327.     { return gbm_query_filetype(ft, gbmft); }
  328.  
  329. GBM_ERR _System Gbm_read_header(const char *fn, int fd, int ft, GBM *gbm, const char *opt)
  330.     { return gbm_read_header(fn, fd, ft, gbm, opt); }
  331.  
  332. GBM_ERR _System Gbm_read_palette(int fd, int ft, GBM *gbm, GBMRGB *gbmrgb)
  333.     { return gbm_read_palette(fd, ft, gbm, gbmrgb); }
  334.  
  335. GBM_ERR _System Gbm_read_data(int fd, int ft, GBM *gbm, byte *data)
  336.     { return gbm_read_data(fd, ft, gbm, data); }
  337.  
  338. GBM_ERR _System Gbm_write(const char *fn, int fd, int ft, const GBM *gbm, const GBMRGB *gbmrgb, const byte *data, const char *opt)
  339.     { return gbm_write(fn, fd, ft, gbm, gbmrgb, data, opt); }
  340.  
  341. const char * _System Gbm_err(GBM_ERR rc)
  342.     { return gbm_err(rc); }
  343.  
  344. int _System Gbm_version(void)
  345.     { return gbm_version(); }
  346. /*...e*/
  347. #endif
  348.