home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / HDF / dfgr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-20  |  40.1 KB  |  1,162 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10
  4. *                July 1, 1990
  5. *
  6. * NCSA HDF Version 3.10 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. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 3.3 $";
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/dfgr.c,v 3.3 90/06/19 11:19:42 clow beta $
  27.  
  28. $Log:    dfgr.c,v $
  29.  * Revision 3.3  90/06/19  11:19:42  clow
  30.  * Implemented DFGRreadref to set next rig to read in.
  31.  * 
  32.  * Revision 3.2  90/05/11  12:55:03  clow
  33.  * added DFGRIrestart() for restarting files for general raster
  34.  * 
  35.  * Revision 3.1  90/05/04  16:26:50  clow
  36.  * changed argument list of DFGRIsetdims
  37.  * added DFGRIsetil
  38.  * 
  39.  * Revision 3.0  90/02/02  20:31:30  clow
  40.  * *** empty log message ***
  41.  * 
  42. */
  43.  
  44. /*-----------------------------------------------------------------------------
  45.  * File:    dfgr.c
  46.  * Purpose: read and write general raster images
  47.  * Invokes: df.c, dfkit.c, dfcomp.c, dfgroup.c, dfgr.h
  48.  * Contents: 
  49.  *  DFGRgetlutdims: get dimensions of lookup table
  50.  *  DFGRreqlutil: use this interlace when returning lookup table
  51.  *  DFGRgetlut: read in lookup table
  52.  *  DFGRgetimdims: get dimensions of image
  53.  *  DFGRreqimil: use this interlace when returning image
  54.  *  DFGRgetimage: read in image
  55.  *  DFGRsetcomp: specify compression scheme to be used
  56.  *  DFGRsetlutdims: set dimensions of lookup table
  57.  *  DFGRsetlut: set lookup table to write out with subsequent images
  58.  *  DFGRaddlut: write out lookup table
  59.  *  DFGRsetimdims: set dimensions of image
  60.  *  DFGRaddimage: write out image
  61.  *
  62.  *  DFGRgetrig: read in raster image group
  63.  *  DFGRaddrig: write out raster image group
  64.  *
  65.  *  DFGRIopen: open/reopen file
  66.  *  DFGRIriginfo: obtain info about next RIG
  67.  *  DFGRIgetdims: get dimensions of lut/iamge
  68.  *  DFGRIreqil: get lut/image with this interlace
  69.  *  DFGRIgetimlut: get image/lut
  70.  *  DFGRIsetdims: set image/lut dimensions
  71.  *  DFGRIaddimlut: write out image/lut
  72.  * Remarks: A RIG specifies attributes associated with an image - lookup table, 
  73.  *          dimension, compression, color compensation etc.
  74.  *---------------------------------------------------------------------------*/
  75.  
  76. #include "dfgr.h"
  77.  
  78. static char Grlastfile[DF_MAXFNLEN];
  79. static DFGRrig Grread;        /* information about RIG being read */
  80. static DFGRrig Grwrite;         /* information about RIG being written */
  81. static int Grnewdata = 0;    /* does Grread contain fresh data? */
  82. static int Grcompr = 0;         /* compression scheme to use */
  83. char *Grlutdata=NULL;        /* points to lut, if in memory */
  84. static uint16 Grrefset=0;    /* Ref of image to get next */
  85. static uint16 Grlastref = 0;    /* Last ref read/written */
  86. static int Grreqil[2]= {0, 0}; /* requested lut/image il */
  87. static struct {            /* track refs of set vals written before */
  88.     int lut;            /* -1: no vals set */
  89.     int16 dims[2];        /* 0: vals set, not written */
  90.     int nt;            /* non-zero: ref of val in file */
  91. } Ref = {-1, {-1, -1}, -1 };
  92.  
  93. static DFGRrig Grzrig = {    /* empty RIG for initialization */
  94.     { {0, 0}, {0, 0}, {0, 0}, },
  95.     { {0, 0, 0, 0, 0, 0, 0, 0},
  96.       {0, 0, 0, 0, 0, 0, 0, 0},
  97.       {0, 0, 0, 0, 0, 0, 0, 0}, },
  98.     0, 0, 0.0, 0.0, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0},
  99.     {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, NULL
  100. };
  101.  
  102. #ifndef VMS
  103. DF *DFGRIopen();
  104. #else /*VMS*/
  105. DF *_DFGRIopen();
  106. #endif
  107.  
  108. #define LUT     0
  109. #define IMAGE   1
  110.  
  111. /*-----------------------------------------------------------------------------
  112.  * Name:    DFGRgetlutdims
  113.  * Purpose: get dimensions of lut from next RIG
  114.  * Inputs:  filename: name of HDF file
  115.  *          pxdim, pydim: pointer to locations for returning x,y dimensions
  116.  *          pncomps: location for returning no of components
  117.  *          pil: location for returning interlace of lut in file
  118.  * Returns: 0 on success, -1 on failure with DFerror set
  119.  *          *pxdim, *pydim, *pncomps, *pil set on success
  120.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  121.  * Invokes: DFGRIgetdims
  122.  * Remarks: none
  123.  *---------------------------------------------------------------------------*/
  124.  
  125. int DFGRgetlutdims(filename, pxdim, pydim, pncomps, pil)
  126. char *filename;
  127. int32 *pxdim, *pydim;
  128. int *pncomps, *pil;
  129. {
  130.  
  131.     return(DFGRIgetdims(filename, pxdim, pydim, pncomps, pil, LUT));
  132. }
  133.  
  134.  
  135. /*-----------------------------------------------------------------------------
  136.  * Name:    DFGRreqlutil
  137.  * Purpose: get next lut with specified interlace
  138.  * Inputs:  il: interlace to get next lut with
  139.  * Returns: 0 on success, -1 on failure with DFerror set
  140.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  141.  * Invokes: DFGRIreqil
  142.  * Remarks: none
  143.  *---------------------------------------------------------------------------*/
  144.  
  145. int DFGRreqlutil(il)
  146. int il;
  147. {
  148.     return(DFGRIreqil(il, LUT));
  149. }
  150.  
  151.  
  152. /*-----------------------------------------------------------------------------
  153.  * Name:    DFGRgetlut
  154.  * Purpose: get lut from next RIG
  155.  * Inputs:  filename: name of HDF file
  156.  *          lut: pointer to space to return lookup table
  157.  *          xdim, ydim: dimensions of space to return lut
  158.  * Returns: 0 on success, -1 on failure with DFerror set
  159.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  160.  * Invokes: DFGRIgetimlut
  161.  * Remarks: space is assumed to be xdim * ydim * ncomps bytes
  162.  *---------------------------------------------------------------------------*/
  163.  
  164. int DFGRgetlut(filename, lut, xdim, ydim)
  165. char *filename;
  166. char *lut;
  167. int32 xdim, ydim;
  168. {
  169.  
  170.     /* 0 == C */
  171.     return(DFGRIgetimlut(filename, lut, xdim, ydim, LUT, 0));
  172. }
  173.  
  174. /*-----------------------------------------------------------------------------
  175.  * Name:    DFGRgetimdims
  176.  * Purpose: get dimensions of next image RIG
  177.  * Inputs:  filename: name of HDF file
  178.  *          pxdim, pydim: pointer to locations for returning x,y dimensions
  179.  *          pncomps: location for returning no of components
  180.  *          pil: location for returning interlace of image in file
  181.  * Returns: 0 on success, -1 on failure with DFerror set
  182.  *          *pxdim, *pydim, *pncomps, *pil set on success
  183.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  184.  * Invokes: DFGRIgetdims
  185.  * Remarks: none
  186.  *---------------------------------------------------------------------------*/
  187.  
  188. int DFGRgetimdims(filename, pxdim, pydim, pncomps, pil)
  189. char *filename;
  190. int32 *pxdim, *pydim;
  191. int *pncomps, *pil;
  192. {
  193.     return(DFGRIgetdims(filename, pxdim, pydim, pncomps, pil, IMAGE));
  194. }
  195.  
  196. /*-----------------------------------------------------------------------------
  197.  * Name:    DFGRreqimil
  198.  * Purpose: get next image with specified interlace
  199.  * Inputs:  il: interlace to get next image with
  200.  * Returns: 0 on success, -1 on failure with DFerror set
  201.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  202.  * Invokes: DFGRIreqil
  203.  * Remarks: none
  204.  *---------------------------------------------------------------------------*/
  205.  
  206. int DFGRreqimil(il)
  207. int il;
  208. {
  209.     return(DFGRIreqil(il, IMAGE));
  210. }
  211.  
  212. /*-----------------------------------------------------------------------------
  213.  * Name:    DFGRgetimage
  214.  * Purpose: get image from next RIG
  215.  * Inputs:  filename: name of HDF file
  216.  *          image: pointer to space to return image
  217.  *          xdim, ydim: dimensions of space to return lut
  218.  * Returns: 0 on success, -1 on failure with DFerror set
  219.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  220.  * Invokes: DFGRIgetimlut
  221.  * Remarks: space is assumed to be xdim * ydim * ncomps bytes
  222.  *---------------------------------------------------------------------------*/
  223.  
  224. int DFGRgetimage(filename, image, xdim, ydim)
  225. char *filename;
  226. char *image;
  227. int32 xdim, ydim;
  228. {
  229.     /* 0 == C */
  230.     return(DFGRIgetimlut(filename, image, xdim, ydim, IMAGE, 0));
  231. }
  232.  
  233. /*-----------------------------------------------------------------------------
  234.  * Name:    DFGRsetcompress
  235.  * Purpose: set compression scheme to use
  236.  * Inputs:  scheme: compression scheme
  237.  * Returns: 0 on success, -1 on failure with DFerror set
  238.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  239.  * Invokes: none
  240.  * Remarks: none
  241.  *---------------------------------------------------------------------------*/
  242.  
  243. int DFGRsetcompress(scheme)
  244. int scheme;
  245. {
  246.     Grcompr = scheme;
  247.     return(0);
  248. }
  249.  
  250. /*-----------------------------------------------------------------------------
  251.  * Name:    DFGRsetlutdims
  252.  * Purpose: set dimensions of lut to write next
  253.  * Inputs:  xdim, ydim: dimensions of lut
  254.  *          ncomps: no of components
  255.  *          il: interlace of lut
  256.  * Returns: 0 on success, -1 on failure with DFerror set
  257.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  258.  * Invokes: DFGRIsetdims
  259.  * Remarks: none
  260.  *---------------------------------------------------------------------------*/
  261.  
  262. int DFGRsetlutdims(xdim, ydim, ncomps, il)
  263. int32 xdim, ydim;
  264. int ncomps, il;
  265. {
  266.     if (DFGRIsetil(il, LUT) < 0) return -1;
  267.     return(DFGRIsetdims(xdim, ydim, ncomps, LUT));
  268. }
  269.  
  270.  
  271. /*-----------------------------------------------------------------------------
  272.  * Name:    DFGRsetlut
  273.  * Purpose: set lut for subsequent RIGs
  274.  * Inputs:  lut: lookup table to write
  275.  *          xdim, ydim: dimensions of array lut
  276.  * Returns: 0 on success, -1 on failure with DFerror set
  277.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  278.  * Invokes: DFGRIaddimlut
  279.  * Remarks: array lut is assumed to be xdim * ydim * ncomps bytes
  280.  *---------------------------------------------------------------------------*/
  281.  
  282. int DFGRsetlut(lut, xdim, ydim)
  283. char *lut;
  284. int32 xdim, ydim;
  285. {
  286.     /* 0 == C */
  287.     return(DFGRIaddimlut((char*)NULL, lut, xdim, ydim, LUT, 0));
  288. }
  289.  
  290.  
  291. /*-----------------------------------------------------------------------------
  292.  * Name:    DFGRaddlut
  293.  * Purpose: write lut to file, associate it with subsequent RIGs
  294.  * Inputs:  filename: name of HDF file
  295.  *          lut: lookup table to write
  296.  *          xdim, ydim: dimensions of array lut
  297.  * Returns: 0 on success, -1 on failure with DFerror set
  298.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  299.  * Invokes: DFGRIaddimlut
  300.  * Remarks: array lut is assumed to be xdim * ydim * ncomps bytes
  301.  *---------------------------------------------------------------------------*/
  302.  
  303. int DFGRaddlut(filename, lut, xdim, ydim)
  304. char *filename;
  305. char *lut;
  306. int32 xdim, ydim;
  307. {
  308.     /* 0 == C */
  309.     return(DFGRIaddimlut(filename, lut, xdim, ydim, LUT, 0));
  310. }
  311.  
  312.  
  313. /*-----------------------------------------------------------------------------
  314.  * Name:    DFGRsetimdims
  315.  * Purpose: set dimensions of image to write next
  316.  * Inputs:  xdim, ydim: dimensions of image
  317.  *          ncomps: no of components
  318.  *          il: interlace of image
  319.  * Returns: 0 on success, -1 on failure with DFerror set
  320.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  321.  * Invokes: DFGRIsetdims
  322.  * Remarks: none
  323.  *---------------------------------------------------------------------------*/
  324.  
  325. int DFGRsetimdims(xdim, ydim, ncomps, il)
  326. int32 xdim, ydim;
  327. int ncomps, il;
  328. {
  329.     if (DFGRIsetil(il, IMAGE) < 0) return -1;
  330.     return(DFGRIsetdims(xdim, ydim, ncomps, IMAGE));
  331. }
  332.  
  333. /*-----------------------------------------------------------------------------
  334.  * Name:    DFGRaddimage
  335.  * Purpose: Write out image
  336.  * Inputs:  filename: name of HDF file
  337.  *          image: image to write
  338.  *          xdim, ydim: dimensions of array image
  339.  * Returns: 0 on success, -1 on failure with DFerror set
  340.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  341.  * Invokes: DFGRIaddimlut
  342.  * Remarks: array image is assumed to be xdim * ydim * ncomps bytes
  343.  *---------------------------------------------------------------------------*/
  344.  
  345. int DFGRaddimage(filename, image, xdim, ydim)
  346. char *filename;
  347. char *image;
  348. int32 xdim, ydim;
  349. {
  350.     /* 0 == C */
  351.     return(DFGRIaddimlut(filename, image, xdim, ydim, IMAGE, 0));
  352. }
  353.  
  354.  
  355. /*-----------------------------------------------------------------------------
  356.  * Name:    DFGRreadref
  357.  * Purpose: Set ref of rig to get next
  358.  * Inputs:  filename: file to which this applies
  359.  *          ref: reference number of next get
  360.  * Returns: 0 on success, -1 on failure
  361.  * Users:   HDF programmers, other routines and utilities
  362.  * Invokes: DFGRIopen, DFIfind, DFclose
  363.  * Remarks: checks if rig with this ref exists
  364.  *---------------------------------------------------------------------------*/
  365.  
  366. int DFGRreadref(filename, ref)
  367. char *filename;
  368. uint16 ref;
  369. {
  370.     DF *dfile;
  371.     int cdd;
  372.     DFdle *dlep;
  373.  
  374.     DFerror = DFE_NOERROR;
  375.  
  376.     dfile = DFGRIopen(filename, DFACC_READ);
  377.     if (dfile==NULL) return(-1);
  378.  
  379.     if (DFIfind(dfile, DFTAG_RIG, ref, 1, 0, 0, &dlep, &cdd)<0)
  380.         return(DFIerr(dfile));
  381.  
  382.     Grrefset = ref;
  383.     return(DFclose(dfile));
  384. }
  385.  
  386.  
  387. /*****************************************************************************/
  388. /* This is the next lower layer - procedures to read in and write out a RIG. */
  389. /*****************************************************************************/
  390.  
  391. /*-----------------------------------------------------------------------------
  392.  * Name:    DFGRgetrig
  393.  * Purpose: Read a RIG into memory
  394.  * Inputs:  dfile: pointer to HDF file containing RIG
  395.  *          ref: reference number of RIG to get
  396.  *          rig: struct in which to place info obtained
  397.  * Returns: 0 on success, -1 on failure with DFerror set
  398.  *          contents of RIG in the struct rig
  399.  * Users:   HDF programmers, utilities, DFGRIgetdims,DFGRIgetimlut,
  400.  *          other routines
  401.  * Invokes: DFdiget, DFdinext, DFIcheck, DFgetelement
  402.  * Remarks: incomplete - does not support DFTAG_MA etc.
  403.  *---------------------------------------------------------------------------*/
  404.  
  405. int DFGRgetrig(dfile, ref, rig)
  406. DF *dfile;
  407. uint16 ref;
  408. DFGRrig *rig;
  409. {
  410.     DFdi elmt;
  411.     char ntstring[4];
  412.     int type;
  413.  
  414.     DFerror = DFE_NOERROR;
  415.  
  416.     if (DFIcheck(dfile))
  417.         return( -1);
  418.     if (!ref) {
  419.         DFerror = DFE_BADREF;
  420.         return(-1);
  421.     }
  422.  
  423.     if (DFdiread(dfile, DFTAG_RIG, ref)<0) /* read RIG into memory */
  424.         return(-1);
  425.  
  426.     *rig = Grzrig;        /* fill rig with zeroes */
  427.     while (!DFdiget(&elmt)) {    /* get next tag/ref from RIG */
  428.         switch (elmt.tag) {    /* process tag/ref */
  429.             case DFTAG_CI:
  430.             case DFTAG_RI:
  431.             case DFTAG_LUT:
  432.                 type = (elmt.tag==DFTAG_LUT) ? LUT : IMAGE;
  433.                 rig->data[type].tag = elmt.tag;
  434.                 rig->data[type].ref = elmt.ref;
  435.                 break;
  436.             case DFTAG_ID:          /* read description info */
  437.             case DFTAG_LD:
  438.                 type = (elmt.tag==DFTAG_LD) ? LUT : IMAGE;
  439. #ifdef DF_STRUCTOK
  440.                 if (DFgetelement(dfile, elmt.tag, elmt.ref,
  441.                  &rig->datadesc[type])<0)
  442.             return(-1);
  443. #else /*DF_STRUCTOK*/
  444.         if (DFgetelement(dfile, elmt.tag, elmt.ref, DFtbuf)>0) {
  445.                     register char *p;
  446.                     p = DFtbuf;
  447.                     INT32READ(p, rig->datadesc[type].xdim);
  448.                     INT32READ(p, rig->datadesc[type].ydim);
  449.                     UINT16READ(p, rig->datadesc[type].nt.tag);
  450.                     UINT16READ(p, rig->datadesc[type].nt.ref);
  451.                     INT16READ(p, rig->datadesc[type].ncomponents);
  452.                     INT16READ(p, rig->datadesc[type].interlace);
  453.                     UINT16READ(p, rig->datadesc[type].compr.tag);
  454.                     UINT16READ(p, rig->datadesc[type].compr.ref);
  455.                 } else return(-1);
  456. #endif /*DF_STRUCTOK*/
  457.                 if (rig->datadesc[type].nt.tag==0) break; /* old RIGs */
  458.  
  459.         /* read NT */
  460.                 if (DFgetelement(dfile, rig->datadesc[type].nt.tag,
  461.                  rig->datadesc[type].nt.ref, ntstring)<0)
  462.                     return(-1);
  463.                 if ((ntstring[2]!=8) || (ntstring[1]!=DFNT_UCHAR)) {
  464.                     DFerror = DFE_BADCALL;
  465.                     return(-1);
  466.                 }
  467.                 break;
  468.             default:        /* ignore unknown tags */
  469.                 break;
  470.         }
  471.     }
  472.     return(0);
  473. }
  474.  
  475. /*-----------------------------------------------------------------------------
  476.  * Name:    DFGRaddrig
  477.  * Purpose: Write RIG struct out to HDF file
  478.  * Inputs:  dfile: HDF file pointer
  479.  *          ref: ref to write RIG with
  480.  *          rig: struct containing RIG info to write
  481.  * Returns: 0 on success, -1 on failure with DFerror set
  482.  * Users:   HDF programmers, utilities, DFGRIaddimlut, other routines
  483.  * Invokes: DFIcheck, DFdistart, DFdiadd, DFdiend, DFputelement
  484.  * Remarks: none
  485.  *---------------------------------------------------------------------------*/
  486.  
  487. int DFGRaddrig(dfile, ref, rig)
  488. DF *dfile;
  489. uint16 ref;
  490. DFGRrig *rig;
  491. {
  492.     char ntstring[4];
  493.     int lutsize;
  494.  
  495.     DFerror = DFE_NOERROR;
  496.  
  497.     if (DFIcheck(dfile))
  498.         return( -1);
  499.     if (!ref) {
  500.         DFerror = DFE_BADREF;
  501.         return(-1);
  502.     }
  503.     if (Ref.nt<=0) {        /* if nt not previously written to file */
  504.                 /* construct and write out NT */
  505.         ntstring[0] = DFNT_VERSION; /* version */
  506.         ntstring[1] = DFNT_UCHAR; /* type */
  507.         ntstring[2] = 8;    /* width: RIG data is 8-bit chars */
  508.         ntstring[3] = DFNTC_BYTE; /* class: data are numeric values */
  509.         if (DFputelement(dfile, DFTAG_NT, ref,(char*)ntstring, (int32) 4) <0)
  510.             return(-1);
  511.         rig->datadesc[IMAGE].nt.tag = DFTAG_NT;
  512.         rig->datadesc[IMAGE].nt.ref = ref;
  513.         Ref.nt = ref;
  514.     }
  515.         
  516.     if (Ref.dims[IMAGE]==0) {
  517. #ifdef DF_STRUCTOK        /* write out description record */
  518.         if (DFputelement(dfile, DFTAG_ID, ref, &rig->datadesc[IMAGE], /* ID */
  519.              sizeof(rig->datadesc[IMAGE]))<0)
  520.             return(-1);
  521. #else /*DF_STRUCTOK*/
  522.         register char *p;
  523.         p = DFtbuf;
  524.         INT32WRITE(p, rig->datadesc[IMAGE].xdim);
  525.         INT32WRITE(p, rig->datadesc[IMAGE].ydim);
  526.         UINT16WRITE(p, rig->datadesc[IMAGE].nt.tag);
  527.         UINT16WRITE(p, rig->datadesc[IMAGE].nt.ref);
  528.         INT16WRITE(p, rig->datadesc[IMAGE].ncomponents);
  529.         INT16WRITE(p, rig->datadesc[IMAGE].interlace);
  530.         UINT16WRITE(p, rig->datadesc[IMAGE].compr.tag);
  531.         UINT16WRITE(p, rig->datadesc[IMAGE].compr.ref);
  532.         if (DFputelement(dfile, DFTAG_ID, ref, DFtbuf, (int32)(p-DFtbuf))<0)
  533.             return(-1);
  534. #endif /*DF_STRUCTOK*/
  535.         Ref.dims[IMAGE] = ref;
  536.     }
  537.     if (!Ref.lut) {        /* associated lut not written to this file */
  538.         if (Grlutdata==NULL) {    /* no lut associated */
  539.             DFerror = DFE_BADPTR;
  540.             return(-1);
  541.         }
  542.         lutsize = Grwrite.datadesc[LUT].xdim * Grwrite.datadesc[LUT].ydim *
  543.         Grwrite.datadesc[LUT].ncomponents;
  544.         if (DFputelement(dfile, DFTAG_LUT, ref, Grlutdata, (int32)lutsize)<0)
  545.         return(-1);
  546.         rig->data[LUT].tag = DFTAG_LUT;
  547.         rig->data[LUT].ref = ref;
  548.         Ref.lut = ref;
  549.     }
  550.  
  551.     if (Ref.dims[LUT]==0) {
  552. #ifdef DF_STRUCTOK        /* write out description record */
  553.         if (DFputelement(dfile, DFTAG_LD, ref, &rig->datadesc[LUT], /* ID */
  554.              sizeof(rig->datadesc[LUT]))<0)
  555.             return(-1);
  556. #else /*DF_STRUCTOK*/
  557.         register char *p;
  558.         p = DFtbuf;
  559.         INT32WRITE(p, rig->datadesc[LUT].xdim);
  560.         INT32WRITE(p, rig->datadesc[LUT].ydim);
  561.         UINT16WRITE(p, rig->datadesc[LUT].nt.tag);
  562.         UINT16WRITE(p, rig->datadesc[LUT].nt.ref);
  563.         INT16WRITE(p, rig->datadesc[LUT].ncomponents);
  564.         INT16WRITE(p, rig->datadesc[LUT].interlace);
  565.         UINT16WRITE(p, rig->datadesc[LUT].compr.tag);
  566.         UINT16WRITE(p, rig->datadesc[LUT].compr.ref);
  567.         if (DFputelement(dfile, DFTAG_LD, ref, DFtbuf, (int32)(p-DFtbuf))<0)
  568.             return(-1);
  569. #endif /*DF_STRUCTOK*/
  570.         Ref.dims[LUT] = ref;
  571.     }
  572.  
  573.     /* prepare to start writing rig */
  574.     /* ### NOTE: the parameter to this call may go away */
  575.     if (DFdisetup(10)<0) return(-1); /* max 10 tag/refs in set */
  576.     /* add tag/ref to RIG - image description, image and lookup table */
  577.     if (DFdiput(DFTAG_ID,(uint16)Ref.dims[IMAGE]) < 0) return(-1);
  578.  
  579.     if (DFdiput(rig->data[IMAGE].tag, rig->data[IMAGE].ref) < 0) return(-1);
  580.  
  581.     if ((Ref.dims[LUT]>0) && (DFdiput(DFTAG_LD, (uint16)Ref.dims[LUT]) < 0))
  582.     return(-1);
  583.  
  584.     if ((Ref.lut>0) && (DFdiput(rig->data[LUT].tag, rig->data[LUT].ref) < 0))
  585.     return(-1);
  586.  
  587.     /* write out RIG */
  588.     return(DFdiwrite(dfile, DFTAG_RIG, ref));
  589. }
  590.  
  591. /*****************************************************************************/
  592. /*----------------------- Internal routines ---------------------------------*/
  593. /*****************************************************************************/
  594.  
  595.  
  596. /*-----------------------------------------------------------------------------
  597.  * Name:    DFGRIopen
  598.  * Purpose: open or reopen a file
  599.  * Inputs:  filename: name of file to open
  600.  *          access : access mode
  601.  * Returns: file pointer on success, NULL on failure with DFerror set
  602.  * Users:   HDF systems programmers, all the RIG routines 
  603.  * Invokes: DFopen
  604.  * Remarks: This is a hook for someday providing more efficient ways to
  605.  *          reopen a file, to avoid re-reading all the headers
  606.  *---------------------------------------------------------------------------*/
  607.  
  608. DF *DFGRIopen(filename, access)
  609. char *filename;
  610. int access;
  611. {
  612.  
  613.     DF *dfile;
  614.  
  615.     /* use reopen if same file as last time - more efficient */
  616.     if (strncmp(Grlastfile,filename,DF_MAXFNLEN) || (access==DFACC_CREATE)) {
  617.     /* treat create as different file */
  618.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  619.         Grrefset = 0;        /* no ref to get set for this file */
  620.         Grnewdata = 0;
  621.         if (Ref.lut>0) Ref.lut = 0;
  622.         if (Grlutdata==NULL) Ref.lut = (-1); /* no LUT if not a "set" call */
  623.         if (Ref.dims[IMAGE]>0) Ref.dims[IMAGE] = 0;
  624.         if (Ref.dims[LUT]>0) Ref.dims[LUT] = 0;
  625.         if (Ref.nt>0) Ref.nt = 0;
  626.         Grread = Grzrig;        /* no rigs read yet */
  627.     }
  628.     else
  629.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  630.  
  631.     strncpy(Grlastfile, filename, DF_MAXFNLEN);
  632.         /* remember filename, so reopen may be used next time if same file */
  633.     return(dfile);
  634. }
  635.  
  636. /*-----------------------------------------------------------------------------
  637.  * Name:    DFGRIriginfo
  638.  * Purpose: Get information about next RIG in file
  639.  * Inputs:  dfile: pointer to DF file
  640.  * Returns: 0 on success, -1 on failure with DFerror set
  641.  * Users:   HDF systems programmers
  642.  * Invokes: DFIfind, DFgetelement, DFGRgetrig
  643.  * Remarks: if Grrefset set, gets image with that ref, if any
  644.  *---------------------------------------------------------------------------*/
  645.  
  646. int DFGRIriginfo(dfile)
  647. DF *dfile;
  648. {
  649.     DFdle *dlep;
  650.     int cdd, i, isfirst;
  651.     uint16 newref=0, newtag, gettag, getref;
  652.     struct {
  653.         uint16 xdim;
  654.         uint16 ydim;
  655.     } r8dims;
  656.     char *p;
  657.  
  658.     isfirst = (Grrefset!=0) || (Grread.data[IMAGE].ref==0);
  659.     getref = Grrefset;        /* ref if specified, else 0 */
  660.     Grrefset = 0;        /* no longer need to remember specified ref */
  661.     gettag = DFTAG_RIG;
  662.     for (i=0; i<4; i++) {    /* repeat for RIG, RI8, CI8, II8 */
  663.         if (DFIfind(dfile, gettag, getref, isfirst, gettag,
  664.             Grread.data[IMAGE].ref, &dlep, &cdd)<0) {
  665.         /* not found */
  666.             if (gettag==DFTAG_RIG) { /* were looking for RIGs */
  667.                 if ((Grread.data[IMAGE].tag==DFTAG_RI) /* file has Rigs */
  668.                     || (Grread.data[IMAGE].tag==DFTAG_CI)) {
  669.                     return(-1);    /* no more to return */
  670.                 }
  671.                 gettag = DFTAG_RI8; /* if no RIGs in file, look for RI8s */
  672.             }
  673.             else if ((gettag==DFTAG_II8) && (!newref)) { /* no RI8/CI8/II8 */
  674.                 return(-1);
  675.             }
  676.             continue;        /* continue checking */
  677.         }
  678.     /* found */
  679.         if (!newref || (dlep->dd[cdd].ref < newref)) { /* is it next one? */
  680.             newref = dlep->dd[cdd].ref;    /* remember tag, ref */
  681.             newtag = gettag;
  682.         }
  683.         if (gettag==DFTAG_RI8) gettag = DFTAG_CI8; /* check next */
  684.         else if (gettag==DFTAG_CI8) gettag = DFTAG_II8;
  685.         else break;        /* all checked, quit */
  686.     }
  687.  
  688.     if (newtag==DFTAG_RIG) {
  689.         if (DFGRgetrig(dfile, newref, &Grread)<0)
  690.             return(-1);
  691.     } else {
  692.         Grread.data[IMAGE].ref = newref;
  693.         Grread.data[IMAGE].tag = newtag;
  694.         if (newtag==DFTAG_CI8) Grread.datadesc[IMAGE].compr.tag = DFTAG_RLE;
  695.         else if (newtag==DFTAG_II8)
  696.             Grread.datadesc[IMAGE].compr.tag = DFTAG_IMC;
  697.  
  698.         if (DFgetelement(dfile, DFTAG_ID8, newref, (char*)&r8dims)<0)
  699.             return(-1);
  700. #ifdef DF_STRUCTOK
  701.         Grread.datadesc[IMAGE].xdim = r8dims.xdim;
  702.         Grread.datadesc[IMAGE].ydim = r8dims.ydim;
  703. #else /*DF_STRUCTOK*/
  704.         p = (char *) &r8dims;
  705.         UINT16READ(p, Grread.datadesc[IMAGE].xdim);
  706.         UINT16READ(p, Grread.datadesc[IMAGE].ydim);
  707. #endif /*DF_STRUCTOK*/
  708.  
  709.         if (DFIfind(dfile, DFTAG_IP8, newref, 0, 0, 0, &dlep, &cdd)>=0) {
  710.             Grread.data[LUT].tag = DFTAG_IP8;
  711.             Grread.data[LUT].ref = newref;
  712.         }
  713.         DFerror = DFE_NOERROR;    /* reset it, just in case! */
  714.     }
  715.  
  716.     /* if LUT dimensions not set, set default dimensions */
  717.     if (Grread.data[LUT].tag && Grread.datadesc[LUT].xdim==0) {
  718.         Grread.datadesc[LUT].xdim = 256;
  719.         Grread.datadesc[LUT].ydim = 1;
  720.         Grread.datadesc[LUT].ncomponents = 3;
  721.     }
  722.  
  723.     Grlastref = Grread.data[IMAGE].ref;    /* remember ref read */
  724.  
  725.     return(0);
  726. }
  727.  
  728. /*-----------------------------------------------------------------------------
  729.  * Name:    DFGRIgetdims
  730.  * Purpose: get dimensions of next image/lut from RIG
  731.  * Inputs:  filename: name of HDF file
  732.  *          pxdim, pxdim: pointer to locations for returning x,y dimensions
  733.  *          pncomps: location for returning no of components
  734.  *          pil: location for returning interlace of image/lut in file
  735.  *          type: LUT to get lut dims, IMAGE to get image dims
  736.  * Returns: 0 on success, -1 on failure with DFerror set
  737.  *          *pxdim, *pydim are set to dimensions of the next image on success
  738.  *          *pncomps, *pil set on success
  739.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  740.  * Invokes: DFGRIopen, DFclose, DFGRIriginfo, DFIerr
  741.  * Remarks: none
  742.  *---------------------------------------------------------------------------*/
  743.  
  744. int DFGRIgetdims(filename, pxdim, pydim, pncomps, pil, type)
  745. char *filename;
  746. int32 *pxdim, *pydim;
  747. int *pncomps, *pil, type;
  748. {
  749.     DF *dfile;
  750.  
  751.     DFerror = DFE_NOERROR;
  752.  
  753.     dfile = DFGRIopen(filename, DFACC_READ);
  754.     if (dfile == NULL) return(-1);
  755.  
  756.     if (type==IMAGE) {        /* getimdims sequences, getlutdims does not */
  757.         if (DFGRIriginfo(dfile)<0) /* reads next RIG or RI8 from file */
  758.             return(DFIerr(dfile)); /* on error, close file and return -1 */
  759.         Grnewdata = 1;
  760.     }
  761.  
  762.     if (type==LUT) if (Grread.data[LUT].ref==0) {
  763.             DFerror = DFE_NOMATCH;
  764.             return(-1);        /* no LUT */
  765.     }
  766.     if (pxdim) *pxdim = Grread.datadesc[type].xdim;
  767.     if (pydim) *pydim = Grread.datadesc[type].ydim;
  768.     if (pncomps) *pncomps = Grread.datadesc[type].ncomponents;
  769.     if (pil) *pil = Grread.datadesc[type].interlace;
  770.     return(DFclose(dfile));
  771. }
  772.  
  773. /*-----------------------------------------------------------------------------
  774.  * Name:    DFGRIreqil
  775.  * Purpose: set interlace with which to get subsequent images/luts
  776.  * Inputs:  il: interlace to get image/lut with
  777.  *          type: LUT for luts, IMAGE for images
  778.  * Returns: 0 on success, -1 on failure with DFerror set
  779.  * Users:   HDF users, utilities, other routines
  780.  * Invokes: none
  781.  * Remarks: none
  782.  *---------------------------------------------------------------------------*/
  783.  
  784. int DFGRIreqil(il, type)
  785. int il, type;
  786. {
  787.     DFerror = DFE_NOERROR;
  788.  
  789.     Grreqil[type] = il;
  790.  
  791.     return(0);
  792. }
  793.  
  794.  
  795. /*-----------------------------------------------------------------------------
  796.  * Name:    DFGRIgetimlut
  797.  * Purpose: get next image/lut from a RIG
  798.  * Inputs:  filename: name of HDF file
  799.  *          imlut: space to read image/lut into
  800.  *          xdim, ydim: dimensions of space allocated by user for image/lut
  801.  *          type: LUT for luts, IMAGE for images
  802.  *          isfortran: 0 if called from C, 1 if called from Fortran
  803.  * Returns: 0 on success, -1 on failure with DFerror set
  804.  *          image/lut in imlut
  805.  * Users:   HDF HLL users, utilities, other routines
  806.  * Invokes: DFGRIopen, DFGRIriginfo, DFIerr, DFclose, DFgetelement, DFgetcomp
  807.  * Remarks: Will also get RI8s and CI8s if no RIGs in file
  808.  *          Normally, DFGRgetimdims is called first and it moves to next image
  809.  *          But if that is not called, DFGRgetimlut will itself move to next
  810.  *          image (but not next lut!).
  811.  *          Automatically decompresses images/luts
  812.  *---------------------------------------------------------------------------*/
  813.  
  814. /* shut lint up */
  815. /* ARGSUSED */
  816. int DFGRIgetimlut(filename, imlut, xdim, ydim, type, isfortran)
  817. char *filename;
  818. int32 xdim, ydim;
  819. char *imlut;
  820. int type, isfortran;
  821. {
  822.     DF *dfile;
  823.     int32 currpos[3], currmax[3], destsize[3], bufsize, i, j;
  824.     char *buf, *destp;
  825.  
  826.     DFerror = DFE_NOERROR;
  827.  
  828.     dfile = DFGRIopen(filename, DFACC_READ);
  829.     if (dfile == NULL) return(-1);
  830.  
  831.     if ((type==IMAGE) && (Grnewdata!=1)) { /* if Grread not fresh */
  832.         if (DFGRIriginfo(dfile)<0) /* reads next RIG or RI8 from file */
  833.             return(DFIerr(dfile)); /* on error, close file and return -1 */
  834.     }
  835.     if (Grnewdata==0) {
  836.         DFerror = DFE_BADCALL;
  837.         return(-1);
  838.     }
  839.     Grnewdata = 0;        /* read new RIG next time */
  840.  
  841.     if ((xdim!=Grread.datadesc[type].xdim) ||
  842.     (ydim!=Grread.datadesc[type].ydim)) {
  843.         DFerror = DFE_BADDIM;
  844.         return(-1);
  845.     }
  846.  
  847.     /* read image/lut */
  848.     if (Grread.datadesc[type].compr.tag) { /* compressed image/lut */
  849.         if ((Grreqil[type] >= 0) &&
  850.         (Grreqil[type] != Grread.datadesc[type].interlace)) {
  851.             DFerror = DFE_NOTIMPL;
  852.             return(-1);
  853.         }
  854.         if (DFgetcomp(dfile, Grread.data[type].tag, Grread.data[type].ref,
  855.               imlut, Grread.datadesc[type].xdim,
  856.               Grread.datadesc[type].ydim,
  857.               Grread.datadesc[type].compr.tag)<0)
  858.             return(DFIerr(dfile));
  859.     } else {            /* non-compressed raster image/lut */
  860.         if (Grreqil[type]>=0) {
  861.             if (Grreqil[type]>=Grread.datadesc[type].ncomponents) {
  862.                 DFerror = DFE_BADDIM;
  863.                 return(-1);
  864.             }
  865.             else if (Grreqil[type]!=Grread.datadesc[type].interlace) {
  866.  
  867.                 if (DFaccess(dfile, Grread.data[type].tag,
  868.                  Grread.data[type].ref, "r")<0)
  869.                     return(DFIerr(dfile));
  870.         /* current position in data */
  871.                 currpos[0] = currpos[1] = currpos[2] = 0;
  872.                 currmax[0] = Grread.datadesc[type].ncomponents;
  873.                 currmax[1] = Grread.datadesc[type].ydim;
  874.                 currmax[2] = Grread.datadesc[type].xdim;
  875.  
  876.         /* compute size of each dim of dest array */
  877.                 destsize[0] = destsize[1] = 1;
  878.                 destsize[2] = currmax[1]; /* xdim is more sig than ydim */
  879.                 if (Grreqil[type]==0) {
  880.                     destsize[1] *= currmax[0];
  881.                     destsize[2] *= currmax[0];
  882.                 }
  883.                 else if (Grreqil[type]==1) {
  884.                     destsize[0] *= currmax[1];
  885.                     destsize[2] *= currmax[0];
  886.                 }
  887.                 else if (Grreqil[type]==2) {
  888.                     destsize[0] *= currmax[1] * currmax[2];
  889.                 }
  890.  
  891.                 bufsize = Grread.datadesc[type].ydim *
  892.             Grread.datadesc[type].ncomponents;
  893.                 buf = DFIgetspace((unsigned)bufsize);
  894.                 if (buf==NULL) return(DFIerr(dfile));
  895.  
  896.         /* read byte by byte and copy */
  897.                 for (i=0; i<Grread.datadesc[type].xdim; i++) {
  898.                     if (DFread(dfile, buf, bufsize)<0)
  899.             return(DFIerr(dfile));
  900.                     for (j=0; j<bufsize; j++) {
  901.                         destp = imlut + destsize[0] * currpos[0] +
  902.                 destsize[1] * currpos[1] +
  903.                 destsize[2] * currpos[2];
  904.                         *destp = buf[j];
  905.                         if (Grread.datadesc[type].interlace==0) {
  906.                             if (++currpos[0] == currmax[0]) {
  907.                                 currpos[0] = 0;
  908.                                 if (++currpos[1] == currmax[1]) {
  909.                                     currpos[1] = 0;
  910.                                     if (++currpos[2] == currmax[2]) break;
  911.                                 }
  912.                             }
  913.                         } else if (++currpos[1]==currmax[1]) {
  914.                             currpos[1] = 0;
  915.                             if (Grread.datadesc[type].interlace==1) {
  916.                                 if (++currpos[0] == currmax[0]) {
  917.                                     currpos[0] = 0;
  918.                                     if (++currpos[2] == currmax[2]) break;
  919.                                 }
  920.                             } else {
  921.                                 if (++currpos[2] == currmax[2]) {
  922.                                     currpos[2] = 0;
  923.                                     if (++currpos[0] == currmax[0]) break;
  924.                                 }
  925.                             }
  926.                         }
  927.                     }
  928.                 }
  929.                 return(0);
  930.             }
  931.         }
  932.         if (DFgetelement(dfile, Grread.data[type].tag, Grread.data[type].ref,
  933.              imlut)<0)
  934.             return(DFIerr(dfile));
  935.     }
  936.  
  937.     return(DFclose(dfile));
  938. }
  939.  
  940. /*-----------------------------------------------------------------------------
  941.  * Name:    DFGRIsetdims
  942.  * Purpose: set dimensions of image/lut
  943.  * Inputs:  xdim, ydim: dimensions of lut
  944.  *          ncomps: no of components
  945.  *          il: interlace of lut
  946.  *          type: LUT if lut, IMAGE if image
  947.  * Returns: 0 on success, -1 on failure with DFerror set
  948.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  949.  * Invokes: none
  950.  * Remarks: none
  951.  *---------------------------------------------------------------------------*/
  952.  
  953. int DFGRIsetdims(xdim, ydim, ncomps, type)
  954. int32 xdim, ydim;
  955. int ncomps;
  956. int type;
  957. {
  958.  
  959.     if ((xdim<=0) || (ydim<=0)) {
  960.         DFerror = DFE_BADDIM;
  961.         return(-1);
  962.     }
  963.     if (ncomps<0) {
  964.         DFerror = DFE_BADDIM;
  965.         return(-1);
  966.     }
  967.     Grwrite.datadesc[type].xdim = xdim;
  968.     Grwrite.datadesc[type].ydim = ydim;
  969.     Grwrite.datadesc[type].ncomponents = ncomps;
  970.  
  971.     Ref.dims[type] = 0;
  972.  
  973.     return(0);
  974. }
  975.  
  976. /*-----------------------------------------------------------------------------
  977.  * Name:    DFGRIsetil
  978.  * Purpose: set interlace of image/lut
  979.  * Inputs:  il: interlace of lut
  980.  *          type: LUT if lut, IMAGE if image
  981.  * Returns: 0 on success, -1 on failure with DFerror set
  982.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  983.  * Invokes: none
  984.  * Remarks: none
  985.  *---------------------------------------------------------------------------*/
  986.  
  987. int DFGRIsetil(il, type)
  988. int il;
  989. int type;
  990. {
  991.  
  992.     if (il<0) {
  993.         DFerror = DFE_BADDIM;
  994.         return(-1);
  995.     }
  996.     Grwrite.datadesc[type].interlace = il;
  997.  
  998.     return(0);
  999. }
  1000. /*-----------------------------------------------------------------------------
  1001.  * Name:    DFGRIrestart
  1002.  * Purpose: restart file
  1003.  * Inputs: 
  1004.  * Returns: 0 on success, -1 on failure with DFerror set
  1005.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  1006.  * Invokes: none
  1007.  * Remarks: none
  1008.  *---------------------------------------------------------------------------*/
  1009.     int
  1010. DFGRIrestart()
  1011. {
  1012.     Grlastfile[0] = '\0';
  1013.     Grrefset = 0;
  1014.     return 0;
  1015. }
  1016.  
  1017.  
  1018. /*-----------------------------------------------------------------------------
  1019.  * Name:    DFGRIaddimlut
  1020.  * Purpose: Internal routine to write RIG to file
  1021.  * Inputs:  filename: name of HDF file
  1022.  *          imlut: image/lut to be written to file
  1023.  *          xdim, ydim: dimensions of image/lut
  1024.  *          type: LUT if lut, IMAGE if image
  1025.  *          isfortran: 0 if called from C, 1 if called from Fortran
  1026.  * Returns: 0 on success, -1 on failure with DFerror set
  1027.  * Users:   HDF systems programmers, DFGRaddimage, DFGRaddlut, DFGRsetlut
  1028.  * Invokes: DFGRIopen, DFclose, DFputelement, DFdup, DFGRaddrig, DFputcomp,
  1029.  *          DFIerr
  1030.  * Remarks: Creates both RIG and RI8/CI8 tags, to accomodate older programs
  1031.  *          LUT will be associated with image if set previously
  1032.  *---------------------------------------------------------------------------*/
  1033.  
  1034. /* shut lint up */
  1035. /* ARGSUSED */
  1036. int DFGRIaddimlut(filename, imlut, xdim, ydim, type, isfortran)
  1037. char *filename;
  1038. int32 xdim, ydim;
  1039. char *imlut;
  1040. int type, isfortran;
  1041. {
  1042.     DF *dfile;
  1043.     uint16 wtag, wref;        /* tag of image/lut being written */
  1044.     char *newlut;
  1045.     int32 lutsize;
  1046.     int is8bit;
  1047.     struct {
  1048.         uint16 xdim;
  1049.         uint16 ydim;
  1050.     } r8dims;
  1051.     char *p;
  1052.  
  1053.     DFerror = DFE_NOERROR;
  1054.  
  1055.     if ((Ref.dims[type]==0) && ((xdim!=Grwrite.datadesc[type].xdim) ||
  1056.                 (ydim!=Grwrite.datadesc[type].ydim))) {
  1057.         DFerror = DFE_BADDIM;
  1058.         return(-1);
  1059.     }
  1060.  
  1061.     if (!imlut) {
  1062.         DFerror = DFE_BADPTR;
  1063.         return(-1);
  1064.     }
  1065.  
  1066.     if (Ref.dims[type]<0)    /* if dims not set, set dimensions */
  1067.         if (DFGRIsetdims(xdim, ydim, 1, type)<0) return(-1);
  1068.                 /* default: ncomps=1, il=0 */
  1069.  
  1070.     if ((type==LUT) && (filename==NULL)) { /* set call */
  1071.         if (Grlutdata) Grlutdata = (char *) DFIfreespace(Grlutdata);
  1072.         Ref.lut = -1;
  1073.         if (imlut==NULL) return(0);
  1074.         lutsize = Grwrite.datadesc[LUT].xdim * Grwrite.datadesc[LUT].ydim *
  1075.         Grwrite.datadesc[LUT].ncomponents;
  1076.         Grlutdata = (char *) DFIgetspace((unsigned)lutsize);
  1077.         DFmovmem(imlut, Grlutdata, (int)lutsize);
  1078.         Ref.lut = 0;
  1079.         return(0);
  1080.     }
  1081.     dfile = DFGRIopen(filename, DFACC_ALL);
  1082.     if (dfile==NULL) return(-1);
  1083.  
  1084.     wref = DFnewref(dfile);
  1085.     if (!wref) return(DFIerr(dfile));
  1086.  
  1087.     wtag = (type==LUT) ? DFTAG_LUT : Grcompr ? DFTAG_CI : DFTAG_RI;
  1088.     Grwrite.data[type].tag = wtag;
  1089.  
  1090.     is8bit = (Grwrite.datadesc[IMAGE].ncomponents == 1);
  1091.  
  1092.     /* write out image/lut */
  1093.     if ((type==IMAGE) && Grcompr) {
  1094.         if (Grwrite.datadesc[IMAGE].ncomponents>1) {
  1095.             DFerror = DFE_NOTIMPL;
  1096.             return(DFIerr(dfile));
  1097.         }
  1098.         lutsize = Grwrite.datadesc[LUT].xdim * Grwrite.datadesc[LUT].ydim *
  1099.         Grwrite.datadesc[LUT].ncomponents;
  1100.         if (Grcompr=DFTAG_IMC) {
  1101.             if (Grlutdata==NULL) {
  1102.                 DFerror = DFE_BADCALL;
  1103.                 return(DFIerr(dfile));
  1104.             }
  1105.             newlut = (char *) DFIgetspace((unsigned)lutsize);
  1106.         }
  1107.         if (DFputcomp(dfile, wtag, wref, imlut, xdim, ydim,
  1108.               Grlutdata, newlut, Grcompr)<0)
  1109.             return(DFIerr(dfile));
  1110.     } else {            /* image need not be compressed */
  1111.         if (DFputelement(dfile, wtag, wref, imlut,
  1112.              xdim*ydim*Grwrite.datadesc[type].ncomponents)<0)
  1113.             return(DFIerr(dfile));
  1114.     }
  1115.     Grwrite.data[type].ref = wref;
  1116.     Grwrite.aspectratio = 1.0;
  1117.  
  1118.     wtag = (type==LUT) ? DFTAG_IP8 : Grcompr ?
  1119.     ((Grcompr==DFTAG_RLE) ? DFTAG_CI8 : DFTAG_II8) : DFTAG_RI8;
  1120.     /* Write out Raster-8 tags for those who want it */
  1121.     if (is8bit && (DFdup(dfile, wtag, wref, Grwrite.data[type].tag, wref)<0))
  1122.         return(DFIerr(dfile));
  1123.  
  1124.     if (type==IMAGE) Grwrite.datadesc[IMAGE].compr.tag = Grcompr;
  1125.  
  1126.     if (Grcompr==DFTAG_IMC) {
  1127.         if (DFputelement(dfile, DFTAG_LUT, wref, newlut, lutsize)<0)
  1128.             return(DFIerr(dfile));
  1129.         Ref.lut = wref;
  1130.     }
  1131.  
  1132.     if (DFGRaddrig(dfile, wref, &Grwrite)<0) /* writes ID, NT */
  1133.         return(DFIerr(dfile));
  1134.  
  1135.     if (is8bit) {
  1136.     /* put in Raster-8 stuff also, for those who want it */
  1137.         if ((Ref.lut>=0) && DFdup(dfile, DFTAG_IP8, wref, DFTAG_LUT, wref)<0)
  1138.             return(DFIerr(dfile));
  1139. #ifdef DF_STRUCTOK
  1140.         r8dims.xdim = Grwrite.datadesc[IMAGE].xdim;
  1141.         r8dims.ydim = Grwrite.datadesc[IMAGE].ydim;
  1142. #else /*DF_STRUCTOK*/
  1143.         p = (char *) &r8dims.xdim;
  1144.         UINT16WRITE(p, Grwrite.datadesc[IMAGE].xdim);
  1145.         UINT16WRITE(p, Grwrite.datadesc[IMAGE].ydim);
  1146. #endif /*DF_STRUCTOK*/
  1147.         if (DFputelement(dfile, DFTAG_ID8, wref, (char*)&r8dims, (int32) 4)<0)
  1148.             return(DFIerr(dfile));
  1149.     }
  1150.  
  1151.     if (Grcompr==DFTAG_IMC) {
  1152.         Ref.lut = 0;
  1153.         newlut = (char *) DFIfreespace(newlut);
  1154.     }
  1155.  
  1156.     Grlastref = wref;        /* remember ref written */
  1157.     
  1158.     wref = 0;            /* don't know ref to write next */
  1159.  
  1160.     return(DFclose(dfile));
  1161. }
  1162.