home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / rexx / library2 / gbmrexx / gbm / gbmsub.c < prev    next >
C/C++ Source or Header  |  1993-05-20  |  6KB  |  256 lines
  1. /*
  2.  
  3. GBMSUB.C  Subrectangle of 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 "gbmrect.h"
  30.  
  31. /*...vgbm\46\h:0:*/
  32. /*...vgbmrect\46\h:0:*/
  33. /*...e*/
  34.  
  35. static char progname [] = "gbmsub";
  36. static char sccs_id [] = "@(#)Subrectangle of 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 [-x x] [-y y] [-w w] [-h h] fn1.ext{,opt} [fn2.ext{,opt}]\n", progname);
  57.     fprintf(stderr, "flags: -x x           left edge of rectangle (default 0)\n");
  58.     fprintf(stderr, "       -y y           bottom edge of rectangle (default 0)\n");
  59.     fprintf(stderr, "       -w w           width of rectangle (default width of image - x)\n");
  60.     fprintf(stderr, "       -h h           height of rectangle (default height of image - y)\n");
  61.     fprintf(stderr, "       fn1.ext{,opt}  input filename (with any format specific options)\n");
  62.     fprintf(stderr, "       fn2.ext{,opt}  optional output filename (or will use fn1 if not present)\n");
  63.     fprintf(stderr, "                      ext's are used to deduce desired bitmap file formats\n");
  64.  
  65.     gbm_init();
  66.     gbm_query_n_filetypes(&n_ft);
  67.     for ( ft = 0; ft < n_ft; ft++ )
  68.         {
  69.         GBMFT gbmft;
  70.  
  71.         gbm_query_filetype(ft, &gbmft);
  72.         fprintf(stderr, "                      %s when ext in [%s]\n",
  73.             gbmft.short_name, gbmft.extensions);
  74.         }
  75.     gbm_deinit();
  76.  
  77.     fprintf(stderr, "       opt's          bitmap format specific options\n");
  78.  
  79.     exit(1);
  80.     }
  81. /*...e*/
  82. /*...sget_opt_value:0:*/
  83. static int get_opt_value(char *s, char *name)
  84.     {
  85.     int    v;
  86.  
  87.     if ( s == NULL )
  88.         fatal("missing %s argument", name);
  89.     if ( !isdigit(s [0]) )
  90.         fatal("bad %s argument", name);
  91.     if ( s [0] == '0' && tolower(s [1]) == 'x' )
  92.         sscanf(s + 2, "%x", &v);
  93.     else
  94.         v = atoi(s);
  95.  
  96.     return ( v );
  97.     }
  98. /*...e*/
  99. /*...sget_opt_value_pos:0:*/
  100. static int get_opt_value_pos(char *s, char *name)
  101.     {
  102.     int    n;
  103.  
  104.     if ( (n = get_opt_value(s, name)) < 0 )
  105.         fatal("%s should not be negative", name);
  106.     return ( n );
  107.     }
  108. /*...e*/
  109. /*...smain:0:*/
  110. int    main(int argc, char *argv [])
  111.     {
  112.     int    x = 0, y = 0, w = -1, h = -1;
  113.     char    fn_src [500+1], fn_dst [500+1], *opt_src, *opt_dst;
  114.     int    fd, ft_src, ft_dst, i, stride_src, flag, bytes;
  115.     GBM_ERR    rc;
  116.     GBMFT    gbmft;
  117.     GBM    gbm;
  118.     GBMRGB    gbmrgb [0x100];
  119.     byte    *data;
  120.  
  121.     for ( i = 1; i < argc; i++ )
  122.         {
  123.         if ( argv [i][0] != '-' )
  124.             break;
  125.         switch ( argv [i][1] )
  126.             {
  127.             case 'x':
  128.                 if ( ++i == argc ) usage();
  129.                 x = get_opt_value_pos(argv [i], "x");
  130.                 break;
  131.             case 'y':
  132.                 if ( ++i == argc ) usage();
  133.                 y = get_opt_value_pos(argv [i], "y");
  134.                 break;
  135.             case 'w':
  136.                 if ( ++i == argc ) usage();
  137.                 w = get_opt_value_pos(argv [i], "w");
  138.                 break;
  139.             case 'h':
  140.                 if ( ++i == argc ) usage();
  141.                 h = get_opt_value_pos(argv [i], "h");
  142.                 break;
  143.             default:
  144.                 usage();
  145.                 break;
  146.             }
  147.         }
  148.  
  149.     if ( i == argc )
  150.         usage();
  151.     strcpy(fn_src, argv [i++]);
  152.     strcpy(fn_dst, ( i == argc ) ? fn_src : argv [i++]);
  153.     if ( i < argc )
  154.         usage();
  155.  
  156.     if ( (opt_src = strchr(fn_src, ',')) != NULL )
  157.         *opt_src++ = '\0';
  158.     else
  159.         opt_src = "";
  160.  
  161.     if ( (opt_dst = strchr(fn_dst, ',')) != NULL )
  162.         *opt_dst++ = '\0';
  163.     else
  164.         opt_dst = "";
  165.  
  166.     gbm_init();
  167.  
  168.     if ( gbm_guess_filetype(fn_src, &ft_src) != GBM_ERR_OK )
  169.         fatal("can't guess bitmap file format for %s", fn_src);
  170.  
  171.     if ( gbm_guess_filetype(fn_dst, &ft_dst) != GBM_ERR_OK )
  172.         fatal("can't guess bitmap file format for %s", fn_dst);
  173.  
  174.     if ( (fd = open(fn_src, O_RDONLY | O_BINARY)) == -1 )
  175.         fatal("can't open %s", fn_src);
  176.  
  177.     if ( (rc = gbm_read_header(fn_src, fd, ft_src, &gbm, opt_src)) != GBM_ERR_OK )
  178.         {
  179.         close(fd);
  180.         fatal("can't read header of %s: %s", fn_src, gbm_err(rc));
  181.         }
  182.  
  183.     if ( w == -1 )
  184.         w = gbm.w - x;
  185.  
  186.     if ( h == -1 )
  187.         h = gbm.h - y;
  188.  
  189.     if ( w     == 0     ) { close(fd); fatal("w = 0"); }
  190.     if ( h     == 0     ) { close(fd); fatal("h = 0"); }
  191.     if ( x     >= gbm.w ) { close(fd); fatal("x >= bitmap width"); }
  192.     if ( y     >= gbm.h ) { close(fd); fatal("y >= bitmap height"); }
  193.     if ( x + w >  gbm.w ) { close(fd); fatal("x+w > bitmap width"); }
  194.     if ( y + h >  gbm.h ) { close(fd); fatal("y+h > bitmap height"); }
  195.  
  196.     gbm_query_filetype(ft_dst, &gbmft);
  197.     switch ( gbm.bpp )
  198.         {
  199.         case 24:    flag = GBM_FT_W24;    break;
  200.         case 8:        flag = GBM_FT_W8;    break;
  201.         case 4:        flag = GBM_FT_W4;    break;
  202.         case 1:        flag = GBM_FT_W1;    break;
  203.         }
  204.     if ( (gbmft.flags & flag) == 0 )
  205.         {
  206.         close(fd);
  207.         fatal("output bitmap format %s does not support writing %d bpp data",
  208.             gbmft.short_name, gbm.bpp);
  209.         }
  210.  
  211.     if ( (rc = gbm_read_palette(fd, ft_src, &gbm, gbmrgb)) != GBM_ERR_OK )
  212.         {
  213.         close(fd);
  214.         fatal("can't read palette of %s: %s", fn_src, gbm_err(rc));
  215.         }
  216.  
  217.     stride_src = ( ((gbm.w * gbm.bpp + 31)/32) * 4 );
  218.     bytes = stride_src * gbm.h;
  219.     if ( (data = malloc(bytes)) == NULL )
  220.         {
  221.         close(fd);
  222.         fatal("out of memory allocating %d bytes for bitmap", bytes);
  223.         }
  224.  
  225.     if ( (rc = gbm_read_data(fd, ft_src, &gbm, data)) != GBM_ERR_OK )
  226.         {
  227.         close(fd);
  228.         fatal("can't read bitmap data of %s: %s", fn_src, gbm_err(rc));
  229.         }
  230.  
  231.     close(fd);
  232.  
  233.     gbm_subrectangle(&gbm, x, y, w, h, data, data);
  234.  
  235.     if ( (fd = open(fn_dst, O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, S_IREAD | S_IWRITE)) == -1 )
  236.         fatal("can't create %s", fn_dst);
  237.  
  238.     gbm.w = w;
  239.     gbm.h = h;
  240.  
  241.     if ( (rc = gbm_write(fn_dst, fd, ft_dst, &gbm, gbmrgb, data, opt_dst)) != GBM_ERR_OK )
  242.         {
  243.         close(fd);
  244.         fatal("can't write %s: %s", fn_dst, gbm_err(rc));
  245.         }
  246.  
  247.     close(fd);
  248.  
  249.     free(data);
  250.  
  251.     gbm_deinit();
  252.  
  253.     return ( 0 );
  254.     }
  255. /*...e*/
  256.