home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / compstol / cmpsttl1.lha / CompositeTool / v1.1.dist / HDF / dfcomp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-08  |  14.9 KB  |  506 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.00
  4. *                December, 1989
  5. *
  6. * NCSA HDF Version 3.00 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. /*-----------------------------------------------------------------------------
  23.  * File:    dfcomp.c
  24.  * Purpose: File compression
  25.  * Invokes: df.c dfimcomp.c df.h
  26.  * Contents: 
  27.  *  DFputcomp: compress image and write it to HDF file
  28.  *  DFgetcomp: read compressed image from HDF file and decompress it
  29.  *  DFCrle: compress string using run length encoding
  30.  *  DFCunrle: decompress string using run length encoding
  31.  * Remarks: DFgetcomp and DFputcomp constitute a general compression interface
  32.  *---------------------------------------------------------------------------*/
  33.  
  34. #include "df.h"
  35.  
  36. #ifndef VMS
  37. extern void DFCimcomp(), DFCunimcomp();
  38. #else /*VMS*/
  39. extern void _DFCimcomp(), _DFCunimcomp();
  40. #endif
  41.  
  42. /*-----------------------------------------------------------------------------
  43.  * Name:    DFputcomp
  44.  * Purpose: Compress and write images to HDF file
  45.  * Inputs:  dfile: pointer to HDF file
  46.  *          tag, ref: tag, ref of compressed image for writing out
  47.  *          image: image to be compressed
  48.  *          xdim, ydim: dimensions of image
  49.  *          palette: palette associated with image
  50.  *          newpal: modified palette, produced if compression scheme is IMCOMP
  51.  *          scheme: compression scheme to be used
  52.  * Returns: 0 on success, -1 on failure with DFerror set
  53.  * Users:   HDF programmers, DF8putrig, other routines
  54.  * Invokes: DFCrle, DFCimcomp, DFaccess, DFwrite, DFIcheck
  55.  * Remarks: IMCOMP modifies the palette associated with the image
  56.  *          Hence the palette and newpal arguments
  57.  *          This is a general compression interface - to be used anytime image
  58.  *          compression is needed in HDF
  59.  *          Note that rseq does its own compression, because that is part of
  60.  *          the interactive color raster protocol
  61.  *          The space needed for compression and decompression can be allocated
  62.  *          statically or dynamically, depending on the DF_DYNAMIC flag, and
  63.  *          for entire image or part of it (reused) depending on availability
  64.  *          Accordingly, writing out is whole image, or row by row
  65.  *          Note that compression is always row by row for RLE.
  66.  *---------------------------------------------------------------------------*/
  67.  
  68.  
  69. int DFputcomp(dfile, tag, ref, image, xdim, ydim, palette, newpal, scheme)
  70. DF *dfile;
  71. uint16 tag, ref;
  72. char *image;
  73. int32 xdim, ydim;
  74. char *palette, *newpal;
  75. int16 scheme;
  76. {
  77.     char *buffer;        /* buffer to hold compressed image */
  78.     char *in;            /* pointer to input for compression */
  79.     char *out;            /* pointer to space for compressed output */
  80.     int32 cisize;        /* maximum size of compressed image */
  81.     int32 crowsize;        /* maximum size of compressed row */
  82.     int32 buftype;        /* buftype = 1: buffer enough for whole image*/
  83.                 /* buftype = 2: buffer holds 1 row */
  84.     int32 n;            /* number of compressed bytes produced */
  85.     int32 total;        /* total compressed bytes produced so far */
  86.     int i, ret=0;
  87.  
  88.     if (DFIcheck(dfile)<0) return(-1);
  89.     if (!tag) {
  90.         DFerror = DFE_BADTAG;
  91.         return(-1);
  92.     }
  93.     if (!ref) {
  94.         DFerror = DFE_BADREF;
  95.         return(-1);
  96.     }
  97.     if ((xdim<=0) || (ydim<=0)) {
  98.         DFerror = DFE_BADDIM;
  99.         return(-1);
  100.     }
  101.     if (!image) {
  102.         DFerror = DFE_BADPTR;
  103.         return(-1);
  104.     }
  105.  
  106.     if (DFaccess(dfile, tag, ref, "w")<0) return(-1); /* setup to write CI */
  107.  
  108.     switch (scheme) {
  109.       case DFTAG_RLE:
  110.     cisize = xdim*(ydim*121/120+1);    /* 120 chars can compress to 121! */
  111.     crowsize = xdim*121/120 + 128;
  112.  
  113.     /* allocate buffer for compression */
  114. #ifdef DF_DYNAMIC        /* large mallocs OK */
  115.     buffer = (char *) DFIgetspace((unsigned)cisize);
  116.     if (!buffer) {
  117.         buffer = (char *) DFIgetspace((unsigned)crowsize);
  118.         if (!buffer) {
  119.         DFerror = DFE_NOSPACE;
  120.         return(-1);
  121.         }
  122.         buftype = 2;    /* compress and write out row by row */
  123.     }
  124.     else buftype = 1;       /* can hold whole image, then write */
  125.  
  126. #else /*DF_DYNAMIC                    use static buffers */
  127.     buffer = DFtbuf;
  128.     if (DF_TBUFSZ>=cisize) buftype = 1;
  129.     else if (DF_TBUFSZ>crowsize) buftype = 2;
  130.     else {
  131.         DFerror = DFE_NOSPACE;
  132.         return(-1);
  133.     }
  134. #endif /*DF_DYNAMIC*/
  135.  
  136.     in = image;
  137.     out = buffer;
  138.     n = total = 0;        /* no bytes compressed so far */
  139.  
  140.     /* compress row by row */
  141.     for (i=0; i<ydim; i++) {
  142.         n = DFCrle(in, out, xdim); /* compress row */
  143.         in += xdim;        /* move input pointer */
  144.         total += n;        /* keep running total */
  145.         if (buftype==1)    /* can hold whole image */
  146.         out = &buffer[total]; /* move out buffer pointer */
  147.         else {        /* buffer too small, */
  148.                 /* write out what was produced */
  149.         if (DFwrite(dfile, buffer, n)<0) {
  150.             ret = -1;    /* flag value */
  151.             break;
  152.         }
  153.         out = buffer;    /* reset output pointer */
  154.         }
  155.     }
  156.  
  157.     if (buftype==1)        /* write out entire image */
  158.                 ret = DFwrite(dfile, buffer, total);
  159.     break;
  160.  
  161.       case DFTAG_IMC:
  162.         if (!palette || !newpal) { /* need palette and newpal */
  163.             DFerror = DFE_BADPTR;
  164.             return(-1);
  165.         }
  166.         cisize = xdim*ydim/4;    /* IMCOMP always cuts to 1/4 */
  167.  
  168. #ifdef DF_DYNAMIC
  169.         buffer = (char *) DFIgetspace((unsigned)cisize);
  170.         if (!buffer) {
  171.             DFerror = DFE_NOSPACE;
  172.             return(-1);
  173.         }
  174. #else /*DF_DYNAMIC*/
  175.         if (DF_TBUFSZ<cisize) {
  176.             DFerror = DFE_NOSPACE;
  177.             return(-1);
  178.         }
  179.         buffer = DFtbuf;
  180. #endif /*DF_DYNAMIC*/
  181.  
  182.         DFCimcomp(xdim, ydim, image, buffer, palette, newpal, 0);
  183.         ret = DFwrite(dfile, buffer, cisize);
  184.         break;
  185.  
  186.     default:            /* unknown compression scheme */
  187.         DFerror = DFE_BADSCHEME;
  188.         return(-1);
  189.         break;
  190.     }
  191. #ifdef DF_DYNAMIC
  192.     DFIfreespace((char*)buffer);
  193. #endif /*DF_DYNAMIC*/
  194.     return(ret);
  195. }
  196.  
  197. /*-----------------------------------------------------------------------------
  198.  * Name:    DFgetcomp
  199.  * Purpose: Read compressed image and decompress it
  200.  * Inputs:  dfile: HDF file pointer
  201.  *          tag, ref: id of image to be decompressed
  202.  *          image: space to return decompressed image in
  203.  *          xdim, ydim: dimensions of decompressed image
  204.  *          scheme: compression scheme used
  205.  * Returns: 0 on success, -1 on failure with DFerror set
  206.  * Users:   HDF programmers, DF8getrig, other routines
  207.  * Invokes: DFIcheck, DFIfind, DFaccess, DFread, DFCunrle, DFCunimcomp
  208.  * Remarks: Will use dynamic/static memory allocation for buffer
  209.  *          will read in image in parts if memory insufficient
  210.  *          Decompression of rle is not necessarily row by row
  211.  *          Other encodings can also be decoded with this
  212.  *---------------------------------------------------------------------------*/
  213.  
  214. int DFgetcomp(dfile, tag, ref, image, xdim, ydim, scheme)
  215. DF *dfile;
  216. uint16 tag, ref;
  217. char *image;
  218. int32 xdim, ydim;
  219. uint16 scheme;
  220. {
  221.     char *buffer, *in, *out;
  222.     int32 cisize, crowsize, buflen, bufleft; /* bufleft: bytes left in buffer*/
  223.     DFdle *dlep;
  224.     int cdd, i, n, totalread;
  225.  
  226.     if (DFIcheck(dfile)<0) return(-1);
  227.     if (!tag) {
  228.         DFerror = DFE_BADTAG;
  229.         return(-1);
  230.     }
  231.     if (!ref) {
  232.         DFerror = DFE_BADREF;
  233.         return(-1);
  234.     }
  235.     if (!image) {
  236.         DFerror = DFE_BADPTR;
  237.         return(-1);
  238.     }
  239.     if ((xdim<=0) || (ydim<=0)) {
  240.         DFerror = DFE_BADDIM;
  241.         return(-1);
  242.     }
  243.  
  244.     if (DFIfind(dfile, tag, ref, 1, 0, 0, &dlep, &cdd)<0) {
  245.         DFerror = DFE_NOMATCH;
  246.         return(-1);
  247.     }
  248.     cisize = dlep->dd[cdd].length;
  249.  
  250.     if (DFaccess(dfile, tag, ref, "r")<0) return(-1);
  251.     switch (scheme) {
  252.       case DFTAG_RLE:
  253.     crowsize = xdim*121/120 + 128; /* max size of a row */
  254.  
  255. #ifdef DF_DYNAMIC
  256.     buffer = (char *) DFIgetspace((unsigned)cisize);
  257.     if (!buffer) {
  258.         buffer = (char *) DFIgetspace((unsigned)crowsize);
  259.         if (!buffer) {
  260.         DFerror = DFE_NOSPACE;
  261.         return(-1);
  262.         }
  263.         buflen = crowsize;
  264.     }
  265.     else buflen = cisize;
  266. #else /*DF_DYNAMIC*/
  267.     if (DF_TBUFSZ<crowsize) {
  268.         DFerror = DFE_NOSPACE;
  269.         return(-1);
  270.     }
  271.     buffer = DFtbuf;    /* static compression buffer */
  272.     buflen = DF_TBUFSZ;
  273. #endif /*DF_DYNAMIC*/
  274.  
  275.     in = buffer;
  276.     out = image;
  277.     if ((n=DFread(dfile, in, buflen))<0) {
  278. #ifdef DF_DYNAMIC
  279.         DFIfreespace((char*)buffer);
  280. #endif /*DF_DYNAMIC*/
  281.         return(-1);
  282.     }
  283.     totalread = n;
  284.     bufleft = n;
  285.     for (i=0; i<ydim; i++) {
  286.         n = DFCunrle(in, out, xdim, !i); /* no of bytes used up */
  287.         /* last arg=TRUE if i=0 - resets decompress */
  288.         in += n;
  289.         out += xdim;
  290.         bufleft -= n;
  291.         /* check if more bytes may be needed for next read */
  292.         if ((bufleft<crowsize) && (totalread<cisize)) {
  293.         DFmovmem(in, buffer, (int)bufleft);
  294.         in = buffer;
  295.         if ((n=DFread(dfile,&in[bufleft],buflen-bufleft))<0) {
  296. #ifdef DF_DYNAMIC
  297.             DFIfreespace((char*)buffer);
  298. #endif /*DF_DYNAMIC   */
  299.             return(-1);
  300.         }
  301.         totalread += n;
  302.         bufleft += n;
  303.         }
  304.     }
  305.     break;
  306.  
  307.       case DFTAG_IMC:
  308.     crowsize = xdim;    /* size of compressed row */
  309.  
  310. #ifdef DF_DYNAMIC
  311.     buffer = (char *) DFIgetspace((unsigned)cisize);
  312.     if (!buffer) {
  313.         buffer = (char *) DFIgetspace((unsigned)crowsize);
  314.         if (!buffer) {
  315.         DFerror = DFE_NOSPACE;
  316.         return(-1);
  317.         }
  318.         buflen = crowsize;
  319.     }
  320.     else buflen = cisize;
  321. #else /*DF_DYNAMIC*/
  322.     buffer = DFtbuf;    /* static compression buffer */
  323.     if (DF_TBUFSZ<crowsize) {
  324.         DFerror = DFE_NOSPACE;
  325.         return(-1);
  326.     }
  327.     buflen = DF_TBUFSZ;
  328. #endif /*DF_DYNAMIC*/
  329.     if (buflen>=cisize) {
  330.         if (DFread(dfile, buffer, cisize)<cisize) {
  331. #ifdef DF_DYNAMIC
  332.         DFIfreespace((char*)buffer);
  333. #endif /*DF_DYNAMIC*/
  334.         return(-1);
  335.         }
  336.         DFCunimcomp(xdim, ydim, buffer, image);
  337.         break;        /* go to end of switch */
  338.     }
  339.  
  340.     in = buffer;        /* if can only read piecemeal */
  341.     out = image;
  342.     if ((n=DFread(dfile, in, buflen))<0) {
  343. #ifdef DF_DYNAMIC
  344.         DFIfreespace((char*)buffer);
  345. #endif /*DF_DYNAMIC*/
  346.         return(-1);
  347.     }
  348.     totalread = n;
  349.     bufleft = n;
  350.     for (i=0; i<ydim; i+=4) {
  351.         DFCunimcomp(xdim, (int32)4, in, out);
  352.         in += xdim;
  353.         out += 4*xdim;
  354.         bufleft -= xdim;
  355.         if ((bufleft<crowsize) && (totalread<cisize)) {
  356.         DFmovmem(in, buffer, (int)bufleft);
  357.         in = buffer;
  358.         if ((n=DFread(dfile,&in[bufleft],buflen-bufleft))<0) {
  359. #ifdef DF_DYNAMIC
  360.             DFIfreespace((char*)buffer);
  361. #endif /*DF_DYNAMIC*/
  362.             return(-1);
  363.         }
  364.         totalread += n;
  365.         bufleft += n;
  366.         }
  367.     }
  368.     break;
  369.  
  370.       default:            /* unknown scheme */
  371.     DFerror = DFE_BADSCHEME;
  372.     return(-1);
  373.     break;
  374.     }
  375. #ifdef DF_DYNAMIC
  376.     DFIfreespace((char*)buffer);
  377. #endif /*DF_DYNAMIC*/
  378.     return(0);
  379. }
  380.  
  381. /*-----------------------------------------------------------------------------
  382.  * Name:    DFCrle
  383.  * Purpose: compress a string of bytes
  384.  * Inputs:  buf: buffer containing data to be compressed
  385.  *          bufto: space for compressed data - assumed big enough
  386.  *          len: number of bytes to compress
  387.  * Returns: number of compressed bytes on success, -1 on failure
  388.  * Users:   HDF programmers, DFputcomp, other routines
  389.  * Invokes: none
  390.  * Remarks: Written for efficiency
  391.  *---------------------------------------------------------------------------*/
  392.  
  393. int DFCrle(buf,bufto,len)
  394. int32 len;
  395. char *buf,*bufto;
  396. {
  397.     register char *p,*q,*cfoll,*clead;
  398.     char *begp;
  399.     int32 i;
  400.  
  401.     p = buf;
  402.     cfoll = bufto;        /* place to copy to */
  403.     clead = cfoll + 1;
  404.     
  405.     begp = p;
  406.     while (len > 0) {           /* encode stuff until gone */
  407.  
  408.         q = p + 1;
  409.         i = len-1;
  410.         while (i && i+120 > len && *p == *q) {
  411.             q++;
  412.             i--;
  413.         }
  414.         
  415.         if (q > p + 2) {        /* three in a row */
  416.             if (p > begp) {
  417.                 *cfoll = p - begp;
  418.                 cfoll = clead;
  419.             }
  420.             *cfoll++ = 128 | (q-p); /* len of seq */
  421.             *cfoll++ = *p;      /* char of seq */
  422.             len -= q-p;         /* subtract len of seq */
  423.             p = q;
  424.             clead = cfoll+1;
  425.             begp = p;
  426.         }
  427.         else {
  428.             *clead++ = *p++;    /* copy one char */
  429.             len--;
  430.             if (p > begp + 120) {
  431.                 *cfoll = p - begp;
  432.                 cfoll = clead++;
  433.                 begp = p;
  434.             }
  435.         }
  436.         
  437.     }
  438. /*
  439.  *  fill in last bytecount
  440.  */
  441.     if (p > begp) 
  442.         *cfoll = (p - begp);
  443.     else
  444.         clead--;                    /* don't need count position */
  445.     
  446.     return((int)(clead - bufto));   /* how many stored as encoded */
  447. }
  448.  
  449. /*-----------------------------------------------------------------------------
  450.  * Name:    DFCunrle
  451.  * Purpose: decompress run length encoding
  452.  * Inputs:  buf: buffer containing compressed data
  453.  *          bufto: space for returning decompressed data
  454.  *          outlen: number of *decompressed* bytes desired.
  455.  *          resetsave: don't use any stored state info - used for fresh image
  456.  * Returns: number of compressed bytes used up on success, -1 on failure
  457.  * Users:   HDF programmers, DFgetcomp, other routines
  458.  * Invokes: none
  459.  * Remarks: has been modified so it will decompress even non-rowwise compression
  460.  *          Hence the static storage stuff
  461.  *---------------------------------------------------------------------------*/
  462.  
  463. int DFCunrle(buf,bufto,outlen, resetsave)
  464. int32 outlen;
  465. char *buf,*bufto;
  466. int resetsave;
  467. {
  468.     register int cnt;
  469.     register char *p,*q;
  470.     char *endp;
  471.     static char save[255], *savestart=NULL, *saveend=NULL;
  472.     /* save has a list of decompressed bytes not returned in
  473.        previous call.  savestart and saveend specify the position
  474.        at which this list starts and ends in the array save */
  475.     
  476.     p = buf;
  477.     endp = bufto + outlen;
  478.     q = bufto;
  479.     if (resetsave) savestart = saveend = save; /* forget saved state */
  480.     while ((saveend>savestart) && (q<endp)) /* copy saved stuff */
  481.         *q++ = *savestart++;
  482.     if (savestart>=saveend) savestart = saveend = save;    /* all copied */
  483.     while (q < endp) {
  484.         cnt = *p++;        /* count field */
  485.         if (!(cnt & 128)) {    /* is set of uniques */
  486.             while (cnt--) {
  487.                 if (q<endp)
  488.                     *q++ = *p++; /* copy unmodified */
  489.                 else
  490.                     *saveend++ = *p++;
  491.             }
  492.         }
  493.         else {
  494.             cnt &= 127;        /* strip high bit */
  495.             while (cnt--) {
  496.                 if (q<endp)
  497.                     *q++ = *p;  /* copy unmodified */
  498.                 else
  499.                     *saveend++ = *p;
  500.             }
  501.             p++;                /* skip that character */
  502.         }
  503.     }
  504.     return((int)(p-buf));
  505. }
  506.