home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / gbmsrc.zip / gbmref.c < prev    next >
C/C++ Source or Header  |  1998-12-31  |  5KB  |  218 lines
  1. /*
  2.  
  3. gbmref.c - Reflect General Bitmap
  4.  
  5. */
  6.  
  7. /*...sincludes:0:*/
  8. #include <stdio.h>
  9. #include <ctype.h>
  10. #include <string.h>
  11. #include <stddef.h>
  12. #include <stdlib.h>
  13. #include <stdarg.h>
  14. #include <memory.h>
  15. #include <malloc.h>
  16. #if defined(AIX) || defined(LINUX)
  17. #include <unistd.h>
  18. #else
  19. #include <io.h>
  20. #endif
  21. #include <fcntl.h>
  22. #include <sys/types.h>
  23. #include <sys/stat.h>
  24. #ifndef O_BINARY
  25. #define    O_BINARY    0
  26. #endif
  27. #include "gbm.h"
  28. #include "gbmmir.h"
  29.  
  30. /*...vgbm\46\h:0:*/
  31. /*...vgbmmir\46\h:0:*/
  32. /*...e*/
  33.  
  34. static char progname[] = "gbmref";
  35.  
  36. /*...sfatal:0:*/
  37. static void fatal(const char *fmt, ...)
  38.     {
  39.     va_list    vars;
  40.     char s[256+1];
  41.  
  42.     va_start(vars, fmt);
  43.     vsprintf(s, fmt, vars);
  44.     va_end(vars);
  45.     fprintf(stderr, "%s: %s\n", progname, s);
  46.     exit(1);
  47.     }
  48. /*...e*/
  49. /*...susage:0:*/
  50. static void usage(void)
  51.     {
  52.     int ft, n_ft;
  53.  
  54.     fprintf(stderr, "usage: %s [-h] [-v] [-t] fn1.ext{,opt} [--] [fn2.ext{,opt}]\n", progname);
  55.     fprintf(stderr, "flags: -h             reflect horizontally\n");
  56.     fprintf(stderr, "       -v             reflect vertically\n");
  57.     fprintf(stderr, "       -t             transpose x by y\n");
  58.     fprintf(stderr, "       fn1.ext{,opt}  input filename (with any format specific options)\n");
  59.     fprintf(stderr, "       fn2.ext{,opt}  optional output filename (or will use fn1 if not present)\n");
  60.     fprintf(stderr, "                      ext's are used to deduce desired bitmap file formats\n");
  61.  
  62.     gbm_init();
  63.     gbm_query_n_filetypes(&n_ft);
  64.     for ( ft = 0; ft < n_ft; ft++ )
  65.         {
  66.         GBMFT gbmft;
  67.  
  68.         gbm_query_filetype(ft, &gbmft);
  69.         fprintf(stderr, "                      %s when ext in [%s]\n",
  70.             gbmft.short_name, gbmft.extensions);
  71.         }
  72.     gbm_deinit();
  73.  
  74.     fprintf(stderr, "       opt's          bitmap format specific options\n");
  75.  
  76.     exit(1);
  77.     }
  78. /*...e*/
  79. /*...smain:0:*/
  80. int main(int argc, char *argv[])
  81.     {
  82.     BOOLEAN    horz = FALSE, vert = FALSE, trans = FALSE;
  83.     char    fn_src[500+1], fn_dst[500+1], *opt_src, *opt_dst;
  84.     int    fd, ft_src, ft_dst, i, stride, bytes, flag;
  85.     GBM_ERR    rc;
  86.     GBMFT    gbmft;
  87.     GBM    gbm;
  88.     GBMRGB    gbmrgb[0x100];
  89.     byte    *data;
  90.  
  91.     for ( i = 1; i < argc; i++ )
  92.         {
  93.         if ( argv[i][0] != '-' )
  94.             break;
  95.         else if ( argv[i][1] == '-' )
  96.             { ++i; break; }
  97.         switch ( argv[i][1] )
  98.             {
  99.             case 'h':    horz = TRUE;    break;
  100.             case 'v':    vert = TRUE;    break;
  101.             case 't':    trans = TRUE;    break;
  102.             default:    usage();    break;
  103.             }
  104.         }
  105.  
  106.     if ( i == argc )
  107.         usage();
  108.     strcpy(fn_src, argv[i++]);
  109.     strcpy(fn_dst, ( i == argc ) ? fn_src : argv[i++]);
  110.     if ( i < argc )
  111.         usage();
  112.  
  113.     if ( (opt_src = strchr(fn_src, ',')) != NULL )
  114.         *opt_src++ = '\0';
  115.     else
  116.         opt_src = "";
  117.  
  118.     if ( (opt_dst = strchr(fn_dst, ',')) != NULL )
  119.         *opt_dst++ = '\0';
  120.     else
  121.         opt_dst = "";
  122.  
  123.     gbm_init();
  124.  
  125.     if ( gbm_guess_filetype(fn_src, &ft_src) != GBM_ERR_OK )
  126.         fatal("can't guess bitmap file format for %s", fn_src);
  127.  
  128.     if ( gbm_guess_filetype(fn_dst, &ft_dst) != GBM_ERR_OK )
  129.         fatal("can't guess bitmap file format for %s", fn_dst);
  130.  
  131.     if ( (fd = gbm_io_open(fn_src, O_RDONLY|O_BINARY)) == -1 )
  132.         fatal("can't open %s", fn_src);
  133.  
  134.     if ( (rc = gbm_read_header(fn_src, fd, ft_src, &gbm, opt_src)) != GBM_ERR_OK )
  135.         {
  136.         gbm_io_close(fd);
  137.         fatal("can't read header of %s: %s", fn_src, gbm_err(rc));
  138.         }
  139.  
  140.     gbm_query_filetype(ft_dst, &gbmft);
  141.     switch ( gbm.bpp )
  142.         {
  143.         case 24:    flag = GBM_FT_W24;    break;
  144.         case 8:        flag = GBM_FT_W8;    break;
  145.         case 4:        flag = GBM_FT_W4;    break;
  146.         case 1:        flag = GBM_FT_W1;    break;
  147.         }
  148.     if ( (gbmft.flags & flag) == 0 )
  149.         {
  150.         gbm_io_close(fd);
  151.         fatal("output bitmap format %s does not support writing %d bpp data",
  152.             gbmft.short_name, gbm.bpp);
  153.         }
  154.  
  155.     if ( (rc = gbm_read_palette(fd, ft_src, &gbm, gbmrgb)) != GBM_ERR_OK )
  156.         {
  157.         gbm_io_close(fd);
  158.         fatal("can't read palette of %s: %s", fn_src, gbm_err(rc));
  159.         }
  160.  
  161.     stride = ( ((gbm.w * gbm.bpp + 31)/32) * 4 );
  162.     bytes = stride * gbm.h;
  163.     if ( (data = malloc((size_t) bytes)) == NULL )
  164.         {
  165.         gbm_io_close(fd);
  166.         fatal("out of memory allocating %d bytes for bitmap", bytes);
  167.         }
  168.  
  169.     if ( (rc = gbm_read_data(fd, ft_src, &gbm, data)) != GBM_ERR_OK )
  170.         {
  171.         gbm_io_close(fd);
  172.         fatal("can't read bitmap data of %s: %s", fn_src, gbm_err(rc));
  173.         }
  174.  
  175.     gbm_io_close(fd);
  176.  
  177.     if ( vert )
  178.         if ( !gbm_ref_vert(&gbm, data) )
  179.             fatal("unable to reflect vertically");
  180.  
  181.     if ( horz )
  182.         if ( !gbm_ref_horz(&gbm, data) )
  183.             fatal("unable to reflect horizontally");
  184.  
  185.     if ( trans )
  186.         {
  187.         int t, stride_t = ((gbm.h * gbm.bpp + 31) / 32) * 4;
  188.         byte *data_t;
  189.  
  190.         if ( (data_t = malloc((size_t) (gbm.w * stride_t))) == NULL )
  191.             fatal("out of memory allocating %u bytes", gbm.w * stride_t);
  192.  
  193.         gbm_transpose(&gbm, data, data_t);
  194.         t = gbm.w; gbm.w = gbm.h; gbm.h = t;
  195.         free(data);
  196.         data = data_t;
  197.         }
  198.  
  199.     if ( (fd = gbm_io_create(fn_dst, O_WRONLY|O_BINARY)) == -1 )
  200.         fatal("can't create %s", fn_dst);
  201.  
  202.     if ( (rc = gbm_write(fn_dst, fd, ft_dst, &gbm, gbmrgb, data, opt_dst)) != GBM_ERR_OK )
  203.         {
  204.         gbm_io_close(fd);
  205.         remove(fn_dst);
  206.         fatal("can't write %s: %s", fn_dst, gbm_err(rc));
  207.         }
  208.  
  209.     gbm_io_close(fd);
  210.  
  211.     free(data);
  212.  
  213.     gbm_deinit();
  214.  
  215.     return 0;
  216.     }
  217. /*...e*/
  218.