home *** CD-ROM | disk | FTP | other *** search
/ Encyclopedia of Graphics File Formats Companion / GFF_CD.ISO / software / unix / saoimage / sao1_07.tar / mainbffr.c < prev    next >
C/C++ Source or Header  |  1990-04-20  |  8KB  |  247 lines
  1. #ifndef lint
  2. static char SccsId[] = "%W%  %G%";
  3. #endif
  4.  
  5. /* Module:    mainbffr.c (Main Buffers)
  6.  * Purpose:    Allocate or reallocate large buffers
  7.  * Subroutine:    init_imaging buffers()        returns: void
  8.  * Subroutine:    init_display_buffers()        returns: void
  9.  * Subroutine:    init_colorbarbuf()        returns: void
  10.  * Subroutine:    init_panbuf()            returns: void
  11.  * Subroutine:    init_dispbuf()            returns: void
  12.  * Subroutine:    init_imagebuf()            returns: int
  13.  * Xlib calls:    none
  14.  * Copyright:    1989 Smithsonian Astrophysical Observatory
  15.  *        You may do anything you like with this file except remove
  16.  *        this copyright.  The Smithsonian Astrophysical Observatory
  17.  *        makes no representations about the suitability of this
  18.  *        software for any purpose.  It is provided "as is" without
  19.  *        express or implied warranty.
  20.  * Modified:    {0} Michael VanHilst    initial version          25 May 1989
  21.  *              {1} MVH fix in init_imagebuf to note square buf  4 April 1990
  22.  *        {n} <who> -- <does what> -- <when>
  23.  */
  24.  
  25. #include <stdio.h>        /* get stderr, NULL, etc */
  26. #include <X11/Xlib.h>        /* X window stuff */
  27. #include <X11/Xutil.h>        /* X window manager stuff */
  28. #include "hfiles/define.h"    /* define MIN, MAX, etc. */
  29. #include "hfiles/struct.h"    /* declare structure types */
  30. #include "hfiles/extern.h"    /* extern main parameter structures */
  31. #include "hfiles/scale.h"    /* define scaling constants */
  32.  
  33. /*
  34.  * Subroutine:    init_imaging_buffers
  35.  * Purpose:    Allocate major buffers used for imaging
  36.  */
  37. void init_imaging_buffers ()
  38. {
  39.   char *calloc_errchk();
  40.   int init_imagebuf();
  41.  
  42.   buffer.scalemap = (unsigned char *)
  43.     calloc_errchk(SCALEBUFSZ, sizeof(char), "scaling map");
  44.   buffer.histogram = (int *)
  45.     calloc_errchk(SCALEBUFSZ, sizeof(int), "histogram table");
  46.   (void)init_imagebuf ();
  47. } 
  48.  
  49. /*
  50.  * Subroutine:    init_display_buffers
  51.  * Purpose:    Allocate buffers used for each window's display
  52.  */
  53. void init_display_buffers ()
  54. {
  55.   void init_panbuf(), init_dispbuf();
  56.  
  57.   init_panbuf();
  58.   init_dispbuf();
  59. } 
  60.  
  61. /*
  62.  * Subroutine:    init_panbuf
  63.  * Purpose:    Allocate or reallocate panbox display buffers
  64.  */
  65. void init_panbuf ()
  66. {
  67.   int buf_sz;
  68.   char *calloc_errchk();
  69.   
  70.   buf_sz = panbox.xwidth * panbox.yheight;
  71.   /* test if the current buffers are adequate, else allocate or reallocate */
  72.   if( buf_sz > buffer.panbuf_sz ) {
  73.     if( buffer.panbuf != NULL )
  74.       free( (char *)buffer.panbuf );
  75.     if( panbox.image.data != NULL ) {
  76.       free( panbox.image.data );
  77.       panbox.image.data = NULL;
  78.       panbox.data_size = 0;
  79.     }
  80.     /* reserve exact window sized buffer for the panbox short integer image */
  81.     buffer.panbuf = (short *)
  82.       calloc_errchk(buf_sz, sizeof(short), "Panbox map");
  83.     buffer.panbuf_sz = buf_sz;
  84.     /* reserve buffer for the panbox display image */
  85.     if( color.screen_depth <= 1 ) {
  86.       /* if only bitmap will be used */
  87.       panbox.image.bytes_per_line = (panbox.xwidth + 7) / 8;
  88.       buf_sz = panbox.image.bytes_per_line * panbox.yheight;
  89.     }
  90.     panbox.image.data = calloc_errchk(buf_sz, sizeof(char), "Panbox display");
  91.     panbox.data_size = buf_sz;
  92.   }
  93.   panbox.image.width = panbox.xwidth;
  94.   panbox.image.height = panbox.yheight;
  95. }
  96.  
  97. /*
  98.  * Subroutine:    init_dispbuf
  99.  * Purpose:    Allocate or reallocate dispbox display buffer
  100.  */
  101. void init_dispbuf ()
  102. {
  103.   int buf_sz;
  104.   char *calloc_errchk();
  105.   void set_coordsys(), set_tdisp();
  106.  
  107.   dispbox.image.width = dispbox.xwidth;
  108.   dispbox.image.height = dispbox.yheight;
  109.   if( color.screen_depth <= 1 ) {
  110.     /* if only bitmap will be used */
  111.     dispbox.image.bytes_per_line = (dispbox.xwidth + 7) / 8;
  112.     buf_sz = dispbox.image.bytes_per_line * dispbox.yheight;
  113.   } else
  114.     buf_sz = dispbox.xwidth * dispbox.yheight;
  115.   /* test if the current buffer is adequate, else allocate or reallocate */
  116.   if( buf_sz > dispbox.data_size ) {
  117.     if( dispbox.image.data != NULL )
  118.       free( dispbox.image.data );
  119.     dispbox.image.data = calloc_errchk(buf_sz, sizeof(char), "Display image");
  120.     dispbox.data_size = buf_sz;
  121.   }
  122.   /* set the display coord system and propose new display parameters */
  123.   set_coordsys(&coord.disp, 0.5, (int)dispbox.width, (int)dispbox.height,
  124.            dispbox.xzero, dispbox.yzero,
  125.            dispbox.xzero + dispbox.xwidth - 1,
  126.            dispbox.yzero + dispbox.yheight - 1);
  127.   /* complete tdi parameters, must already have center and zoom */
  128.   set_tdisp(&coord);
  129. }
  130.  
  131. /*
  132.  * Subroutine:    init_imagebuf
  133.  * Purpose:    Allocate or reallocate main image buffer to fit img or as
  134.  *        much as allowed.  Also allocate file data buffer if data
  135.  *        cannot be read directly into i*2 buf.
  136.  * Returns:    1 on success, else 0.
  137.  * Post-state:    buffer.load_filebuf set to 0 if alloc's failed.
  138.  * Method:    Try to allocate enough for entire given image subsection.
  139.  *        If the display is to be rotated, make the short buf square
  140.  *        or double (whichever is less).
  141.  * Parameters:
  142.  *    buffer:        i/o: record structure for imaging buffers
  143.  *    coord.img:    i: coordinate system of image or image subsection
  144.  *    coord.buf:    o: coordinate system of short integer image buffer
  145.  */
  146. static char imgbuf_error[] =
  147.   "Unable to allocate sufficient memory for requested image.\n";
  148. int init_imagebuf ()
  149. {
  150.   int width, height;
  151.   int img_sz, buf_sz;
  152.   int shortbuf_double = 0;
  153.   int shortbuf_square = 0;
  154.   int did_alloc = 0;
  155.   char *calloc_errchk();
  156.   void set_coordsys();
  157.  
  158.   /* calculate buffer size, use img if within limit, else use limit */
  159.   width = coord.img.width;
  160.   height = coord.img.height;
  161.   img_sz = width * height;
  162.   /* if image is to be rotated 90% (aspect ratio changed) */
  163.   if( img.rotate_code & 1 ) {
  164.     /* make short buffer square or double for rotation algorithm */
  165.     buf_sz = SQR(MAX(width, height));
  166.     if( buf_sz > (2 * img_sz) ) {
  167.       buf_sz = 2 * img_sz;
  168.       shortbuf_double = 1;
  169.     } else
  170.       shortbuf_square = 1;
  171.   } else
  172.     buf_sz = img_sz;
  173.   /* buf_sz is in shorts, img_sz will now be in bytes (as is filebuf_sz) */
  174.   img_sz *= img.bytepix;
  175.   /* free filebuf if unique and inadequate, or unneeded */
  176.   if( buffer.filebuf == (char *)buffer.shortbuf ) {
  177.     buffer.filebuf = NULL;
  178.     buffer.filebuf_sz = 0;
  179.   } else if( (buffer.filebuf != NULL) &&
  180.          ((img.bytepix <= 2) || (img_sz > buffer.filebuf_sz)) ) {
  181.     free( buffer.filebuf );
  182.     buffer.filebuf = NULL;
  183.     buffer.filebuf_sz = 0;
  184.   }
  185.   /* check the adequacy of current short integer image buf */
  186.   if( buf_sz > buffer.shortbuf_sz ) {
  187.     if( buffer.shortbuf != NULL )
  188.       free( (char *)buffer.shortbuf );
  189.     buffer.shortbuf = (short *)calloc_errchk(buf_sz, sizeof(short), NULL);
  190.     if( buffer.shortbuf == 0 ) {
  191.       /* if failed, clear the slate, report error, and continue */
  192.       buffer.shortbuf_sz = 0;
  193.       if( buffer.filebuf != NULL ) {
  194.     free( buffer.filebuf );
  195.     buffer.filebuf = NULL;
  196.     buffer.filebuf_sz = 0;
  197.       }
  198.       (void)fprintf(stderr, imgbuf_error);
  199.       buffer.load_filebuf = 0;
  200.       return( 0 );
  201.     }
  202.     buffer.shortbuf_sz = buf_sz;
  203.     did_alloc = 1;
  204.   }
  205.   /* check on file data buf (if it still exists, it must be adequate) */
  206.   if( buffer.filebuf == NULL ) {
  207.     if( img.bytepix > 2 ) {
  208.       /* force worst case allignment */
  209.       buffer.filebuf = calloc_errchk((img_sz + 7) / 8, 8, NULL);
  210.       if( buffer.filebuf == NULL ) {
  211.     /* if failed, clear the slate, report error, and continue */
  212.     buffer.filebuf_sz = 0;
  213.     free( (char *)buffer.shortbuf );
  214.     buffer.shortbuf = NULL;
  215.     buffer.shortbuf_sz = 0;
  216.     fputs (imgbuf_error, stderr);
  217.     buffer.load_filebuf = 0;
  218.     return( 0 );
  219.       }
  220.       buffer.filebuf_sz = img_sz;
  221.       did_alloc++;
  222.     } else {
  223.       /* no special input buffer needed */
  224.       buffer.filebuf = (char *)buffer.shortbuf;
  225.       /* shortbuf_sz is shorts, filebuf_sz is bytes */
  226.       buffer.filebuf_sz = buffer.shortbuf_sz * sizeof(short);
  227.     }
  228.   }
  229.   /* note rotation space status */
  230.   buffer.shortbuf_double = shortbuf_double;
  231.   buffer.shortbuf_square = shortbuf_square;
  232.   /* set basic buffer coord system parameters (fill buffer) */
  233.   set_coordsys(&coord.buf, 0.5, width, height, 0, 0, width - 1, height - 1);
  234.   /* flag that buffer must be loaded */
  235.   coord.buferror = 1;
  236.   buffer.load_filebuf = 1;
  237.   /* report buffer size */
  238.   if( control.verbose && did_alloc ) {
  239.     (void)printf("Reserved %d x %d image data buffer", width, height);
  240.     if( did_alloc > 1 )
  241.       (void)printf("s.\n");
  242.     else
  243.       (void)printf(".\n");
  244.   }
  245.   return( 1 );
  246. }
  247.