home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / rexx / library2 / gbmrexx / gbm / gbmref.c < prev    next >
C/C++ Source or Header  |  1993-02-20  |  5KB  |  217 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. #ifdef AIX
  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 "standard.h"
  28. #include "gbm.h"
  29. #include "gbmmir.h"
  30.  
  31. /*...vgbm\46\h:0:*/
  32. /*...vgbmmir\46\h:0:*/
  33. /*...e*/
  34.  
  35. static char progname [] = "gbmref";
  36. static char sccs_id [] = "@(#)Reflect General Bitmap  1/3/93";
  37.  
  38. /*...sfatal:0:*/
  39. static void fatal(const char *fmt, ...)
  40.     {
  41.     va_list    vars;
  42.     char    s [256+1];
  43.  
  44.     va_start(vars, fmt);
  45.     vsprintf(s, fmt, vars);
  46.     va_end(vars);
  47.     fprintf(stderr, "%s: %s\n", progname, s);
  48.     exit(1);
  49.     }
  50. /*...e*/
  51. /*...susage:0:*/
  52. static void usage(void)
  53.     {
  54.     int    ft, n_ft;
  55.  
  56.     fprintf(stderr, "usage: %s [-h] [-v] [-t] fn1.ext{,opt} [fn2.ext{,opt}]\n", progname);
  57.     fprintf(stderr, "flags: -h             reflect horizontally\n");
  58.     fprintf(stderr, "       -v             reflect vertically\n");
  59.     fprintf(stderr, "       -t             transpose x by y\n");
  60.     fprintf(stderr, "       fn1.ext{,opt}  input filename (with any format specific options)\n");
  61.     fprintf(stderr, "       fn2.ext{,opt}  optional output filename (or will use fn1 if not present)\n");
  62.     fprintf(stderr, "                      ext's are used to deduce desired bitmap file formats\n");
  63.  
  64.     gbm_init();
  65.     gbm_query_n_filetypes(&n_ft);
  66.     for ( ft = 0; ft < n_ft; ft++ )
  67.         {
  68.         GBMFT gbmft;
  69.  
  70.         gbm_query_filetype(ft, &gbmft);
  71.         fprintf(stderr, "                      %s when ext in [%s]\n",
  72.             gbmft.short_name, gbmft.extensions);
  73.         }
  74.     gbm_deinit();
  75.  
  76.     fprintf(stderr, "       opt's          bitmap format specific options\n");
  77.  
  78.     exit(1);
  79.     }
  80. /*...e*/
  81. /*...smain:0:*/
  82. int    main(int argc, char *argv [])
  83.     {
  84.     BOOLEAN    horz = FALSE, vert = FALSE, trans = FALSE;
  85.     char    fn_src [500+1], fn_dst [500+1], *opt_src, *opt_dst;
  86.     int    fd, ft_src, ft_dst, i, stride, bytes, flag;
  87.     GBM_ERR    rc;
  88.     GBMFT    gbmft;
  89.     GBM    gbm;
  90.     GBMRGB    gbmrgb [0x100];
  91.     byte    *data;
  92.  
  93.     for ( i = 1; i < argc; i++ )
  94.         {
  95.         if ( argv [i][0] != '-' )
  96.             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 = 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.         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.         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.         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(bytes)) == NULL )
  164.         {
  165.         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.         close(fd);
  172.         fatal("can't read bitmap data of %s: %s", fn_src, gbm_err(rc));
  173.         }
  174.  
  175.     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(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 = open(fn_dst, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, S_IREAD | S_IWRITE)) == -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.         close(fd);
  205.         fatal("can't write %s: %s", fn_dst, gbm_err(rc));
  206.         }
  207.  
  208.     close(fd);
  209.  
  210.     free(data);
  211.  
  212.     gbm_deinit();
  213.  
  214.     return ( 0 );
  215.     }
  216. /*...e*/
  217.