diff options
Diffstat (limited to 'vendor/cfitsio/imcompress.c')
| -rw-r--r-- | vendor/cfitsio/imcompress.c | 9247 |
1 files changed, 9247 insertions, 0 deletions
diff --git a/vendor/cfitsio/imcompress.c b/vendor/cfitsio/imcompress.c new file mode 100644 index 00000000..6330bf8d --- /dev/null +++ b/vendor/cfitsio/imcompress.c @@ -0,0 +1,9247 @@ +# include <stdio.h> +# include <stdlib.h> +# include <string.h> +# include <math.h> +# include <ctype.h> +# include <time.h> +# include "fitsio2.h" + +#define NULL_VALUE -2147483647 /* value used to represent undefined pixels */ + +/* nearest integer function */ +# define NINT(x) ((x >= 0.) ? (int) (x + 0.5) : (int) (x - 0.5)) + +/* special quantize level value indicates that floating point image pixels */ +/* should not be quantized and instead losslessly compressed (with GZIP) */ +#define NO_QUANTIZE 9999 + + +/* string array for storing the individual column compression stats */ +char results[999][60]; +float trans_ratio[999]; + +float *fits_rand_value = 0; + +int imcomp_write_nocompress_tile(fitsfile *outfptr, long row, int datatype, + void *tiledata, long tilelen, int nullcheck, void *nullflagval, int *status); +int imcomp_convert_tile_tshort(fitsfile *outfptr, void *tiledata, long tilelen, + int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale, + double zero, double actual_bzero, int *intlength, int *status); +int imcomp_convert_tile_tushort(fitsfile *outfptr, void *tiledata, long tilelen, + int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale, + double zero, int *intlength, int *status); +int imcomp_convert_tile_tint(fitsfile *outfptr, void *tiledata, long tilelen, + int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale, + double zero, int *intlength, int *status); +int imcomp_convert_tile_tuint(fitsfile *outfptr, void *tiledata, long tilelen, + int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale, + double zero, int *intlength, int *status); +int imcomp_convert_tile_tbyte(fitsfile *outfptr, void *tiledata, long tilelen, + int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale, + double zero, int *intlength, int *status); +int imcomp_convert_tile_tsbyte(fitsfile *outfptr, void *tiledata, long tilelen, + int nullcheck, void *nullflagval, int nullval, int zbitpix, double scale, + double zero, int *intlength, int *status); +int imcomp_convert_tile_tfloat(fitsfile *outfptr, long row, void *tiledata, long tilelen, + long tilenx, long tileny, int nullcheck, void *nullflagval, int nullval, int zbitpix, + double scale, double zero, int *intlength, int *flag, double *bscale, double *bzero,int *status); +int imcomp_convert_tile_tdouble(fitsfile *outfptr, long row, void *tiledata, long tilelen, + long tilenx, long tileny, int nullcheck, void *nullflagval, int nullval, int zbitpix, + double scale, double zero, int *intlength, int *flag, double *bscale, double *bzero, int *status); + +static int unquantize_i1r4(long row, + unsigned char *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + unsigned char tnull, /* I - value of FITS TNULLn keyword if any */ + float nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + float *output, /* O - array of converted pixels */ + int *status); /* IO - error status */ +static int unquantize_i2r4(long row, + short *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + short tnull, /* I - value of FITS TNULLn keyword if any */ + float nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + float *output, /* O - array of converted pixels */ + int *status); /* IO - error status */ +static int unquantize_i4r4(long row, + INT32BIT *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + INT32BIT tnull, /* I - value of FITS TNULLn keyword if any */ + float nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + float *output, /* O - array of converted pixels */ + int *status); /* IO - error status */ +static int unquantize_i1r8(long row, + unsigned char *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + unsigned char tnull, /* I - value of FITS TNULLn keyword if any */ + double nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + double *output, /* O - array of converted pixels */ + int *status); /* IO - error status */ +static int unquantize_i2r8(long row, + short *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + short tnull, /* I - value of FITS TNULLn keyword if any */ + double nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + double *output, /* O - array of converted pixels */ + int *status); /* IO - error status */ +static int unquantize_i4r8(long row, + INT32BIT *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + INT32BIT tnull, /* I - value of FITS TNULLn keyword if any */ + double nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + double *output, /* O - array of converted pixels */ + int *status); /* IO - error status */ +static int imcomp_float2nan(float *indata, long tilelen, int *outdata, + float nullflagval, int *status); +static int imcomp_double2nan(double *indata, long tilelen, LONGLONG *outdata, + double nullflagval, int *status); +static int fits_read_write_compressed_img(fitsfile *fptr, /* I - FITS file pointer */ + int datatype, /* I - datatype of the array to be returned */ + LONGLONG *infpixel, /* I - 'bottom left corner' of the subsection */ + LONGLONG *inlpixel, /* I - 'top right corner' of the subsection */ + long *ininc, /* I - increment to be applied in each dimension */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: set undefined pixels = nullval */ + void *nullval, /* I - value for undefined pixels */ + int *anynul, /* O - set to 1 if any values are null; else 0 */ + fitsfile *outfptr, /* I - FITS file pointer */ + int *status); + +static int fits_shuffle_8bytes(char *heap, LONGLONG length, int *status); +static int fits_shuffle_4bytes(char *heap, LONGLONG length, int *status); +static int fits_shuffle_2bytes(char *heap, LONGLONG length, int *status); +static int fits_gzip_heap(fitsfile *infptr, fitsfile *outfptr, int *status); +static int fits_unshuffle_8bytes(char *heap, LONGLONG length, int *status); +static int fits_unshuffle_4bytes(char *heap, LONGLONG length, int *status); +static int fits_unshuffle_2bytes(char *heap, LONGLONG length, int *status); +static int fits_gunzip_heap(fitsfile *infptr, fitsfile *outfptr, int *status); + +/*---------------------------------------------------------------------------*/ +int fits_init_randoms(void) { + +/* initialize an array of random numbers */ + + int ii; + double a = 16807.0; + double m = 2147483647.0; + double temp, seed; + + FFLOCK; + + if (fits_rand_value) { + FFUNLOCK; + return(0); /* array is already initialized */ + } + + /* allocate array for the random number sequence */ + /* THIS MEMORY IS NEVER FREED */ + fits_rand_value = calloc(N_RANDOM, sizeof(float)); + + if (!fits_rand_value) { + FFUNLOCK; + return(MEMORY_ALLOCATION); + } + + /* We need a portable algorithm that anyone can use to generate this + exact same sequence of random number. The C 'rand' function is not + suitable because it is not available to Fortran or Java programmers. + Instead, use a well known simple algorithm published here: + "Random number generators: good ones are hard to find", Communications of the ACM, + Volume 31 , Issue 10 (October 1988) Pages: 1192 - 1201 + */ + + /* initialize the random numbers */ + seed = 1; + for (ii = 0; ii < N_RANDOM; ii++) { + temp = a * seed; + seed = temp -m * ((int) (temp / m) ); + fits_rand_value[ii] = (float) (seed / m); + } + + FFUNLOCK; + + /* + IMPORTANT NOTE: the 10000th seed value must have the value 1043618065 if the + algorithm has been implemented correctly */ + + if ( (int) seed != 1043618065) { + ffpmsg("fits_init_randoms generated incorrect random number sequence"); + return(1); + } else { + return(0); + } +} +/*--------------------------------------------------------------------------*/ +void bz_internal_error(int errcode) +{ + /* external function declared by the bzip2 code in bzlib_private.h */ + ffpmsg("bzip2 returned an internal error"); + ffpmsg("This should never happen"); + return; +} +/*--------------------------------------------------------------------------*/ +int fits_set_compression_type(fitsfile *fptr, /* I - FITS file pointer */ + int ctype, /* image compression type code; */ + /* allowed values: RICE_1, GZIP_1, GZIP_2, PLIO_1, */ + /* HCOMPRESS_1, BZIP2_1, and NOCOMPRESS */ + int *status) /* IO - error status */ +{ +/* + This routine specifies the image compression algorithm that should be + used when writing a FITS image. The image is divided into tiles, and + each tile is compressed and stored in a row of at variable length binary + table column. +*/ + (fptr->Fptr)->request_compress_type = ctype; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_tile_dim(fitsfile *fptr, /* I - FITS file pointer */ + int ndim, /* number of dimensions in the compressed image */ + long *dims, /* size of image compression tile in each dimension */ + /* default tile size = (NAXIS1, 1, 1, ...) */ + int *status) /* IO - error status */ +{ +/* + This routine specifies the size (dimension) of the image + compression tiles that should be used when writing a FITS + image. The image is divided into tiles, and each tile is compressed + and stored in a row of at variable length binary table column. +*/ + int ii; + + if (ndim < 0 || ndim > MAX_COMPRESS_DIM) + { + *status = BAD_DIMEN; + return(*status); + } + + for (ii = 0; ii < ndim; ii++) + { + (fptr->Fptr)->request_tilesize[ii] = dims[ii]; + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_quantize_level(fitsfile *fptr, /* I - FITS file pointer */ + float qlevel, /* floating point quantization level */ + int *status) /* IO - error status */ +{ +/* + This routine specifies the value of the quantization level, q, that + should be used when compressing floating point images. The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. +*/ + if (qlevel == 0.) + { + /* this means don't quantize the floating point values. Instead, */ + /* the floating point values will be losslessly compressed */ + (fptr->Fptr)->quantize_level = NO_QUANTIZE; + } else { + + (fptr->Fptr)->quantize_level = qlevel; + + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_quantize_dither(fitsfile *fptr, /* I - FITS file pointer */ + int dither, /* dither type */ + int *status) /* IO - error status */ +{ +/* + This routine specifies what type of dithering (randomization) should + be performed when quantizing floating point images to integer prior to + compression. A value of -1 means do no dithering. A value of 0 means + used the default SUBTRACTIVE_DITHER_1 (which is equivalent to dither = 1). + A value of -1 means do not apply any dither. +*/ + + if (dither == 0) dither = 1; + (fptr->Fptr)->request_quantize_dither = dither; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_dither_offset(fitsfile *fptr, /* I - FITS file pointer */ + int offset, /* random dithering offset value (1 to 10000) */ + int *status) /* IO - error status */ +{ +/* + This routine specifies the value of the offset that should be applied when + calculating the random dithering when quantizing floating point iamges. + A random offset should be applied to each image to avoid quantization + effects when taking the difference of 2 images, or co-adding a set of + images. Without this random offset, the corresponding pixel in every image + will have exactly the same dithering. + + offset = 0 means use the default random dithering based on system time + offset = negative means randomly chose dithering based on 1st tile checksum + offset = [1 - 10000] means use that particular dithering pattern + +*/ + /* if positive, ensure that the value is in the range 1 to 10000 */ + if (offset > 0) + (fptr->Fptr)->request_dither_offset = ((offset - 1) % 10000 ) + 1; + else + (fptr->Fptr)->request_dither_offset = offset; + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_noise_bits(fitsfile *fptr, /* I - FITS file pointer */ + int noisebits, /* noise_bits parameter value */ + /* (default = 4) */ + int *status) /* IO - error status */ +{ +/* + ******************************************************************** + ******************************************************************** + THIS ROUTINE IS PROVIDED ONLY FOR BACKWARDS COMPATIBILITY; + ALL NEW SOFTWARE SHOULD CALL fits_set_quantize_level INSTEAD + ******************************************************************** + ******************************************************************** + + This routine specifies the value of the noice_bits parameter that + should be used when compressing floating point images. The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. + + Feb 2008: the "noisebits" parameter has been replaced with the more + general "quantize level" parameter. +*/ + float qlevel; + + if (noisebits < 1 || noisebits > 16) + { + *status = DATA_COMPRESSION_ERR; + return(*status); + } + + qlevel = (float) pow (2., (double)noisebits); + fits_set_quantize_level(fptr, qlevel, status); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_hcomp_scale(fitsfile *fptr, /* I - FITS file pointer */ + float scale, /* hcompress scale parameter value */ + /* (default = 0.) */ + int *status) /* IO - error status */ +{ +/* + This routine specifies the value of the hcompress scale parameter that + The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. +*/ + (fptr->Fptr)->request_hcomp_scale = scale; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_hcomp_smooth(fitsfile *fptr, /* I - FITS file pointer */ + int smooth, /* hcompress smooth parameter value */ + /* if scale > 1 and smooth != 0, then */ + /* the image will be smoothed when it is */ + /* decompressed to remove some of the */ + /* 'blockiness' in the image produced */ + /* by the lossy compression */ + int *status) /* IO - error status */ +{ +/* + This routine specifies the value of the hcompress scale parameter that + The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. +*/ + + (fptr->Fptr)->request_hcomp_smooth = smooth; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_set_lossy_int(fitsfile *fptr, /* I - FITS file pointer */ + int lossy_int, /* I - True (!= 0) or False (0) */ + int *status) /* IO - error status */ +{ +/* + This routine specifies whether images with integer pixel values should + quantized and compressed the same way float images are compressed. + The default is to not do this, and instead apply a lossless compression + algorithm to integer images. +*/ + + (fptr->Fptr)->request_lossy_int_compress = lossy_int; + return(*status); +}/*--------------------------------------------------------------------------*/ +int fits_get_compression_type(fitsfile *fptr, /* I - FITS file pointer */ + int *ctype, /* image compression type code; */ + /* allowed values: */ + /* RICE_1, GZIP_1, GZIP_2, PLIO_1, HCOMPRESS_1, BZIP2_1 */ + int *status) /* IO - error status */ +{ +/* + This routine returns the image compression algorithm that should be + used when writing a FITS image. The image is divided into tiles, and + each tile is compressed and stored in a row of at variable length binary + table column. +*/ + *ctype = (fptr->Fptr)->request_compress_type; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_get_tile_dim(fitsfile *fptr, /* I - FITS file pointer */ + int ndim, /* number of dimensions in the compressed image */ + long *dims, /* size of image compression tile in each dimension */ + /* default tile size = (NAXIS1, 1, 1, ...) */ + int *status) /* IO - error status */ +{ +/* + This routine returns the size (dimension) of the image + compression tiles that should be used when writing a FITS + image. The image is divided into tiles, and each tile is compressed + and stored in a row of at variable length binary table column. +*/ + int ii; + + if (ndim < 0 || ndim > MAX_COMPRESS_DIM) + { + *status = BAD_DIMEN; + return(*status); + } + + for (ii = 0; ii < ndim; ii++) + { + dims[ii] = (fptr->Fptr)->request_tilesize[ii]; + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_get_noise_bits(fitsfile *fptr, /* I - FITS file pointer */ + int *noisebits, /* noise_bits parameter value */ + /* (default = 4) */ + int *status) /* IO - error status */ +{ +/* + ******************************************************************** + ******************************************************************** + THIS ROUTINE IS PROVIDED ONLY FOR BACKWARDS COMPATIBILITY; + ALL NEW SOFTWARE SHOULD CALL fits_set_quantize_level INSTEAD + ******************************************************************** + ******************************************************************** + + + This routine returns the value of the noice_bits parameter that + should be used when compressing floating point images. The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. + + Feb 2008: code changed to use the more general "quantize level" parameter + rather than the "noise bits" parameter. If quantize level is greater than + zero, then the previous noisebits parameter is approximately given by + + noise bits = natural logarithm (quantize level) / natural log (2) + + This result is rounded to the nearest integer. +*/ + double qlevel; + + qlevel = (fptr->Fptr)->quantize_level; + + if (qlevel > 0. && qlevel < 65537. ) + *noisebits = (int) ((log(qlevel) / log(2.0)) + 0.5); + else + *noisebits = 0; + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_get_quantize_level(fitsfile *fptr, /* I - FITS file pointer */ + float *qlevel, /* quantize level parameter value */ + int *status) /* IO - error status */ +{ +/* + This routine returns the value of the noice_bits parameter that + should be used when compressing floating point images. The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. +*/ + + if ((fptr->Fptr)->quantize_level == NO_QUANTIZE) { + *qlevel = 0; + } else { + *qlevel = (fptr->Fptr)->quantize_level; + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_get_dither_offset(fitsfile *fptr, /* I - FITS file pointer */ + int *offset, /* dithering offset parameter value */ + int *status) /* IO - error status */ +{ +/* + This routine returns the value of the dithering offset parameter that + is used when compressing floating point images. The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. +*/ + + *offset = (fptr->Fptr)->request_dither_offset; + return(*status); +}/*--------------------------------------------------------------------------*/ +int fits_get_hcomp_scale(fitsfile *fptr, /* I - FITS file pointer */ + float *scale, /* Hcompress scale parameter value */ + int *status) /* IO - error status */ + +{ +/* + This routine returns the value of the noice_bits parameter that + should be used when compressing floating point images. The image is + divided into tiles, and each tile is compressed and stored in a row + of at variable length binary table column. +*/ + + *scale = (fptr->Fptr)->request_hcomp_scale; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_get_hcomp_smooth(fitsfile *fptr, /* I - FITS file pointer */ + int *smooth, /* Hcompress smooth parameter value */ + int *status) /* IO - error status */ + +{ + *smooth = (fptr->Fptr)->request_hcomp_smooth; + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_img_compress(fitsfile *infptr, /* pointer to image to be compressed */ + fitsfile *outfptr, /* empty HDU for output compressed image */ + int *status) /* IO - error status */ + +/* + This routine initializes the output table, copies all the keywords, + and loops through the input image, compressing the data and + writing the compressed tiles to the output table. + + This is a high level routine that is called by the fpack and funpack + FITS compression utilities. +*/ +{ + int bitpix, naxis; + long naxes[MAX_COMPRESS_DIM]; + + if (*status > 0) + return(*status); + + /* get datatype and size of input image */ + if (fits_get_img_param(infptr, MAX_COMPRESS_DIM, &bitpix, + &naxis, naxes, status) > 0) + return(*status); + + if (naxis < 1 || naxis > MAX_COMPRESS_DIM) + { + ffpmsg("Image cannot be compressed: NAXIS out of range"); + return(*status = BAD_NAXIS); + } + + /* if requested, treat integer images same as a float image. */ + /* Then the pixels will be quantized (lossy algorithm) to achieve */ + /* higher amounts of compression than with lossless algorithms */ + + if ( (outfptr->Fptr)->request_lossy_int_compress != 0 && bitpix > 0) + bitpix = FLOAT_IMG; /* compress integer images as if float */ + + /* initialize output table */ + if (imcomp_init_table(outfptr, bitpix, naxis, naxes, 0, status) > 0) + return (*status); + + /* Copy the image header keywords to the table header. */ + if (imcomp_copy_img2comp(infptr, outfptr, status) > 0) + return (*status); + + /* turn off any intensity scaling (defined by BSCALE and BZERO */ + /* keywords) so that unscaled values will be read by CFITSIO */ + /* (except if quantizing an int image, same as a float image) */ + if ( (outfptr->Fptr)->request_lossy_int_compress == 0 && bitpix > 0) + ffpscl(infptr, 1.0, 0.0, status); + + /* force a rescan of the output file keywords, so that */ + /* the compression parameters will be copied to the internal */ + /* fitsfile structure used by CFITSIO */ + ffrdef(outfptr, status); + + /* turn off any intensity scaling (defined by BSCALE and BZERO */ + /* keywords) so that unscaled values will be written by CFITSIO */ + /* (except if quantizing an int image, same as a float image) */ + if ( (outfptr->Fptr)->request_lossy_int_compress == 0 && bitpix > 0) + ffpscl(outfptr, 1.0, 0.0, status); + + /* Read each image tile, compress, and write to a table row. */ + imcomp_compress_image (infptr, outfptr, status); + + /* force another rescan of the output file keywords, to */ + /* update PCOUNT and TFORMn = '1PB(iii)' keyword values. */ + ffrdef(outfptr, status); + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int fits_compress_img_OBSOLETE(fitsfile *infptr, /* pointer to image to be compressed */ + fitsfile *outfptr, /* empty HDU for output compressed image */ + int compress_type, /* compression type code */ + /* RICE_1, HCOMPRESS_1, etc. */ + long *intilesize, /* size in each dimension of the tiles */ + /* NULL pointer means tile by rows */ + int blocksize, /* compression parameter: blocksize */ + int nbits, /* compression parameter: nbits */ + int *status) /* IO - error status */ + +/* + !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! + This routine is obsolete and should not be used. The + ftools 'fimgzip' task used to call this routine (but that task has been deleted); + + The name of the routine was changed 4/27/2011, to see if anyone complains. + If not, then this routine should be deleted from the source code. + !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! !!! + + This routine initializes the output table, copies all the keywords, + and loops through the input image, compressing the data and + writing the compressed tiles to the output table. +*/ +{ + int bitpix, naxis; + long naxes[MAX_COMPRESS_DIM]; + + if (*status > 0) + return(*status); + + /* get datatype and size of input image */ + if (fits_get_img_param(infptr, MAX_COMPRESS_DIM, &bitpix, + &naxis, naxes, status) > 0) + return(*status); + + if (naxis < 1 || naxis > MAX_COMPRESS_DIM) + { + ffpmsg("Image cannot be compressed: NAXIS out of range"); + return(*status = BAD_NAXIS); + } + + /* initialize output table */ + if (imcomp_init_table(outfptr, bitpix, naxis, naxes, 0, status) > 0) + return (*status); + + /* Copy the image header keywords to the table header. */ + if (imcomp_copy_imheader(infptr, outfptr, status) > 0) + return (*status); + + /* turn off any intensity scaling (defined by BSCALE and BZERO */ + /* keywords) so that unscaled values will be read by CFITSIO */ + ffpscl(infptr, 1.0, 0.0, status); + + /* force a rescan of the output file keywords, so that */ + /* the compression parameters will be copied to the internal */ + /* fitsfile structure used by CFITSIO */ + ffrdef(outfptr, status); + + /* Read each image tile, compress, and write to a table row. */ + imcomp_compress_image (infptr, outfptr, status); + + /* force another rescan of the output file keywords, to */ + /* update PCOUNT and TFORMn = '1PB(iii)' keyword values. */ + ffrdef(outfptr, status); + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_init_table(fitsfile *outfptr, + int inbitpix, + int naxis, + long *naxes, + int writebitpix, /* write the ZBITPIX, ZNAXIS, and ZNAXES keyword? */ + int *status) +/* + create a BINTABLE extension for the output compressed image. +*/ +{ + char keyname[FLEN_KEYWORD], zcmptype[12]; + int ii, remain, ncols, bitpix; + long nrows; + char *ttype[] = {"COMPRESSED_DATA", "ZSCALE", "ZZERO"}; + char *tform[3]; + char tf0[4], tf1[4], tf2[4]; + char *tunit[] = {"\0", "\0", "\0" }; + char comm[FLEN_COMMENT]; + long actual_tilesize[MAX_COMPRESS_DIM]; /* Actual size to use for tiles */ + + if (*status > 0) + return(*status); + + /* check for special case of losslessly compressing floating point */ + /* images. Only compression algorithm that supports this is GZIP */ + if ( (outfptr->Fptr)->quantize_level == NO_QUANTIZE) { + if (((outfptr->Fptr)->request_compress_type != GZIP_1) && + ((outfptr->Fptr)->request_compress_type != GZIP_2)) { + ffpmsg("Lossless compression of floating point images must use GZIP (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + } + } + + /* test for the 2 special cases that represent unsigned integers */ + if (inbitpix == USHORT_IMG) + bitpix = SHORT_IMG; + else if (inbitpix == ULONG_IMG) + bitpix = LONG_IMG; + else if (inbitpix == SBYTE_IMG) + bitpix = BYTE_IMG; + else + bitpix = inbitpix; + + /* reset default tile dimensions too if required */ + memcpy(actual_tilesize, outfptr->Fptr->request_tilesize, MAX_COMPRESS_DIM * sizeof(long)); + + if ((outfptr->Fptr)->request_compress_type == HCOMPRESS_1) { + + if (naxis < 2 ) { + ffpmsg("Hcompress cannot be used with 1-dimensional images (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + + } else if (naxes[0] < 4 || naxes[1] < 4) { + ffpmsg("Hcompress minimum image dimension is 4 pixels (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + } + + if ((actual_tilesize[0] == 0) && + (actual_tilesize[1] == 0) ){ + + /* compress the whole image as a single tile */ + actual_tilesize[0] = naxes[0]; + actual_tilesize[1] = naxes[1]; + + for (ii = 2; ii < naxis; ii++) { + /* set all higher tile dimensions = 1 */ + actual_tilesize[ii] = 1; + } + + } else if ((actual_tilesize[0] == 0) && + (actual_tilesize[1] == 1) ){ + + /* + The Hcompress algorithm is inherently 2D in nature, so the row by row + tiling that is used for other compression algorithms is not appropriate. + If the image has less than 30 rows, then the entire image will be compressed + as a single tile. Otherwise the tiles will consist of 16 rows of the image. + This keeps the tiles to a reasonable size, and it also includes enough rows + to allow good compression efficiency. If the last tile of the image + happens to contain less than 4 rows, then find another tile size with + between 14 and 30 rows (preferably even), so that the last tile has + at least 4 rows + */ + + /* 1st tile dimension is the row length of the image */ + actual_tilesize[0] = naxes[0]; + + if (naxes[1] <= 30) { /* use whole image if it is small */ + actual_tilesize[1] = naxes[1]; + } else { + /* look for another good tile dimension */ + if (naxes[1] % 16 == 0 || naxes[1] % 16 > 3) { + actual_tilesize[1] = 16; + } else if (naxes[1] % 24 == 0 || naxes[1] % 24 > 3) { + actual_tilesize[1] = 24; + } else if (naxes[1] % 20 == 0 || naxes[1] % 20 > 3) { + actual_tilesize[1] = 20; + } else if (naxes[1] % 30 == 0 || naxes[1] % 30 > 3) { + actual_tilesize[1] = 30; + } else if (naxes[1] % 28 == 0 || naxes[1] % 28 > 3) { + actual_tilesize[1] = 28; + } else if (naxes[1] % 26 == 0 || naxes[1] % 26 > 3) { + actual_tilesize[1] = 26; + } else if (naxes[1] % 22 == 0 || naxes[1] % 22 > 3) { + actual_tilesize[1] = 22; + } else if (naxes[1] % 18 == 0 || naxes[1] % 18 > 3) { + actual_tilesize[1] = 18; + } else if (naxes[1] % 14 == 0 || naxes[1] % 14 > 3) { + actual_tilesize[1] = 14; + } else { + actual_tilesize[1] = 17; + + } + } + + } else if (actual_tilesize[0] < 4 || + actual_tilesize[1] < 4) { + + /* user-specified tile size is too small */ + ffpmsg("Hcompress minimum tile dimension is 4 pixels (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + } + + /* check if requested tile size causes the last tile to to have less than 4 pixels */ + remain = naxes[0] % (actual_tilesize[0]); /* 1st dimension */ + if (remain > 0 && remain < 4) { + (actual_tilesize[0])++; /* try increasing tile size by 1 */ + + remain = naxes[0] % (actual_tilesize[0]); + if (remain > 0 && remain < 4) { + ffpmsg("Last tile along 1st dimension has less than 4 pixels (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + } + } + + remain = naxes[1] % (actual_tilesize[1]); /* 2nd dimension */ + if (remain > 0 && remain < 4) { + (actual_tilesize[1])++; /* try increasing tile size by 1 */ + + remain = naxes[1] % (actual_tilesize[1]); + if (remain > 0 && remain < 4) { + ffpmsg("Last tile along 2nd dimension has less than 4 pixels (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + } + } + + } /* end, if HCOMPRESS_1 */ + + for (ii = 0; ii < naxis; ii++) { + if (actual_tilesize[ii] <= 0) { + /* tile size of 0 means use the image size of that dimension */ + actual_tilesize[ii] = naxes[ii]; + } + } + + /* ---- set up array of TFORM strings -------------------------------*/ + strcpy(tf0, "1PB"); + strcpy(tf1, "1D"); + strcpy(tf2, "1D"); + + tform[0] = tf0; + tform[1] = tf1; + tform[2] = tf2; + + /* calculate number of rows in output table */ + nrows = 1; + for (ii = 0; ii < naxis; ii++) + { + nrows = nrows * ((naxes[ii] - 1)/ (actual_tilesize[ii]) + 1); + } + + /* determine the default number of columns in the output table */ + if (bitpix < 0 && (outfptr->Fptr)->quantize_level != NO_QUANTIZE) + ncols = 3; /* quantized and scaled floating point image */ + else + ncols = 1; /* default table has just one 'COMPRESSED_DATA' column */ + + if ((outfptr->Fptr)->request_compress_type == RICE_1) + { + strcpy(zcmptype, "RICE_1"); + } + else if ((outfptr->Fptr)->request_compress_type == GZIP_1) + { + strcpy(zcmptype, "GZIP_1"); + } + else if ((outfptr->Fptr)->request_compress_type == GZIP_2) + { + strcpy(zcmptype, "GZIP_2"); + } + else if ((outfptr->Fptr)->request_compress_type == BZIP2_1) + { + strcpy(zcmptype, "BZIP2_1"); + } + else if ((outfptr->Fptr)->request_compress_type == PLIO_1) + { + strcpy(zcmptype, "PLIO_1"); + /* the PLIO compression algorithm outputs short integers, not bytes */ + strcpy(tform[0], "1PI"); + } + else if ((outfptr->Fptr)->request_compress_type == HCOMPRESS_1) + { + strcpy(zcmptype, "HCOMPRESS_1"); + } + else if ((outfptr->Fptr)->request_compress_type == NOCOMPRESS) + { + strcpy(zcmptype, "NOCOMPRESS"); + } + else + { + ffpmsg("unknown compression type (imcomp_init_table)"); + return(*status = DATA_COMPRESSION_ERR); + } + + /* create the bintable extension to contain the compressed image */ + ffcrtb(outfptr, BINARY_TBL, nrows, ncols, ttype, + tform, tunit, 0, status); + + /* Add standard header keywords. */ + ffpkyl (outfptr, "ZIMAGE", 1, + "extension contains compressed image", status); + + if (writebitpix) { + /* write the keywords defining the datatype and dimensions of */ + /* the uncompressed image. If not, these keywords will be */ + /* copied later from the input uncompressed image */ + + ffpkyj (outfptr, "ZBITPIX", bitpix, + "data type of original image", status); + ffpkyj (outfptr, "ZNAXIS", naxis, + "dimension of original image", status); + + for (ii = 0; ii < naxis; ii++) + { + sprintf (keyname, "ZNAXIS%d", ii+1); + ffpkyj (outfptr, keyname, naxes[ii], + "length of original image axis", status); + } + } + + for (ii = 0; ii < naxis; ii++) + { + sprintf (keyname, "ZTILE%d", ii+1); + ffpkyj (outfptr, keyname, actual_tilesize[ii], + "size of tiles to be compressed", status); + } + + if (bitpix < 0) { + + if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE) { + ffpkys(outfptr, "ZQUANTIZ", "NONE", + "Lossless compression without quantization", status); + } else { + + /* Unless dithering has been specifically turned off by setting */ + /* request_quantize_dither = -1, use dithering by default */ + /* when quantizing floating point images. */ + + if ( (outfptr->Fptr)->request_quantize_dither == 0) + (outfptr->Fptr)->request_quantize_dither = SUBTRACTIVE_DITHER_1; + + if ((outfptr->Fptr)->request_quantize_dither == SUBTRACTIVE_DITHER_1) { + ffpkys(outfptr, "ZQUANTIZ", "SUBTRACTIVE_DITHER_1", + "Pixel Quantization Algorithm", status); + + /* also write the associated ZDITHER0 keyword with a default value */ + /* which may get updated later. */ + ffpky(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->request_dither_offset), + "dithering offset when quantizing floats", status); + } + } + } + + ffpkys (outfptr, "ZCMPTYPE", zcmptype, + "compression algorithm", status); + + /* write any algorithm-specific keywords */ + if ((outfptr->Fptr)->request_compress_type == RICE_1) + { + ffpkys (outfptr, "ZNAME1", "BLOCKSIZE", + "compression block size", status); + + /* for now at least, the block size is always 32 */ + ffpkyj (outfptr, "ZVAL1", 32, + "pixels per block", status); + + ffpkys (outfptr, "ZNAME2", "BYTEPIX", + "bytes per pixel (1, 2, 4, or 8)", status); + + if (bitpix == BYTE_IMG) + ffpkyj (outfptr, "ZVAL2", 1, + "bytes per pixel (1, 2, 4, or 8)", status); + else if (bitpix == SHORT_IMG) + ffpkyj (outfptr, "ZVAL2", 2, + "bytes per pixel (1, 2, 4, or 8)", status); + else + ffpkyj (outfptr, "ZVAL2", 4, + "bytes per pixel (1, 2, 4, or 8)", status); + + } + else if ((outfptr->Fptr)->request_compress_type == HCOMPRESS_1) + { + ffpkys (outfptr, "ZNAME1", "SCALE", + "HCOMPRESS scale factor", status); + ffpkye (outfptr, "ZVAL1", (outfptr->Fptr)->request_hcomp_scale, + 7, "HCOMPRESS scale factor", status); + + ffpkys (outfptr, "ZNAME2", "SMOOTH", + "HCOMPRESS smooth option", status); + ffpkyj (outfptr, "ZVAL2", (long) (outfptr->Fptr)->request_hcomp_smooth, + "HCOMPRESS smooth option", status); + } + + /* Write the BSCALE and BZERO keywords, if an unsigned integer image */ + if (inbitpix == USHORT_IMG) + { + strcpy(comm, "offset data range to that of unsigned short"); + ffpkyg(outfptr, "BZERO", 32768., 0, comm, status); + strcpy(comm, "default scaling factor"); + ffpkyg(outfptr, "BSCALE", 1.0, 0, comm, status); + } + else if (inbitpix == SBYTE_IMG) + { + strcpy(comm, "offset data range to that of signed byte"); + ffpkyg(outfptr, "BZERO", -128., 0, comm, status); + strcpy(comm, "default scaling factor"); + ffpkyg(outfptr, "BSCALE", 1.0, 0, comm, status); + } + else if (inbitpix == ULONG_IMG) + { + strcpy(comm, "offset data range to that of unsigned long"); + ffpkyg(outfptr, "BZERO", 2147483648., 0, comm, status); + strcpy(comm, "default scaling factor"); + ffpkyg(outfptr, "BSCALE", 1.0, 0, comm, status); + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_calc_max_elem (int comptype, int nx, int zbitpix, int blocksize) + +/* This function returns the maximum number of bytes in a compressed + image line. + + nx = maximum number of pixels in a tile + blocksize is only relevant for RICE compression +*/ +{ + if (comptype == RICE_1) + { + if (zbitpix == 16) + return (sizeof(short) * nx + nx / blocksize + 2 + 4); + else + return (sizeof(float) * nx + nx / blocksize + 2 + 4); + } + else if ((comptype == GZIP_1) || (comptype == GZIP_2)) + { + /* gzip usually compressed by at least a factor of 2 for I*4 images */ + /* and somewhat less for I*2 images */ + /* If this size turns out to be too small, then the gzip */ + /* compression routine will allocate more space as required */ + /* to be on the safe size, allocate buffer same size as input */ + + if (zbitpix == 16) + return(nx * 2); + else if (zbitpix == 8) + return(nx); + else + return(nx * 4); + } + else if (comptype == BZIP2_1) + { + /* To guarantee that the compressed data will fit, allocate an output + buffer of size 1% larger than the uncompressed data, plus 600 bytes */ + + return((int) (nx * 1.01 * zbitpix / 8. + 601.)); + } + else if (comptype == HCOMPRESS_1) + { + /* Imperical evidence suggests in the worst case, + the compressed stream could be up to 10% larger than the original + image. Add 26 byte overhead, only significant for very small tiles + + Possible improvement: may need to allow a larger size for 32-bit images */ + + if (zbitpix == 16 || zbitpix == 8) + + return( (int) (nx * 2.2 + 26)); /* will be compressing 16-bit int array */ + else + return( (int) (nx * 4.4 + 26)); /* will be compressing 32-bit int array */ + } + else + return(nx * sizeof(int)); +} +/*--------------------------------------------------------------------------*/ +int imcomp_compress_image (fitsfile *infptr, fitsfile *outfptr, int *status) + +/* This routine does the following: + - reads an image one tile at a time + - if it is a float or double image, then it tries to quantize the pixels + into scaled integers. + - it then compressess the integer pixels, or if the it was not + possible to quantize the floating point pixels, then it losslessly + compresses them with gzip + - writes the compressed byte stream to the output FITS file +*/ +{ + double *tiledata; + int anynul, gotnulls = 0, datatype; + long ii, row; + int naxis; + double dummy = 0., dblnull = DOUBLENULLVALUE; + float fltnull = FLOATNULLVALUE; + long maxtilelen, tilelen, incre[] = {1, 1, 1, 1, 1, 1}; + long naxes[MAX_COMPRESS_DIM], fpixel[MAX_COMPRESS_DIM]; + long lpixel[MAX_COMPRESS_DIM], tile[MAX_COMPRESS_DIM]; + long tilesize[MAX_COMPRESS_DIM]; + long i0, i1, i2, i3, i4, i5; + char card[FLEN_CARD]; + + if (*status > 0) + return(*status); + + maxtilelen = (outfptr->Fptr)->maxtilelen; + + /* + Allocate buffer to hold 1 tile of data; size depends on which compression + algorithm is used: + + Rice and GZIP will compress byte, short, or int arrays without conversion. + PLIO requires 4-byte int values, so byte and short arrays must be converted to int. + HCompress internally converts byte or short values to ints, and + converts int values to 8-byte longlong integers. + */ + + if ((outfptr->Fptr)->zbitpix == FLOAT_IMG) + { + datatype = TFLOAT; + + if ( (outfptr->Fptr)->compress_type == HCOMPRESS_1) { + /* need twice as much scratch space (8 bytes per pixel) */ + tiledata = (double*) malloc (maxtilelen * 2 *sizeof (float)); + } else { + tiledata = (double*) malloc (maxtilelen * sizeof (float)); + } + } + else if ((outfptr->Fptr)->zbitpix == DOUBLE_IMG) + { + datatype = TDOUBLE; + tiledata = (double*) malloc (maxtilelen * sizeof (double)); + } + else if ((outfptr->Fptr)->zbitpix == SHORT_IMG) + { + datatype = TSHORT; + if ( (outfptr->Fptr)->compress_type == RICE_1 || + (outfptr->Fptr)->compress_type == GZIP_1 || + (outfptr->Fptr)->compress_type == GZIP_2 || + (outfptr->Fptr)->compress_type == BZIP2_1 || + (outfptr->Fptr)->compress_type == NOCOMPRESS) { + /* only need buffer of I*2 pixels for gzip, bzip2, and Rice */ + + tiledata = (double*) malloc (maxtilelen * sizeof (short)); + } else { + /* need buffer of I*4 pixels for Hcompress and PLIO */ + tiledata = (double*) malloc (maxtilelen * sizeof (int)); + } + } + else if ((outfptr->Fptr)->zbitpix == BYTE_IMG) + { + + datatype = TBYTE; + if ( (outfptr->Fptr)->compress_type == RICE_1 || + (outfptr->Fptr)->compress_type == BZIP2_1 || + (outfptr->Fptr)->compress_type == GZIP_1 || + (outfptr->Fptr)->compress_type == GZIP_2) { + /* only need buffer of I*1 pixels for gzip, bzip2, and Rice */ + + tiledata = (double*) malloc (maxtilelen); + } else { + /* need buffer of I*4 pixels for Hcompress and PLIO */ + tiledata = (double*) malloc (maxtilelen * sizeof (int)); + } + } + else if ((outfptr->Fptr)->zbitpix == LONG_IMG) + { + datatype = TINT; + if ( (outfptr->Fptr)->compress_type == HCOMPRESS_1) { + /* need twice as much scratch space (8 bytes per pixel) */ + + tiledata = (double*) malloc (maxtilelen * 2 * sizeof (int)); + } else { + /* only need buffer of I*4 pixels for gzip, bzip2, Rice, and PLIO */ + + tiledata = (double*) malloc (maxtilelen * sizeof (int)); + } + } + else + { + ffpmsg("Bad image datatype. (imcomp_compress_image)"); + return (*status = MEMORY_ALLOCATION); + } + + if (tiledata == NULL) + { + ffpmsg("Out of memory. (imcomp_compress_image)"); + return (*status = MEMORY_ALLOCATION); + } + + /* calculate size of tile in each dimension */ + naxis = (outfptr->Fptr)->zndim; + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + if (ii < naxis) + { + naxes[ii] = (outfptr->Fptr)->znaxis[ii]; + tilesize[ii] = (outfptr->Fptr)->tilesize[ii]; + } + else + { + naxes[ii] = 1; + tilesize[ii] = 1; + } + } + row = 1; + + /* set up big loop over up to 6 dimensions */ + for (i5 = 1; i5 <= naxes[5]; i5 += tilesize[5]) + { + fpixel[5] = i5; + lpixel[5] = minvalue(i5 + tilesize[5] - 1, naxes[5]); + tile[5] = lpixel[5] - fpixel[5] + 1; + for (i4 = 1; i4 <= naxes[4]; i4 += tilesize[4]) + { + fpixel[4] = i4; + lpixel[4] = minvalue(i4 + tilesize[4] - 1, naxes[4]); + tile[4] = lpixel[4] - fpixel[4] + 1; + for (i3 = 1; i3 <= naxes[3]; i3 += tilesize[3]) + { + fpixel[3] = i3; + lpixel[3] = minvalue(i3 + tilesize[3] - 1, naxes[3]); + tile[3] = lpixel[3] - fpixel[3] + 1; + for (i2 = 1; i2 <= naxes[2]; i2 += tilesize[2]) + { + fpixel[2] = i2; + lpixel[2] = minvalue(i2 + tilesize[2] - 1, naxes[2]); + tile[2] = lpixel[2] - fpixel[2] + 1; + for (i1 = 1; i1 <= naxes[1]; i1 += tilesize[1]) + { + fpixel[1] = i1; + lpixel[1] = minvalue(i1 + tilesize[1] - 1, naxes[1]); + tile[1] = lpixel[1] - fpixel[1] + 1; + for (i0 = 1; i0 <= naxes[0]; i0 += tilesize[0]) + { + fpixel[0] = i0; + lpixel[0] = minvalue(i0 + tilesize[0] - 1, naxes[0]); + tile[0] = lpixel[0] - fpixel[0] + 1; + + /* number of pixels in this tile */ + tilelen = tile[0]; + for (ii = 1; ii < naxis; ii++) + { + tilelen *= tile[ii]; + } + + /* read next tile of data from image */ + anynul = 0; + if (datatype == TFLOAT) + { + ffgsve(infptr, 1, naxis, naxes, fpixel, lpixel, incre, + FLOATNULLVALUE, (float *) tiledata, &anynul, status); + } + else if (datatype == TDOUBLE) + { + ffgsvd(infptr, 1, naxis, naxes, fpixel, lpixel, incre, + DOUBLENULLVALUE, tiledata, &anynul, status); + } + else if (datatype == TINT) + { + ffgsvk(infptr, 1, naxis, naxes, fpixel, lpixel, incre, + 0, (int *) tiledata, &anynul, status); + } + else if (datatype == TSHORT) + { + ffgsvi(infptr, 1, naxis, naxes, fpixel, lpixel, incre, + 0, (short *) tiledata, &anynul, status); + } + else if (datatype == TBYTE) + { + ffgsvb(infptr, 1, naxis, naxes, fpixel, lpixel, incre, + 0, (unsigned char *) tiledata, &anynul, status); + } + else + { + ffpmsg("Error bad datatype of image tile to compress"); + free(tiledata); + return (*status); + } + + /* now compress the tile, and write to row of binary table */ + /* NOTE: we don't have to worry about the presence of null values in the + array if it is an integer array: the null value is simply encoded + in the compressed array just like any other pixel value. + + If it is a floating point array, then we need to check for null + only if the anynul parameter returned a true value when reading the tile + */ + if (anynul && datatype == TFLOAT) { + imcomp_compress_tile(outfptr, row, datatype, tiledata, tilelen, + tile[0], tile[1], 1, &fltnull, status); + } else if (anynul && datatype == TDOUBLE) { + imcomp_compress_tile(outfptr, row, datatype, tiledata, tilelen, + tile[0], tile[1], 1, &dblnull, status); + } else { + imcomp_compress_tile(outfptr, row, datatype, tiledata, tilelen, + tile[0], tile[1], 0, &dummy, status); + } + + /* set flag if we found any null values */ + if (anynul) + gotnulls = 1; + + /* check for any error in the previous operations */ + if (*status > 0) + { + ffpmsg("Error writing compressed image to table"); + free(tiledata); + return (*status); + } + + row++; + } + } + } + } + } + } + + free (tiledata); /* finished with this buffer */ + + /* insert ZBLANK keyword if necessary; only for TFLOAT or TDOUBLE images */ + if (gotnulls) + { + ffgcrd(outfptr, "ZCMPTYPE", card, status); + ffikyj(outfptr, "ZBLANK", COMPRESS_NULL_VALUE, + "null value in the compressed integer array", status); + } + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_compress_tile (fitsfile *outfptr, + long row, /* tile number = row in the binary table that holds the compressed data */ + int datatype, + void *tiledata, + long tilelen, + long tilenx, + long tileny, + int nullcheck, + void *nullflagval, + int *status) + +/* + This is the main compression routine. + + This routine does the following to the input tile of pixels: + - if it is a float or double image, then it quantizes the pixels + - compresses the integer pixel values + - writes the compressed byte stream to the FITS file. + + If the tile cannot be quantized than the raw float or double values + are losslessly compressed with gzip and then written to the output table. + + This input array may be modified by this routine. If the array is of type TINT + or TFLOAT, and the compression type is HCOMPRESS, then it must have been + allocated to be twice as large (8 bytes per pixel) to provide scratch space. + + Note that this routine does not fully support the implicit datatype conversion that + is supported when writing to normal FITS images. The datatype of the input array + must have the same datatype (either signed or unsigned) as the output (compressed) + FITS image in some cases. +*/ +{ + int *idata; /* quantized integer data */ + int cn_zblank, zbitpix, nullval; + int flag = 1; /* true by default; only = 0 if float data couldn't be quantized */ + int intlength; /* size of integers to be compressed */ + double scale, zero, actual_bzero; + long ii; + size_t clen; /* size of cbuf */ + short *cbuf; /* compressed data */ + int nelem = 0; /* number of bytes */ + size_t gzip_nelem = 0; + unsigned int bzlen; + int ihcompscale; + float hcompscale; + double noise2, noise3, noise5; + double bscale[1] = {1.}, bzero[1] = {0.}; /* scaling parameters */ + long hcomp_len; + LONGLONG *lldata; + + if (*status > 0) + return(*status); + + /* check for special case of losslessly compressing floating point */ + /* images. Only compression algorithm that supports this is GZIP */ + if ( (outfptr->Fptr)->quantize_level == NO_QUANTIZE) { + if (((outfptr->Fptr)->compress_type != GZIP_1) && + ((outfptr->Fptr)->compress_type != GZIP_2)) { + ffpmsg("Lossless compression of floating point images must use GZIP"); + return(*status = DATA_COMPRESSION_ERR); + } + } + + /* free the previously saved tile if the input tile is for the same row */ + if ((outfptr->Fptr)->tilerow == row) { + if ((outfptr->Fptr)->tiledata) { + free((outfptr->Fptr)->tiledata); + } + + if ((outfptr->Fptr)->tilenullarray) { + free((outfptr->Fptr)->tilenullarray); + } + + (outfptr->Fptr)->tiledata = 0; + (outfptr->Fptr)->tilenullarray = 0; + (outfptr->Fptr)->tilerow = 0; + (outfptr->Fptr)->tiledatasize = 0; + (outfptr->Fptr)->tiletype = 0; + } + + if ( (outfptr->Fptr)->compress_type == NOCOMPRESS) { + /* Special case when using NOCOMPRESS for diagnostic purposes in fpack */ + if (imcomp_write_nocompress_tile(outfptr, row, datatype, tiledata, tilelen, + nullcheck, nullflagval, status) > 0) { + return(*status); + } + return(*status); + } + + /* =========================================================================== */ + /* initialize various parameters */ + idata = (int *) tiledata; /* may overwrite the input tiledata in place */ + + /* zbitpix is the BITPIX keyword value in the uncompressed FITS image */ + zbitpix = (outfptr->Fptr)->zbitpix; + + /* if the tile/image has an integer datatype, see if a null value has */ + /* been defined (with the BLANK keyword in a normal FITS image). */ + /* If so, and if the input tile array also contains null pixels, */ + /* (represented by pixels that have a value = nullflagval) then */ + /* any pixels whose value = nullflagval, must be set to the value = nullval */ + /* before the pixel array is compressed. These null pixel values must */ + /* not be inverse scaled by the BSCALE/BZERO values, if present. */ + + cn_zblank = (outfptr->Fptr)->cn_zblank; + nullval = (outfptr->Fptr)->zblank; + + if (zbitpix > 0 && cn_zblank != -1) /* If the integer image has no defined null */ + nullcheck = 0; /* value, then don't bother checking input array for nulls. */ + + /* if the BSCALE and BZERO keywords exist, then the input values must */ + /* be inverse scaled by this factor, before the values are compressed. */ + /* (The program may have turned off scaling, which over rides the keywords) */ + + scale = (outfptr->Fptr)->cn_bscale; + zero = (outfptr->Fptr)->cn_bzero; + actual_bzero = (outfptr->Fptr)->cn_actual_bzero; + + /* =========================================================================== */ + /* prepare the tile of pixel values for compression */ + if (datatype == TSHORT) { + imcomp_convert_tile_tshort(outfptr, tiledata, tilelen, nullcheck, nullflagval, + nullval, zbitpix, scale, zero, actual_bzero, &intlength, status); + } else if (datatype == TUSHORT) { + imcomp_convert_tile_tushort(outfptr, tiledata, tilelen, nullcheck, nullflagval, + nullval, zbitpix, scale, zero, &intlength, status); + } else if (datatype == TBYTE) { + imcomp_convert_tile_tbyte(outfptr, tiledata, tilelen, nullcheck, nullflagval, + nullval, zbitpix, scale, zero, &intlength, status); + } else if (datatype == TSBYTE) { + imcomp_convert_tile_tsbyte(outfptr, tiledata, tilelen, nullcheck, nullflagval, + nullval, zbitpix, scale, zero, &intlength, status); + } else if (datatype == TINT) { + imcomp_convert_tile_tint(outfptr, tiledata, tilelen, nullcheck, nullflagval, + nullval, zbitpix, scale, zero, &intlength, status); + } else if (datatype == TUINT) { + imcomp_convert_tile_tuint(outfptr, tiledata, tilelen, nullcheck, nullflagval, + nullval, zbitpix, scale, zero, &intlength, status); + } else if (datatype == TLONG && sizeof(long) == 8) { + ffpmsg("Integer*8 Long datatype is not supported when writing to compressed images"); + return(*status = BAD_DATATYPE); + } else if (datatype == TULONG && sizeof(long) == 8) { + ffpmsg("Unsigned integer*8 datatype is not supported when writing to compressed images"); + return(*status = BAD_DATATYPE); + } else if (datatype == TFLOAT) { + imcomp_convert_tile_tfloat(outfptr, row, tiledata, tilelen, tilenx, tileny, nullcheck, + nullflagval, nullval, zbitpix, scale, zero, &intlength, &flag, bscale, bzero, status); + } else if (datatype == TDOUBLE) { + imcomp_convert_tile_tdouble(outfptr, row, tiledata, tilelen, tilenx, tileny, nullcheck, + nullflagval, nullval, zbitpix, scale, zero, &intlength, &flag, bscale, bzero, status); + } else { + ffpmsg("unsupported image datatype (imcomp_compress_tile)"); + return(*status = BAD_DATATYPE); + } + + if (*status > 0) + return(*status); /* return if error occurs */ + + /* =========================================================================== */ + if (flag) /* now compress the integer data array */ + { + /* allocate buffer for the compressed tile bytes */ + clen = (outfptr->Fptr)->maxelem; + cbuf = (short *) calloc (clen, sizeof (unsigned char)); + + if (cbuf == NULL) { + ffpmsg("Memory allocation failure. (imcomp_compress_tile)"); + return (*status = MEMORY_ALLOCATION); + } + + /* =========================================================================== */ + if ( (outfptr->Fptr)->compress_type == RICE_1) + { + if (intlength == 2) { + nelem = fits_rcomp_short ((short *)idata, tilelen, (unsigned char *) cbuf, + clen, (outfptr->Fptr)->rice_blocksize); + } else if (intlength == 1) { + nelem = fits_rcomp_byte ((signed char *)idata, tilelen, (unsigned char *) cbuf, + clen, (outfptr->Fptr)->rice_blocksize); + } else { + nelem = fits_rcomp (idata, tilelen, (unsigned char *) cbuf, + clen, (outfptr->Fptr)->rice_blocksize); + } + + if (nelem < 0) /* data compression error condition */ + { + free (cbuf); + ffpmsg("error Rice compressing image tile (imcomp_compress_tile)"); + return (*status = DATA_COMPRESSION_ERR); + } + + /* Write the compressed byte stream. */ + ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1, + nelem, (unsigned char *) cbuf, status); + } + + /* =========================================================================== */ + else if ( (outfptr->Fptr)->compress_type == PLIO_1) + { + for (ii = 0; ii < tilelen; ii++) { + if (idata[ii] < 0 || idata[ii] > 16777215) + { + /* plio algorithn only supports positive 24 bit ints */ + ffpmsg("data out of range for PLIO compression (0 - 2**24)"); + return(*status = DATA_COMPRESSION_ERR); + } + } + + nelem = pl_p2li (idata, 1, cbuf, tilelen); + + if (nelem < 0) /* data compression error condition */ + { + free (cbuf); + ffpmsg("error PLIO compressing image tile (imcomp_compress_tile)"); + return (*status = DATA_COMPRESSION_ERR); + } + + /* Write the compressed byte stream. */ + ffpcli(outfptr, (outfptr->Fptr)->cn_compressed, row, 1, + nelem, cbuf, status); + } + + /* =========================================================================== */ + else if ( ((outfptr->Fptr)->compress_type == GZIP_1) || + ((outfptr->Fptr)->compress_type == GZIP_2) ) { + + if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE && datatype == TFLOAT) { + /* Special case of losslessly compressing floating point pixels with GZIP */ + /* In this case we compress the input tile array directly */ + +#if BYTESWAPPED + ffswap4((int*) tiledata, tilelen); +#endif + if ( (outfptr->Fptr)->compress_type == GZIP_2 ) + fits_shuffle_4bytes((char *) tiledata, tilelen, status); + + compress2mem_from_mem((char *) tiledata, tilelen * sizeof(float), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + + } else if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE && datatype == TDOUBLE) { + /* Special case of losslessly compressing double pixels with GZIP */ + /* In this case we compress the input tile array directly */ + +#if BYTESWAPPED + ffswap8((double *) tiledata, tilelen); +#endif + if ( (outfptr->Fptr)->compress_type == GZIP_2 ) + fits_shuffle_8bytes((char *) tiledata, tilelen, status); + + compress2mem_from_mem((char *) tiledata, tilelen * sizeof(double), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + + } else { + + /* compress the integer idata array */ + +#if BYTESWAPPED + if (intlength == 2) + ffswap2((short *) idata, tilelen); + else if (intlength == 4) + ffswap4(idata, tilelen); +#endif + + if (intlength == 2) { + + if ( (outfptr->Fptr)->compress_type == GZIP_2 ) + fits_shuffle_2bytes((char *) tiledata, tilelen, status); + + compress2mem_from_mem((char *) idata, tilelen * sizeof(short), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + + } else if (intlength == 1) { + + compress2mem_from_mem((char *) idata, tilelen * sizeof(unsigned char), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + + } else { + + if ( (outfptr->Fptr)->compress_type == GZIP_2 ) + fits_shuffle_4bytes((char *) tiledata, tilelen, status); + + compress2mem_from_mem((char *) idata, tilelen * sizeof(int), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + } + } + + /* Write the compressed byte stream. */ + ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1, + gzip_nelem, (unsigned char *) cbuf, status); + + /* =========================================================================== */ + } else if ( (outfptr->Fptr)->compress_type == BZIP2_1) { + +#if BYTESWAPPED + if (intlength == 2) + ffswap2((short *) idata, tilelen); + else if (intlength == 4) + ffswap4(idata, tilelen); +#endif + + bzlen = (unsigned int) clen; + + /* call bzip2 with blocksize = 900K, verbosity = 0, and default workfactor */ + +/* bzip2 is not supported in the public release. This is only for test purposes. + if (BZ2_bzBuffToBuffCompress( (char *) cbuf, &bzlen, + (char *) idata, (unsigned int) (tilelen * intlength), 9, 0, 0) ) +*/ + { + ffpmsg("bzip2 compression error"); + return(*status = DATA_COMPRESSION_ERR); + } + + /* Write the compressed byte stream. */ + ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1, + bzlen, (unsigned char *) cbuf, status); + + /* =========================================================================== */ + } else if ( (outfptr->Fptr)->compress_type == HCOMPRESS_1) { + /* + if hcompscale is positive, then we have to multiply + the value by the RMS background noise to get the + absolute scale value. If negative, then it gives the + absolute scale value directly. + */ + hcompscale = (outfptr->Fptr)->hcomp_scale; + + if (hcompscale > 0.) { + fits_img_stats_int(idata, tilenx, tileny, nullcheck, + nullval, 0,0,0,0,0,0,&noise2,&noise3,&noise5,status); + + /* use the minimum of the 3 noise estimates */ + if (noise2 != 0. && noise2 < noise3) noise3 = noise2; + if (noise5 != 0. && noise5 < noise3) noise3 = noise5; + + hcompscale = (float) (hcompscale * noise3); + + } else if (hcompscale < 0.) { + + hcompscale = hcompscale * -1.0F; + } + + ihcompscale = (int) (hcompscale + 0.5); + + hcomp_len = clen; /* allocated size of the buffer */ + + if (zbitpix == BYTE_IMG || zbitpix == SHORT_IMG) { + fits_hcompress(idata, tilenx, tileny, + ihcompscale, (char *) cbuf, &hcomp_len, status); + + } else { + /* have to convert idata to an I*8 array, in place */ + /* idata must have been allocated large enough to do this */ + lldata = (LONGLONG *) idata; + + for (ii = tilelen - 1; ii >= 0; ii--) { + lldata[ii] = idata[ii]; + } + + fits_hcompress64(lldata, tilenx, tileny, + ihcompscale, (char *) cbuf, &hcomp_len, status); + } + + /* Write the compressed byte stream. */ + ffpclb(outfptr, (outfptr->Fptr)->cn_compressed, row, 1, + hcomp_len, (unsigned char *) cbuf, status); + } + + /* =========================================================================== */ + if ((outfptr->Fptr)->cn_zscale > 0) + { + /* write the linear scaling parameters for this tile */ + ffpcld (outfptr, (outfptr->Fptr)->cn_zscale, row, 1, 1, + bscale, status); + ffpcld (outfptr, (outfptr->Fptr)->cn_zzero, row, 1, 1, + bzero, status); + } + + free(cbuf); /* finished with this buffer */ + + /* =========================================================================== */ + } else { /* if flag == 0., floating point data couldn't be quantized */ + + /* losslessly compress the data with gzip. */ + + /* if gzip2 compressed data column doesn't exist, create it */ + if ((outfptr->Fptr)->cn_gzip_data < 1) { + fits_insert_col(outfptr, 999, "GZIP_COMPRESSED_DATA", "1PB", status); + + if (*status <= 0) /* save the number of this column */ + ffgcno(outfptr, CASEINSEN, "GZIP_COMPRESSED_DATA", + &(outfptr->Fptr)->cn_gzip_data, status); + } + + if (datatype == TFLOAT) { + /* allocate buffer for the compressed tile bytes */ + /* make it 10% larger than the original uncompressed data */ + clen = tilelen * sizeof(float) * 1.1; + cbuf = (short *) calloc (clen, sizeof (unsigned char)); + + if (cbuf == NULL) + { + ffpmsg("Memory allocation error. (imcomp_compress_tile)"); + return (*status = MEMORY_ALLOCATION); + } + + /* convert null values to NaNs in place, if necessary */ + if (nullcheck == 1) { + imcomp_float2nan((float *) tiledata, tilelen, (int *) tiledata, + *(float *) (nullflagval), status); + } + +#if BYTESWAPPED + ffswap4((int*) tiledata, tilelen); +#endif + compress2mem_from_mem((char *) tiledata, tilelen * sizeof(float), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + + } else if (datatype == TDOUBLE) { + + /* allocate buffer for the compressed tile bytes */ + /* make it 10% larger than the original uncompressed data */ + clen = tilelen * sizeof(double) * 1.1; + cbuf = (short *) calloc (clen, sizeof (unsigned char)); + + if (cbuf == NULL) + { + ffpmsg("Memory allocation error. (imcomp_compress_tile)"); + return (*status = MEMORY_ALLOCATION); + } + + /* convert null values to NaNs in place, if necessary */ + if (nullcheck == 1) { + imcomp_double2nan((double *) tiledata, tilelen, (LONGLONG *) tiledata, + *(double *) (nullflagval), status); + } + +#if BYTESWAPPED + ffswap8((double*) tiledata, tilelen); +#endif + compress2mem_from_mem((char *) tiledata, tilelen * sizeof(double), + (char **) &cbuf, &clen, realloc, &gzip_nelem, status); + } + + /* Write the compressed byte stream. */ + ffpclb(outfptr, (outfptr->Fptr)->cn_gzip_data, row, 1, + gzip_nelem, (unsigned char *) cbuf, status); + + free(cbuf); /* finished with this buffer */ + } + + return(*status); +} + +/*--------------------------------------------------------------------------*/ +int imcomp_write_nocompress_tile(fitsfile *outfptr, + long row, + int datatype, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int *status) +{ + char coltype[4]; + + /* Write the uncompressed image tile pixels to the tile-compressed image file. */ + /* This is a special case when using NOCOMPRESS for diagnostic purposes in fpack. */ + /* Currently, this only supports a limited number of data types and */ + /* does not fully support null-valued pixels in the image. */ + + if ((outfptr->Fptr)->cn_uncompressed < 1) { + /* uncompressed data column doesn't exist, so append new column to table */ + if (datatype == TSHORT) { + strcpy(coltype, "1PI"); + } else if (datatype == TINT) { + strcpy(coltype, "1PJ"); + } else if (datatype == TFLOAT) { + strcpy(coltype, "1PE"); + } else { + ffpmsg("NOCOMPRESSION option only supported for int*2, int*4, and float*4 images"); + return(*status = DATA_COMPRESSION_ERR); + } + + fits_insert_col(outfptr, 999, "UNCOMPRESSED_DATA", coltype, status); /* create column */ + } + + fits_get_colnum(outfptr, CASEINSEN, "UNCOMPRESSED_DATA", + &(outfptr->Fptr)->cn_uncompressed, status); /* save col. num. */ + + fits_write_col(outfptr, datatype, (outfptr->Fptr)->cn_uncompressed, row, 1, + tilelen, tiledata, status); /* write the tile data */ + return (*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tshort( + fitsfile *outfptr, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + double actual_bzero, + int *intlength, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + short *sbuff; + int flagval, *idata; + long ii; + + /* We only support writing this integer*2 tile data to a FITS image with + BITPIX = 16 and with BZERO = 0 and BSCALE = 1. */ + + if (zbitpix != SHORT_IMG || scale != 1.0 || zero != 0.0) { + ffpmsg("Datatype conversion/scaling is not supported when writing to compressed images"); + return(*status = DATA_COMPRESSION_ERR); + } + + sbuff = (short *) tiledata; + idata = (int *) tiledata; + + if ( (outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1 + || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1 ) + { + /* don't have to convert to int if using gzip, bzip2 or Rice compression */ + *intlength = 2; + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(short *) (nullflagval); + if (flagval != nullval) { + for (ii = tilelen - 1; ii >= 0; ii--) { + if (sbuff[ii] == (short) flagval) + sbuff[ii] = (short) nullval; + } + } + } + } else if ((outfptr->Fptr)->compress_type == HCOMPRESS_1) { + /* have to convert to int if using HCOMPRESS */ + *intlength = 4; + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(short *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (sbuff[ii] == (short) flagval) + idata[ii] = nullval; + else + idata[ii] = (int) sbuff[ii]; + } + } else { /* just do the data type conversion to int */ + for (ii = tilelen - 1; ii >= 0; ii--) + idata[ii] = (int) sbuff[ii]; + } + } else { + /* have to convert to int if using PLIO */ + *intlength = 4; + if (zero == 0. && actual_bzero == 32768.) { + /* Here we are compressing unsigned 16-bit integers that have */ + /* been offset by -32768 using the standard FITS convention. */ + /* Since PLIO cannot deal with negative values, we must apply */ + /* the shift of 32786 to the values to make them all positive. */ + /* The inverse negative shift will be applied in */ + /* imcomp_decompress_tile when reading the compressed tile. */ + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(short *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (sbuff[ii] == (short) flagval) + idata[ii] = nullval; + else + idata[ii] = (int) sbuff[ii] + 32768; + } + } else { /* just do the data type conversion to int */ + for (ii = tilelen - 1; ii >= 0; ii--) + idata[ii] = (int) sbuff[ii] + 32768; + } + } else { + /* This is not an unsigned 16-bit integer array, so process normally */ + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(short *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (sbuff[ii] == (short) flagval) + idata[ii] = nullval; + else + idata[ii] = (int) sbuff[ii]; + } + } else { /* just do the data type conversion to int */ + for (ii = tilelen - 1; ii >= 0; ii--) + idata[ii] = (int) sbuff[ii]; + } + } + } + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tushort( + fitsfile *outfptr, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + unsigned short *usbuff; + short *sbuff; + int flagval, *idata; + long ii; + + /* datatype of input array is unsigned short. We only support writing this datatype + to a FITS image with BITPIX = 16 and with BZERO = 0 and BSCALE = 32768. */ + + if (zbitpix != SHORT_IMG || scale != 1.0 || zero != 32768.) { + ffpmsg("Implicit datatype conversion is not supported when writing to compressed images"); + return(*status = DATA_COMPRESSION_ERR); + } + + usbuff = (unsigned short *) tiledata; + sbuff = (short *) tiledata; + idata = (int *) tiledata; + + if ((outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1 + || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1) + { + /* don't have to convert to int if using gzip, bzip2, or Rice compression */ + *intlength = 2; + + /* offset the unsigned value by -32768 to a signed short value. */ + /* It is more efficient to do this by just flipping the most significant of the 16 bits */ + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(unsigned short *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (usbuff[ii] == (unsigned short) flagval) + sbuff[ii] = (short) nullval; + else + usbuff[ii] = (usbuff[ii]) ^ 0x8000; + } + } else { + /* just offset the pixel values by 32768 (by flipping the MSB */ + for (ii = tilelen - 1; ii >= 0; ii--) + usbuff[ii] = (usbuff[ii]) ^ 0x8000; + } + } else { + /* have to convert to int if using HCOMPRESS or PLIO */ + *intlength = 4; + + if (nullcheck == 1) { + /* offset the pixel values by 32768, and */ + /* reset pixels equal to flagval to nullval */ + flagval = *(unsigned short *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (usbuff[ii] == (unsigned short) flagval) + idata[ii] = nullval; + else + idata[ii] = ((int) usbuff[ii]) - 32768; + } + } else { /* just do the data type conversion to int */ + for (ii = tilelen - 1; ii >= 0; ii--) + idata[ii] = ((int) usbuff[ii]) - 32768; + } + } + + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tint( + fitsfile *outfptr, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + int flagval, *idata; + long ii; + + + /* datatype of input array is int. We only support writing this datatype + to a FITS image with BITPIX = 32 and with BZERO = 0 and BSCALE = 1. */ + + if (zbitpix != LONG_IMG || scale != 1.0 || zero != 0.) { + ffpmsg("Implicit datatype conversion is not supported when writing to compressed images"); + return(*status = DATA_COMPRESSION_ERR); + } + + idata = (int *) tiledata; + *intlength = 4; + + if (nullcheck == 1) { + /* no datatype conversion is required for any of the compression algorithms, + except possibly for HCOMPRESS (to I*8), which is handled later. + Just reset pixels equal to flagval to the FITS null value */ + flagval = *(int *) (nullflagval); + if (flagval != nullval) { + for (ii = tilelen - 1; ii >= 0; ii--) { + if (idata[ii] == flagval) + idata[ii] = nullval; + } + } + } + + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tuint( + fitsfile *outfptr, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + int flagval, *idata; + unsigned int *uintbuff, uintflagval; + long ii; + + + /* datatype of input array is unsigned int. We only support writing this datatype + to a FITS image with BITPIX = 32 and with BZERO = 0 and BSCALE = 2147483648. */ + + if (zbitpix != LONG_IMG || scale != 1.0 || zero != 2147483648.) { + ffpmsg("Implicit datatype conversion is not supported when writing to compressed images"); + return(*status = DATA_COMPRESSION_ERR); + } + + *intlength = 4; + idata = (int *) tiledata; + uintbuff = (unsigned int *) tiledata; + + /* offset the unsigned value by -2147483648 to a signed int value. */ + /* It is more efficient to do this by just flipping the most significant of the 32 bits */ + + if (nullcheck == 1) { + /* reset pixels equal to flagval to nullval and */ + /* offset the other pixel values (by flipping the MSB) */ + uintflagval = *(unsigned int *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (uintbuff[ii] == uintflagval) + idata[ii] = nullval; + else + uintbuff[ii] = (uintbuff[ii]) ^ 0x80000000; + } + } else { + /* just offset the pixel values (by flipping the MSB) */ + for (ii = tilelen - 1; ii >= 0; ii--) + uintbuff[ii] = (uintbuff[ii]) ^ 0x80000000; + } + + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tbyte( + fitsfile *outfptr, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + int flagval, *idata; + long ii; + unsigned char *usbbuff; + + /* datatype of input array is unsigned byte. We only support writing this datatype + to a FITS image with BITPIX = 8 and with BZERO = 0 and BSCALE = 1. */ + + if (zbitpix != BYTE_IMG || scale != 1.0 || zero != 0.) { + ffpmsg("Implicit datatype conversion is not supported when writing to compressed images"); + return(*status = DATA_COMPRESSION_ERR); + } + + idata = (int *) tiledata; + usbbuff = (unsigned char *) tiledata; + + if ( (outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1 + || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1 ) + { + /* don't have to convert to int if using gzip, bzip2, or Rice compression */ + *intlength = 1; + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(unsigned char *) (nullflagval); + if (flagval != nullval) { + for (ii = tilelen - 1; ii >= 0; ii--) { + if (usbbuff[ii] == (unsigned char) flagval) + usbbuff[ii] = (unsigned char) nullval; + } + } + } + } else { + /* have to convert to int if using HCOMPRESS or PLIO */ + *intlength = 4; + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(unsigned char *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (usbbuff[ii] == (unsigned char) flagval) + idata[ii] = nullval; + else + idata[ii] = (int) usbbuff[ii]; + } + } else { /* just do the data type conversion to int */ + for (ii = tilelen - 1; ii >= 0; ii--) + idata[ii] = (int) usbbuff[ii]; + } + } + + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tsbyte( + fitsfile *outfptr, + void *tiledata, + long tilelen, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + int flagval, *idata; + long ii; + signed char *sbbuff; + + /* datatype of input array is signed byte. We only support writing this datatype + to a FITS image with BITPIX = 8 and with BZERO = 0 and BSCALE = -128. */ + + if (zbitpix != BYTE_IMG|| scale != 1.0 || zero != -128.) { + ffpmsg("Implicit datatype conversion is not supported when writing to compressed images"); + return(*status = DATA_COMPRESSION_ERR); + } + + idata = (int *) tiledata; + sbbuff = (signed char *) tiledata; + + if ( (outfptr->Fptr)->compress_type == RICE_1 || (outfptr->Fptr)->compress_type == GZIP_1 + || (outfptr->Fptr)->compress_type == GZIP_2 || (outfptr->Fptr)->compress_type == BZIP2_1 ) + { + /* don't have to convert to int if using gzip, bzip2 or Rice compression */ + *intlength = 1; + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + /* offset the other pixel values (by flipping the MSB) */ + + flagval = *(signed char *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (sbbuff[ii] == (signed char) flagval) + sbbuff[ii] = (signed char) nullval; + else + sbbuff[ii] = (sbbuff[ii]) ^ 0x80; } + } else { /* just offset the pixel values (by flipping the MSB) */ + for (ii = tilelen - 1; ii >= 0; ii--) + sbbuff[ii] = (sbbuff[ii]) ^ 0x80; + } + + } else { + /* have to convert to int if using HCOMPRESS or PLIO */ + *intlength = 4; + + if (nullcheck == 1) { + /* reset pixels equal to flagval to the FITS null value, prior to compression */ + flagval = *(signed char *) (nullflagval); + for (ii = tilelen - 1; ii >= 0; ii--) { + if (sbbuff[ii] == (signed char) flagval) + idata[ii] = nullval; + else + idata[ii] = ((int) sbbuff[ii]) + 128; + } + } else { /* just do the data type conversion to int */ + for (ii = tilelen - 1; ii >= 0; ii--) + idata[ii] = ((int) sbbuff[ii]) + 128; + } + } + + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tfloat( + fitsfile *outfptr, + long row, + void *tiledata, + long tilelen, + long tilenx, + long tileny, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *flag, + double *bscale, + double *bzero, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + int flagval, *idata; + long irow, ii; + float floatnull; + unsigned char *usbbuff; + unsigned long dithersum; + int iminval = 0, imaxval = 0; /* min and max quantized integers */ + + *intlength = 4; + idata = (int *) tiledata; + + /* if the tile-compressed table contains zscale and zzero columns */ + /* then scale and quantize the input floating point data. */ + + if ((outfptr->Fptr)->cn_zscale > 0) { + /* quantize the float values into integers */ + + if (nullcheck == 1) + floatnull = *(float *) (nullflagval); + else + floatnull = FLOATNULLVALUE; /* NaNs are represented by this, by default */ + + if ((outfptr->Fptr)->quantize_dither == SUBTRACTIVE_DITHER_1) { + + /* see if the dithering offset value needs to be initialized */ + if ((outfptr->Fptr)->request_dither_offset == 0 && (outfptr->Fptr)->dither_offset == 0) { + + /* This means randomly choose the dithering offset based on the system time. */ + /* The offset will have a value between 1 and 10000, inclusive. */ + /* The time function returns an integer value that is incremented each second. */ + /* The clock function returns the elapsed CPU time, in integer CLOCKS_PER_SEC units. */ + /* The CPU time returned by clock is typically (on linux PC) only good to 0.01 sec */ + /* Summing the 2 quantities may help avoid cases where 2 executions of the program */ + /* (perhaps in a multithreaded environoment) end up with exactly the same dither_offset */ + /* value. The sum is incremented by the current HDU number in the file to provide */ + /* further randomization. This randomization is desireable if multiple compressed */ + /* images will be summed (or differenced). In such cases, the benefits of dithering */ + /* may be lost if all the images use exactly the same sequence of random numbers when */ + /* calculating the dithering offsets. */ + + (outfptr->Fptr)->dither_offset = + (( (int)time(NULL) + ( (int) clock() / (int) (CLOCKS_PER_SEC / 100)) + (outfptr->Fptr)->curhdu) % 10000) + 1; + + /* update the header keyword with this new value */ + fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_offset), + NULL, status); + + } else if ((outfptr->Fptr)->request_dither_offset < 0 && (outfptr->Fptr)->dither_offset < 0) { + + /* this means randomly choose the dithering offset based on some hash function */ + /* of the first input tile of data to be quantized and compressed. This ensures that */ + /* the same offset value is used for a given image every time it is compressed. */ + + usbbuff = (unsigned char *) tiledata; + dithersum = 0; + for (ii = 0; ii < 4 * tilelen; ii++) { + dithersum += usbbuff[ii]; /* doesn't matter if there is an integer overflow */ + } + (outfptr->Fptr)->dither_offset = ((int) (dithersum % 10000)) + 1; + + /* update the header keyword with this new value */ + fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_offset), + NULL, status); + } + + /* subtract 1 to convert from 1-based to 0-based element number */ + irow = row + (outfptr->Fptr)->dither_offset - 1; /* dither the quantized values */ + + } else { + irow = 0; /* do not dither the quantized values */ + } + + *flag = fits_quantize_float (irow, (float *) tiledata, tilenx, tileny, + nullcheck, floatnull, (outfptr->Fptr)->quantize_level, idata, + bscale, bzero, &iminval, &imaxval); + + if (*flag > 1) + return(*status = *flag); + } + else if ((outfptr->Fptr)->quantize_level != NO_QUANTIZE) + { + /* if floating point pixels are not being losslessly compressed, then */ + /* input float data is implicitly converted (truncated) to integers */ + if ((scale != 1. || zero != 0.)) /* must scale the values */ + imcomp_nullscalefloats((float *) tiledata, tilelen, idata, scale, zero, + nullcheck, *(float *) (nullflagval), nullval, status); + else + imcomp_nullfloats((float *) tiledata, tilelen, idata, + nullcheck, *(float *) (nullflagval), nullval, status); + } + else if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE) + { + /* just convert null values to NaNs in place, if necessary, then do lossless gzip compression */ + if (nullcheck == 1) { + imcomp_float2nan((float *) tiledata, tilelen, (int *) tiledata, + *(float *) (nullflagval), status); + } + } + + return(*status); +} + /*--------------------------------------------------------------------------*/ +int imcomp_convert_tile_tdouble( + fitsfile *outfptr, + long row, + void *tiledata, + long tilelen, + long tilenx, + long tileny, + int nullcheck, + void *nullflagval, + int nullval, + int zbitpix, + double scale, + double zero, + int *intlength, + int *flag, + double *bscale, + double *bzero, + int *status) +{ + /* Prepare the input tile array of pixels for compression. + /* Convert input integer*2 tile array in place to 4 or 8-byte ints for compression, */ + /* If needed, convert 4 or 8-byte ints and do null value substitution. */ + /* Note that the calling routine must have allocated the input array big enough */ + /* to be able to do this. */ + + int flagval, *idata; + long irow, ii; + double doublenull; + unsigned char *usbbuff; + unsigned long dithersum; + int iminval = 0, imaxval = 0; /* min and max quantized integers */ + + *intlength = 4; + idata = (int *) tiledata; + + /* if the tile-compressed table contains zscale and zzero columns */ + /* then scale and quantize the input floating point data. */ + /* Otherwise, just truncate the floats to integers. */ + + if ((outfptr->Fptr)->cn_zscale > 0) + { + if (nullcheck == 1) + doublenull = *(double *) (nullflagval); + else + doublenull = DOUBLENULLVALUE; + + /* quantize the double values into integers */ + if ((outfptr->Fptr)->quantize_dither == SUBTRACTIVE_DITHER_1) { + + /* see if the dithering offset value needs to be initialized (see above) */ + if ((outfptr->Fptr)->request_dither_offset == 0 && (outfptr->Fptr)->dither_offset == 0) { + + (outfptr->Fptr)->dither_offset = + (( (int)time(NULL) + ( (int) clock() / (int) (CLOCKS_PER_SEC / 100)) + (outfptr->Fptr)->curhdu) % 10000) + 1; + + /* update the header keyword with this new value */ + fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_offset), + NULL, status); + + } else if ((outfptr->Fptr)->request_dither_offset < 0 && (outfptr->Fptr)->dither_offset < 0) { + + usbbuff = (unsigned char *) tiledata; + dithersum = 0; + for (ii = 0; ii < 8 * tilelen; ii++) { + dithersum += usbbuff[ii]; + } + (outfptr->Fptr)->dither_offset = ((int) (dithersum % 10000)) + 1; + + /* update the header keyword with this new value */ + fits_update_key(outfptr, TINT, "ZDITHER0", &((outfptr->Fptr)->dither_offset), + NULL, status); + } + + irow = row + (outfptr->Fptr)->dither_offset - 1; /* dither the quantized values */ + + } else { + irow = 0; /* do not dither the quantized values */ + } + + *flag = fits_quantize_double (irow, (double *) tiledata, tilenx, tileny, + nullcheck, doublenull, (outfptr->Fptr)->quantize_level, idata, + bscale, bzero, &iminval, &imaxval); + + if (*flag > 1) + return(*status = *flag); + } + else if ((outfptr->Fptr)->quantize_level != NO_QUANTIZE) + { + /* if floating point pixels are not being losslessly compressed, then */ + /* input float data is implicitly converted (truncated) to integers */ + if ((scale != 1. || zero != 0.)) /* must scale the values */ + imcomp_nullscaledoubles((double *) tiledata, tilelen, idata, scale, zero, + nullcheck, *(double *) (nullflagval), nullval, status); + else + imcomp_nulldoubles((double *) tiledata, tilelen, idata, + nullcheck, *(double *) (nullflagval), nullval, status); + } + else if ((outfptr->Fptr)->quantize_level == NO_QUANTIZE) + { + /* just convert null values to NaNs in place, if necessary, then do lossless gzip compression */ + if (nullcheck == 1) { + imcomp_double2nan((double *) tiledata, tilelen, (LONGLONG *) tiledata, + *(double *) (nullflagval), status); + } + } + + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullscale( + int *idata, + long tilelen, + int nullflagval, + int nullval, + double scale, + double zero, + int *status) +/* + do null value substitution AND scaling of the integer array. + If array value = nullflagval, then set the value to nullval. + Otherwise, inverse scale the integer value. +*/ +{ + long ii; + double dvalue; + + for (ii=0; ii < tilelen; ii++) + { + if (idata[ii] == nullflagval) + idata[ii] = nullval; + else + { + dvalue = (idata[ii] - zero) / scale; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullvalues( + int *idata, + long tilelen, + int nullflagval, + int nullval, + int *status) +/* + do null value substitution. + If array value = nullflagval, then set the value to nullval. +*/ +{ + long ii; + + for (ii=0; ii < tilelen; ii++) + { + if (idata[ii] == nullflagval) + idata[ii] = nullval; + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_scalevalues( + int *idata, + long tilelen, + double scale, + double zero, + int *status) +/* + do inverse scaling the integer values. +*/ +{ + long ii; + double dvalue; + + for (ii=0; ii < tilelen; ii++) + { + dvalue = (idata[ii] - zero) / scale; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullscalei2( + short *idata, + long tilelen, + short nullflagval, + short nullval, + double scale, + double zero, + int *status) +/* + do null value substitution AND scaling of the integer array. + If array value = nullflagval, then set the value to nullval. + Otherwise, inverse scale the integer value. +*/ +{ + long ii; + double dvalue; + + for (ii=0; ii < tilelen; ii++) + { + if (idata[ii] == nullflagval) + idata[ii] = nullval; + else + { + dvalue = (idata[ii] - zero) / scale; + + if (dvalue < DSHRT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = SHRT_MIN; + } + else if (dvalue > DSHRT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = SHRT_MAX; + } + else + { + if (dvalue >= 0) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullvaluesi2( + short *idata, + long tilelen, + short nullflagval, + short nullval, + int *status) +/* + do null value substitution. + If array value = nullflagval, then set the value to nullval. +*/ +{ + long ii; + + for (ii=0; ii < tilelen; ii++) + { + if (idata[ii] == nullflagval) + idata[ii] = nullval; + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_scalevaluesi2( + short *idata, + long tilelen, + double scale, + double zero, + int *status) +/* + do inverse scaling the integer values. +*/ +{ + long ii; + double dvalue; + + for (ii=0; ii < tilelen; ii++) + { + dvalue = (idata[ii] - zero) / scale; + + if (dvalue < DSHRT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = SHRT_MIN; + } + else if (dvalue > DSHRT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = SHRT_MAX; + } + else + { + if (dvalue >= 0) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullfloats( + float *fdata, + long tilelen, + int *idata, + int nullcheck, + float nullflagval, + int nullval, + int *status) +/* + do null value substitution of the float array. + If array value = nullflagval, then set the output value to FLOATNULLVALUE. +*/ +{ + long ii; + double dvalue; + + if (nullcheck == 1) /* must check for null values */ + { + for (ii=0; ii < tilelen; ii++) + { + if (fdata[ii] == nullflagval) + idata[ii] = nullval; + else + { + dvalue = fdata[ii]; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + } + else /* don't have to worry about null values */ + { + for (ii=0; ii < tilelen; ii++) + { + dvalue = fdata[ii]; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullscalefloats( + float *fdata, + long tilelen, + int *idata, + double scale, + double zero, + int nullcheck, + float nullflagval, + int nullval, + int *status) +/* + do null value substitution of the float array. + If array value = nullflagval, then set the output value to FLOATNULLVALUE. + Otherwise, inverse scale the integer value. +*/ +{ + long ii; + double dvalue; + + if (nullcheck == 1) /* must check for null values */ + { + for (ii=0; ii < tilelen; ii++) + { + if (fdata[ii] == nullflagval) + idata[ii] = nullval; + else + { + dvalue = (fdata[ii] - zero) / scale; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0.) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + } + else /* don't have to worry about null values */ + { + for (ii=0; ii < tilelen; ii++) + { + dvalue = (fdata[ii] - zero) / scale; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0.) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nulldoubles( + double *fdata, + long tilelen, + int *idata, + int nullcheck, + double nullflagval, + int nullval, + int *status) +/* + do null value substitution of the float array. + If array value = nullflagval, then set the output value to FLOATNULLVALUE. + Otherwise, inverse scale the integer value. +*/ +{ + long ii; + double dvalue; + + if (nullcheck == 1) /* must check for null values */ + { + for (ii=0; ii < tilelen; ii++) + { + if (fdata[ii] == nullflagval) + idata[ii] = nullval; + else + { + dvalue = fdata[ii]; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0.) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + } + else /* don't have to worry about null values */ + { + for (ii=0; ii < tilelen; ii++) + { + dvalue = fdata[ii]; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0.) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int imcomp_nullscaledoubles( + double *fdata, + long tilelen, + int *idata, + double scale, + double zero, + int nullcheck, + double nullflagval, + int nullval, + int *status) +/* + do null value substitution of the float array. + If array value = nullflagval, then set the output value to FLOATNULLVALUE. + Otherwise, inverse scale the integer value. +*/ +{ + long ii; + double dvalue; + + if (nullcheck == 1) /* must check for null values */ + { + for (ii=0; ii < tilelen; ii++) + { + if (fdata[ii] == nullflagval) + idata[ii] = nullval; + else + { + dvalue = (fdata[ii] - zero) / scale; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0.) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + } + else /* don't have to worry about null values */ + { + for (ii=0; ii < tilelen; ii++) + { + dvalue = (fdata[ii] - zero) / scale; + + if (dvalue < DINT_MIN) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MIN; + } + else if (dvalue > DINT_MAX) + { + *status = OVERFLOW_ERR; + idata[ii] = INT32_MAX; + } + else + { + if (dvalue >= 0.) + idata[ii] = (int) (dvalue + .5); + else + idata[ii] = (int) (dvalue - .5); + } + } + } + return(*status); +} +/*---------------------------------------------------------------------------*/ +int fits_write_compressed_img(fitsfile *fptr, /* I - FITS file pointer */ + int datatype, /* I - datatype of the array to be written */ + long *infpixel, /* I - 'bottom left corner' of the subsection */ + long *inlpixel, /* I - 'top right corner' of the subsection */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: pixels that are = nullval will be */ + /* written with the FITS null pixel value */ + /* (floating point arrays only) */ + void *array, /* I - array of values to be written */ + void *nullval, /* I - undefined pixel value */ + int *status) /* IO - error status */ +/* + Write a section of a compressed image. +*/ +{ + int naxis[MAX_COMPRESS_DIM], tiledim[MAX_COMPRESS_DIM]; + long tilesize[MAX_COMPRESS_DIM], thistilesize[MAX_COMPRESS_DIM]; + long ftile[MAX_COMPRESS_DIM], ltile[MAX_COMPRESS_DIM]; + long tfpixel[MAX_COMPRESS_DIM], tlpixel[MAX_COMPRESS_DIM]; + long rowdim[MAX_COMPRESS_DIM], offset[MAX_COMPRESS_DIM],ntemp; + long fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM]; + int ii, i5, i4, i3, i2, i1, i0, ndim, irow, pixlen, tilenul; + int tstatus, buffpixsiz; + void *buffer; + char *bnullarray = 0, card[FLEN_CARD]; + + if (*status > 0) + return(*status); + + if (!fits_is_compressed_image(fptr, status) ) + { + ffpmsg("CHDU is not a compressed image (fits_write_compressed_img)"); + return(*status = DATA_COMPRESSION_ERR); + } + + /* reset position to the correct HDU if necessary */ + if (fptr->HDUposition != (fptr->Fptr)->curhdu) + ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status); + + /* rescan header if data structure is undefined */ + else if ((fptr->Fptr)->datastart == DATA_UNDEFINED) + if ( ffrdef(fptr, status) > 0) + return(*status); + + + /* ===================================================================== */ + + + if (datatype == TSHORT || datatype == TUSHORT) + { + pixlen = sizeof(short); + } + else if (datatype == TINT || datatype == TUINT) + { + pixlen = sizeof(int); + } + else if (datatype == TBYTE || datatype == TSBYTE) + { + pixlen = 1; + } + else if (datatype == TLONG || datatype == TULONG) + { + pixlen = sizeof(long); + } + else if (datatype == TFLOAT) + { + pixlen = sizeof(float); + } + else if (datatype == TDOUBLE) + { + pixlen = sizeof(double); + } + else + { + ffpmsg("unsupported datatype for compressing image"); + return(*status = BAD_DATATYPE); + } + + /* ===================================================================== */ + + /* allocate scratch space for processing one tile of the image */ + buffpixsiz = pixlen; /* this is the minimum pixel size */ + + if ( (fptr->Fptr)->compress_type == HCOMPRESS_1) { /* need 4 or 8 bytes per pixel */ + if ((fptr->Fptr)->zbitpix == BYTE_IMG || + (fptr->Fptr)->zbitpix == SHORT_IMG ) + buffpixsiz = maxvalue(buffpixsiz, 4); + else + buffpixsiz = 8; + } + else if ( (fptr->Fptr)->compress_type == PLIO_1) { /* need 4 bytes per pixel */ + buffpixsiz = maxvalue(buffpixsiz, 4); + } + else if ( (fptr->Fptr)->compress_type == RICE_1 || + (fptr->Fptr)->compress_type == GZIP_1 || + (fptr->Fptr)->compress_type == GZIP_2 || + (fptr->Fptr)->compress_type == BZIP2_1) { /* need 1, 2, or 4 bytes per pixel */ + if ((fptr->Fptr)->zbitpix == BYTE_IMG) + buffpixsiz = maxvalue(buffpixsiz, 1); + else if ((fptr->Fptr)->zbitpix == SHORT_IMG) + buffpixsiz = maxvalue(buffpixsiz, 2); + else + buffpixsiz = maxvalue(buffpixsiz, 4); + } + else + { + ffpmsg("unsupported image compression algorithm"); + return(*status = BAD_DATATYPE); + } + + /* cast to double to force alignment on 8-byte addresses */ + buffer = (double *) calloc ((fptr->Fptr)->maxtilelen, buffpixsiz); + + if (buffer == NULL) + { + ffpmsg("Out of memory (fits_write_compress_img)"); + return (*status = MEMORY_ALLOCATION); + } + + /* ===================================================================== */ + + /* initialize all the arrays */ + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + naxis[ii] = 1; + tiledim[ii] = 1; + tilesize[ii] = 1; + ftile[ii] = 1; + ltile[ii] = 1; + rowdim[ii] = 1; + } + + ndim = (fptr->Fptr)->zndim; + ntemp = 1; + for (ii = 0; ii < ndim; ii++) + { + fpixel[ii] = infpixel[ii]; + lpixel[ii] = inlpixel[ii]; + + /* calc number of tiles in each dimension, and tile containing */ + /* the first and last pixel we want to read in each dimension */ + naxis[ii] = (fptr->Fptr)->znaxis[ii]; + if (fpixel[ii] < 1) + { + free(buffer); + return(*status = BAD_PIX_NUM); + } + + tilesize[ii] = (fptr->Fptr)->tilesize[ii]; + tiledim[ii] = (naxis[ii] - 1) / tilesize[ii] + 1; + ftile[ii] = (fpixel[ii] - 1) / tilesize[ii] + 1; + ltile[ii] = minvalue((lpixel[ii] - 1) / tilesize[ii] + 1, + tiledim[ii]); + rowdim[ii] = ntemp; /* total tiles in each dimension */ + ntemp *= tiledim[ii]; + } + + /* support up to 6 dimensions for now */ + /* tfpixel and tlpixel are the first and last image pixels */ + /* along each dimension of the compression tile */ + for (i5 = ftile[5]; i5 <= ltile[5]; i5++) + { + tfpixel[5] = (i5 - 1) * tilesize[5] + 1; + tlpixel[5] = minvalue(tfpixel[5] + tilesize[5] - 1, + naxis[5]); + thistilesize[5] = tlpixel[5] - tfpixel[5] + 1; + offset[5] = (i5 - 1) * rowdim[5]; + for (i4 = ftile[4]; i4 <= ltile[4]; i4++) + { + tfpixel[4] = (i4 - 1) * tilesize[4] + 1; + tlpixel[4] = minvalue(tfpixel[4] + tilesize[4] - 1, + naxis[4]); + thistilesize[4] = thistilesize[5] * (tlpixel[4] - tfpixel[4] + 1); + offset[4] = (i4 - 1) * rowdim[4] + offset[5]; + for (i3 = ftile[3]; i3 <= ltile[3]; i3++) + { + tfpixel[3] = (i3 - 1) * tilesize[3] + 1; + tlpixel[3] = minvalue(tfpixel[3] + tilesize[3] - 1, + naxis[3]); + thistilesize[3] = thistilesize[4] * (tlpixel[3] - tfpixel[3] + 1); + offset[3] = (i3 - 1) * rowdim[3] + offset[4]; + for (i2 = ftile[2]; i2 <= ltile[2]; i2++) + { + tfpixel[2] = (i2 - 1) * tilesize[2] + 1; + tlpixel[2] = minvalue(tfpixel[2] + tilesize[2] - 1, + naxis[2]); + thistilesize[2] = thistilesize[3] * (tlpixel[2] - tfpixel[2] + 1); + offset[2] = (i2 - 1) * rowdim[2] + offset[3]; + for (i1 = ftile[1]; i1 <= ltile[1]; i1++) + { + tfpixel[1] = (i1 - 1) * tilesize[1] + 1; + tlpixel[1] = minvalue(tfpixel[1] + tilesize[1] - 1, + naxis[1]); + thistilesize[1] = thistilesize[2] * (tlpixel[1] - tfpixel[1] + 1); + offset[1] = (i1 - 1) * rowdim[1] + offset[2]; + for (i0 = ftile[0]; i0 <= ltile[0]; i0++) + { + tfpixel[0] = (i0 - 1) * tilesize[0] + 1; + tlpixel[0] = minvalue(tfpixel[0] + tilesize[0] - 1, + naxis[0]); + thistilesize[0] = thistilesize[1] * (tlpixel[0] - tfpixel[0] + 1); + /* calculate row of table containing this tile */ + irow = i0 + offset[1]; + + /* read and uncompress this row (tile) of the table */ + /* also do type conversion and undefined pixel substitution */ + /* at this point */ + imcomp_decompress_tile(fptr, irow, thistilesize[0], + datatype, nullcheck, nullval, buffer, bnullarray, &tilenul, + status); + + if (*status == NO_COMPRESSED_TILE) + { + /* tile doesn't exist, so initialize to zero */ + memset(buffer, 0, pixlen * thistilesize[0]); + *status = 0; + } + + /* copy the intersecting pixels to this tile from the input */ + imcomp_merge_overlap(buffer, pixlen, ndim, tfpixel, tlpixel, + bnullarray, array, fpixel, lpixel, nullcheck, status); + + /* compress the tile again, and write it back to the FITS file */ + imcomp_compress_tile (fptr, irow, datatype, buffer, + thistilesize[0], + tlpixel[0] - tfpixel[0] + 1, + tlpixel[1] - tfpixel[1] + 1, + nullcheck, nullval, + status); + } + } + } + } + } + } + free(buffer); + + + if ((fptr->Fptr)->zbitpix < 0 && nullcheck != 0) { +/* + This is a floating point FITS image with possible null values. + It is too messy to test if any null values are actually written, so + just assume so. We need to make sure that the + ZBLANK keyword is present in the compressed image header. If it is not + there then we need to insert the keyword. +*/ + tstatus = 0; + ffgcrd(fptr, "ZBLANK", card, &tstatus); + + if (tstatus) { /* have to insert the ZBLANK keyword */ + ffgcrd(fptr, "ZCMPTYPE", card, status); + ffikyj(fptr, "ZBLANK", COMPRESS_NULL_VALUE, + "null value in the compressed integer array", status); + + /* set this value into the internal structure; it is used if */ + /* the program reads back the values from the array */ + + (fptr->Fptr)->zblank = COMPRESS_NULL_VALUE; + (fptr->Fptr)->cn_zblank = -1; /* flag for a constant ZBLANK */ + } + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_write_compressed_pixels(fitsfile *fptr, /* I - FITS file pointer */ + int datatype, /* I - datatype of the array to be written */ + LONGLONG fpixel, /* I - 'first pixel to write */ + LONGLONG npixel, /* I - number of pixels to write */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: pixels that are = nullval will be */ + /* written with the FITS null pixel value */ + /* (floating point arrays only) */ + void *array, /* I - array of values to write */ + void *nullval, /* I - value used to represent undefined pixels*/ + int *status) /* IO - error status */ +/* + Write a consecutive set of pixels to a compressed image. This routine + interpretes the n-dimensional image as a long one-dimensional array. + This is actually a rather inconvenient way to write compressed images in + general, and could be rather inefficient if the requested pixels to be + written are located in many different image compression tiles. + + The general strategy used here is to write the requested pixels in blocks + that correspond to rectangular image sections. +*/ +{ + int naxis, ii, bytesperpixel; + long naxes[MAX_COMPRESS_DIM], nread; + LONGLONG tfirst, tlast, last0, last1, dimsize[MAX_COMPRESS_DIM]; + long nplane, firstcoord[MAX_COMPRESS_DIM], lastcoord[MAX_COMPRESS_DIM]; + char *arrayptr; + + if (*status > 0) + return(*status); + + arrayptr = (char *) array; + + /* get size of array pixels, in bytes */ + bytesperpixel = ffpxsz(datatype); + + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + naxes[ii] = 1; + firstcoord[ii] = 0; + lastcoord[ii] = 0; + } + + /* determine the dimensions of the image to be written */ + ffgidm(fptr, &naxis, status); + ffgisz(fptr, MAX_COMPRESS_DIM, naxes, status); + + /* calc the cumulative number of pixels in each successive dimension */ + dimsize[0] = 1; + for (ii = 1; ii < MAX_COMPRESS_DIM; ii++) + dimsize[ii] = dimsize[ii - 1] * naxes[ii - 1]; + + /* determine the coordinate of the first and last pixel in the image */ + /* Use zero based indexes here */ + tfirst = fpixel - 1; + tlast = tfirst + npixel - 1; + for (ii = naxis - 1; ii >= 0; ii--) + { + firstcoord[ii] = (long) (tfirst / dimsize[ii]); + lastcoord[ii] = (long) (tlast / dimsize[ii]); + tfirst = tfirst - firstcoord[ii] * dimsize[ii]; + tlast = tlast - lastcoord[ii] * dimsize[ii]; + } + + /* to simplify things, treat 1-D, 2-D, and 3-D images as separate cases */ + + if (naxis == 1) + { + /* Simple: just write the requested range of pixels */ + + firstcoord[0] = firstcoord[0] + 1; + lastcoord[0] = lastcoord[0] + 1; + fits_write_compressed_img(fptr, datatype, firstcoord, lastcoord, + nullcheck, array, nullval, status); + return(*status); + } + else if (naxis == 2) + { + nplane = 0; /* write 1st (and only) plane of the image */ + fits_write_compressed_img_plane(fptr, datatype, bytesperpixel, + nplane, firstcoord, lastcoord, naxes, nullcheck, + array, nullval, &nread, status); + } + else if (naxis == 3) + { + /* test for special case: writing an integral number of planes */ + if (firstcoord[0] == 0 && firstcoord[1] == 0 && + lastcoord[0] == naxes[0] - 1 && lastcoord[1] == naxes[1] - 1) + { + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + /* convert from zero base to 1 base */ + (firstcoord[ii])++; + (lastcoord[ii])++; + } + + /* we can write the contiguous block of pixels in one go */ + fits_write_compressed_img(fptr, datatype, firstcoord, lastcoord, + nullcheck, array, nullval, status); + return(*status); + } + + /* save last coordinate in temporary variables */ + last0 = lastcoord[0]; + last1 = lastcoord[1]; + + if (firstcoord[2] < lastcoord[2]) + { + /* we will write up to the last pixel in all but the last plane */ + lastcoord[0] = naxes[0] - 1; + lastcoord[1] = naxes[1] - 1; + } + + /* write one plane of the cube at a time, for simplicity */ + for (nplane = firstcoord[2]; nplane <= lastcoord[2]; nplane++) + { + if (nplane == lastcoord[2]) + { + lastcoord[0] = (long) last0; + lastcoord[1] = (long) last1; + } + + fits_write_compressed_img_plane(fptr, datatype, bytesperpixel, + nplane, firstcoord, lastcoord, naxes, nullcheck, + arrayptr, nullval, &nread, status); + + /* for all subsequent planes, we start with the first pixel */ + firstcoord[0] = 0; + firstcoord[1] = 0; + + /* increment pointers to next elements to be written */ + arrayptr = arrayptr + nread * bytesperpixel; + } + } + else + { + ffpmsg("only 1D, 2D, or 3D images are currently supported"); + return(*status = DATA_COMPRESSION_ERR); + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_write_compressed_img_plane(fitsfile *fptr, /* I - FITS file */ + int datatype, /* I - datatype of the array to be written */ + int bytesperpixel, /* I - number of bytes per pixel in array */ + long nplane, /* I - which plane of the cube to write */ + long *firstcoord, /* I coordinate of first pixel to write */ + long *lastcoord, /* I coordinate of last pixel to write */ + long *naxes, /* I size of each image dimension */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: pixels that are = nullval will be */ + /* written with the FITS null pixel value */ + /* (floating point arrays only) */ + void *array, /* I - array of values that are written */ + void *nullval, /* I - value for undefined pixels */ + long *nread, /* O - total number of pixels written */ + int *status) /* IO - error status */ + + /* + in general we have to write the first partial row of the image, + followed by the middle complete rows, followed by the last + partial row of the image. If the first or last rows are complete, + then write them at the same time as all the middle rows. + */ +{ + /* bottom left coord. and top right coord. */ + long blc[MAX_COMPRESS_DIM], trc[MAX_COMPRESS_DIM]; + char *arrayptr; + + *nread = 0; + + arrayptr = (char *) array; + + blc[2] = nplane + 1; + trc[2] = nplane + 1; + + if (firstcoord[0] != 0) + { + /* have to read a partial first row */ + blc[0] = firstcoord[0] + 1; + blc[1] = firstcoord[1] + 1; + trc[1] = blc[1]; + if (lastcoord[1] == firstcoord[1]) + trc[0] = lastcoord[0] + 1; /* 1st and last pixels in same row */ + else + trc[0] = naxes[0]; /* read entire rest of the row */ + + fits_write_compressed_img(fptr, datatype, blc, trc, + nullcheck, arrayptr, nullval, status); + + *nread = *nread + trc[0] - blc[0] + 1; + + if (lastcoord[1] == firstcoord[1]) + { + return(*status); /* finished */ + } + + /* set starting coord to beginning of next line */ + firstcoord[0] = 0; + firstcoord[1] += 1; + arrayptr = arrayptr + (trc[0] - blc[0] + 1) * bytesperpixel; + } + + /* write contiguous complete rows of the image, if any */ + blc[0] = 1; + blc[1] = firstcoord[1] + 1; + trc[0] = naxes[0]; + + if (lastcoord[0] + 1 == naxes[0]) + { + /* can write the last complete row, too */ + trc[1] = lastcoord[1] + 1; + } + else + { + /* last row is incomplete; have to read it separately */ + trc[1] = lastcoord[1]; + } + + if (trc[1] >= blc[1]) /* must have at least one whole line to read */ + { + fits_write_compressed_img(fptr, datatype, blc, trc, + nullcheck, arrayptr, nullval, status); + + *nread = *nread + (trc[1] - blc[1] + 1) * naxes[0]; + + if (lastcoord[1] + 1 == trc[1]) + return(*status); /* finished */ + + /* increment pointers for the last partial row */ + arrayptr = arrayptr + (trc[1] - blc[1] + 1) * naxes[0] * bytesperpixel; + + } + + if (trc[1] == lastcoord[1] + 1) + return(*status); /* all done */ + + /* set starting and ending coord to last line */ + + trc[0] = lastcoord[0] + 1; + trc[1] = lastcoord[1] + 1; + blc[1] = trc[1]; + + fits_write_compressed_img(fptr, datatype, blc, trc, + nullcheck, arrayptr, nullval, status); + + *nread = *nread + trc[0] - blc[0] + 1; + + return(*status); +} + +/* ######################################################################## */ +/* ### Image Decompression Routines ### */ +/* ######################################################################## */ + +/*--------------------------------------------------------------------------*/ +int fits_img_decompress (fitsfile *infptr, /* image (bintable) to uncompress */ + fitsfile *outfptr, /* empty HDU for output uncompressed image */ + int *status) /* IO - error status */ + +/* + This routine decompresses the whole image and writes it to the output file. +*/ + +{ + int ii, datatype = 0; + int nullcheck, anynul; + LONGLONG fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM]; + long inc[MAX_COMPRESS_DIM]; + long imgsize; + float *nulladdr, fnulval; + double dnulval; + + if (fits_img_decompress_header(infptr, outfptr, status) > 0) + { + return (*status); + } + + /* force a rescan of the output header keywords, then reset the scaling */ + /* in case the BSCALE and BZERO keywords are present, so that the */ + /* decompressed values won't be scaled when written to the output image */ + ffrdef(outfptr, status); + ffpscl(outfptr, 1.0, 0.0, status); + ffpscl(infptr, 1.0, 0.0, status); + + /* initialize; no null checking is needed for integer images */ + nullcheck = 0; + nulladdr = &fnulval; + + /* determine datatype for image */ + if ((infptr->Fptr)->zbitpix == BYTE_IMG) + { + datatype = TBYTE; + } + else if ((infptr->Fptr)->zbitpix == SHORT_IMG) + { + datatype = TSHORT; + } + else if ((infptr->Fptr)->zbitpix == LONG_IMG) + { + datatype = TINT; + } + else if ((infptr->Fptr)->zbitpix == FLOAT_IMG) + { + /* In the case of float images we must check for NaNs */ + nullcheck = 1; + fnulval = FLOATNULLVALUE; + nulladdr = &fnulval; + datatype = TFLOAT; + } + else if ((infptr->Fptr)->zbitpix == DOUBLE_IMG) + { + /* In the case of double images we must check for NaNs */ + nullcheck = 1; + dnulval = DOUBLENULLVALUE; + nulladdr = (float *) &dnulval; + datatype = TDOUBLE; + } + + /* calculate size of the image (in pixels) */ + imgsize = 1; + for (ii = 0; ii < (infptr->Fptr)->zndim; ii++) + { + imgsize *= (infptr->Fptr)->znaxis[ii]; + fpixel[ii] = 1; /* Set first and last pixel to */ + lpixel[ii] = (infptr->Fptr)->znaxis[ii]; /* include the entire image. */ + inc[ii] = 1; + } + + /* uncompress the input image and write to output image, one tile at a time */ + + fits_read_write_compressed_img(infptr, datatype, fpixel, lpixel, inc, + nullcheck, nulladdr, &anynul, outfptr, status); + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int fits_decompress_img (fitsfile *infptr, /* image (bintable) to uncompress */ + fitsfile *outfptr, /* empty HDU for output uncompressed image */ + int *status) /* IO - error status */ + +/* + THIS IS AN OBSOLETE ROUTINE. USE fits_img_decompress instead!!! + + This routine decompresses the whole image and writes it to the output file. +*/ + +{ + double *data; + int ii, datatype = 0, byte_per_pix = 0; + int nullcheck, anynul; + LONGLONG fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM]; + long inc[MAX_COMPRESS_DIM]; + long imgsize, memsize; + float *nulladdr, fnulval; + double dnulval; + + if (*status > 0) + return(*status); + + if (!fits_is_compressed_image(infptr, status) ) + { + ffpmsg("CHDU is not a compressed image (fits_decompress_img)"); + return(*status = DATA_DECOMPRESSION_ERR); + } + + /* create an empty output image with the correct dimensions */ + if (ffcrim(outfptr, (infptr->Fptr)->zbitpix, (infptr->Fptr)->zndim, + (infptr->Fptr)->znaxis, status) > 0) + { + ffpmsg("error creating output decompressed image HDU"); + return (*status); + } + /* Copy the table header to the image header. */ + if (imcomp_copy_imheader(infptr, outfptr, status) > 0) + { + ffpmsg("error copying header of compressed image"); + return (*status); + } + + /* force a rescan of the output header keywords, then reset the scaling */ + /* in case the BSCALE and BZERO keywords are present, so that the */ + /* decompressed values won't be scaled when written to the output image */ + ffrdef(outfptr, status); + ffpscl(outfptr, 1.0, 0.0, status); + ffpscl(infptr, 1.0, 0.0, status); + + /* initialize; no null checking is needed for integer images */ + nullcheck = 0; + nulladdr = &fnulval; + + /* determine datatype for image */ + if ((infptr->Fptr)->zbitpix == BYTE_IMG) + { + datatype = TBYTE; + byte_per_pix = 1; + } + else if ((infptr->Fptr)->zbitpix == SHORT_IMG) + { + datatype = TSHORT; + byte_per_pix = sizeof(short); + } + else if ((infptr->Fptr)->zbitpix == LONG_IMG) + { + datatype = TINT; + byte_per_pix = sizeof(int); + } + else if ((infptr->Fptr)->zbitpix == FLOAT_IMG) + { + /* In the case of float images we must check for NaNs */ + nullcheck = 1; + fnulval = FLOATNULLVALUE; + nulladdr = &fnulval; + datatype = TFLOAT; + byte_per_pix = sizeof(float); + } + else if ((infptr->Fptr)->zbitpix == DOUBLE_IMG) + { + /* In the case of double images we must check for NaNs */ + nullcheck = 1; + dnulval = DOUBLENULLVALUE; + nulladdr = (float *) &dnulval; + datatype = TDOUBLE; + byte_per_pix = sizeof(double); + } + + /* calculate size of the image (in pixels) */ + imgsize = 1; + for (ii = 0; ii < (infptr->Fptr)->zndim; ii++) + { + imgsize *= (infptr->Fptr)->znaxis[ii]; + fpixel[ii] = 1; /* Set first and last pixel to */ + lpixel[ii] = (infptr->Fptr)->znaxis[ii]; /* include the entire image. */ + inc[ii] = 1; + } + /* Calc equivalent number of double pixels same size as whole the image. */ + /* We use double datatype to force the memory to be aligned properly */ + memsize = ((imgsize * byte_per_pix) - 1) / sizeof(double) + 1; + + /* allocate memory for the image */ + data = (double*) calloc (memsize, sizeof(double)); + if (!data) + { + ffpmsg("Couldn't allocate memory for the uncompressed image"); + return(*status = MEMORY_ALLOCATION); + } + + /* uncompress the entire image into memory */ + /* This routine should be enhanced sometime to only need enough */ + /* memory to uncompress one tile at a time. */ + fits_read_compressed_img(infptr, datatype, fpixel, lpixel, inc, + nullcheck, nulladdr, data, NULL, &anynul, status); + + /* write the image to the output file */ + if (anynul) + fits_write_imgnull(outfptr, datatype, 1, imgsize, data, nulladdr, + status); + else + fits_write_img(outfptr, datatype, 1, imgsize, data, status); + + free(data); + return (*status); +} +/*--------------------------------------------------------------------------*/ +int fits_img_decompress_header(fitsfile *infptr, /* image (bintable) to uncompress */ + fitsfile *outfptr, /* empty HDU for output uncompressed image */ + int *status) /* IO - error status */ + +/* + This routine reads the header of the input tile compressed image and + converts it to that of a standard uncompress FITS image. +*/ + +{ + int writeprime = 0; + int hdupos, inhdupos, numkeys; + int nullprime = 0, copyprime = 0, norec = 0, tstatus; + char card[FLEN_CARD]; + int ii, datatype = 0, naxis, bitpix; + long naxes[MAX_COMPRESS_DIM]; + + if (*status > 0) + return(*status); + else if (*status == -1) { + *status = 0; + writeprime = 1; + } + + if (!fits_is_compressed_image(infptr, status) ) + { + ffpmsg("CHDU is not a compressed image (fits_img_decompress)"); + return(*status = DATA_DECOMPRESSION_ERR); + } + + /* get information about the state of the output file; does it already */ + /* contain any keywords and HDUs? */ + fits_get_hdu_num(infptr, &inhdupos); /* Get the current output HDU position */ + fits_get_hdu_num(outfptr, &hdupos); /* Get the current output HDU position */ + fits_get_hdrspace(outfptr, &numkeys, 0, status); + + /* Was the input compressed HDU originally the primary array image? */ + tstatus = 0; + if (!fits_read_card(infptr, "ZSIMPLE", card, &tstatus)) { + /* yes, input HDU was a primary array (not an IMAGE extension) */ + /* Now determine if we can uncompress it into the primary array of */ + /* the output file. This is only possible if the output file */ + /* currently only contains a null primary array, with no addition */ + /* header keywords and with no following extension in the FITS file. */ + + if (hdupos == 1) { /* are we positioned at the primary array? */ + if (numkeys == 0) { /* primary HDU is completely empty */ + nullprime = 1; + } else { + fits_get_img_param(outfptr, MAX_COMPRESS_DIM, &bitpix, &naxis, naxes, status); + + if (naxis == 0) { /* is this a null image? */ + nullprime = 1; + + if (inhdupos == 2) /* must be at the first extension */ + copyprime = 1; + } + } + } + } + + if (nullprime) { + /* We will delete the existing keywords in the null primary array + and uncompress the input image into the primary array of the output. + Some of these keywords may be added back to the uncompressed image + header later. + */ + + for (ii = numkeys; ii > 0; ii--) + fits_delete_record(outfptr, ii, status); + + } else { + + /* if the ZTENSION keyword doesn't exist, then we have to + write the required keywords manually */ + tstatus = 0; + if (fits_read_card(infptr, "ZTENSION", card, &tstatus)) { + + /* create an empty output image with the correct dimensions */ + if (ffcrim(outfptr, (infptr->Fptr)->zbitpix, (infptr->Fptr)->zndim, + (infptr->Fptr)->znaxis, status) > 0) + { + ffpmsg("error creating output decompressed image HDU"); + return (*status); + } + + norec = 1; /* the required keywords have already been written */ + + } else { /* the input compressed image does have ZTENSION keyword */ + + if (writeprime) { /* convert the image extension to a primary array */ + /* have to write the required keywords manually */ + + /* create an empty output image with the correct dimensions */ + if (ffcrim(outfptr, (infptr->Fptr)->zbitpix, (infptr->Fptr)->zndim, + (infptr->Fptr)->znaxis, status) > 0) + { + ffpmsg("error creating output decompressed image HDU"); + return (*status); + } + + norec = 1; /* the required keywords have already been written */ + + } else { /* write the input compressed image to an image extension */ + + if (numkeys == 0) { /* the output file is currently completely empty */ + + /* In this case, the input is a compressed IMAGE extension. */ + /* Since the uncompressed output file is currently completely empty, */ + /* we need to write a null primary array before uncompressing the */ + /* image extension */ + + ffcrim(outfptr, 8, 0, naxes, status); /* naxes is not used */ + + /* now create the empty extension to uncompress into */ + if (fits_create_hdu(outfptr, status) > 0) + { + ffpmsg("error creating output decompressed image HDU"); + return (*status); + } + + } else { + /* just create a new empty extension, then copy all the required */ + /* keywords into it. */ + fits_create_hdu(outfptr, status); + } + } + } + + } + + if (*status > 0) { + ffpmsg("error creating output decompressed image HDU"); + return (*status); + } + + /* Copy the table header to the image header. */ + + if (imcomp_copy_comp2img(infptr, outfptr, norec, status) > 0) + { + ffpmsg("error copying header keywords from compressed image"); + } + + if (copyprime) { + /* append any unexpected keywords from the primary array. + This includes any keywords except SIMPLE, BITPIX, NAXIS, + EXTEND, COMMENT, HISTORY, CHECKSUM, and DATASUM. + */ + + fits_movabs_hdu(infptr, 1, NULL, status); /* move to primary array */ + + /* do this so that any new keywords get written before any blank + keywords that may have been appended by imcomp_copy_comp2img */ + fits_set_hdustruc(outfptr, status); + + if (imcomp_copy_prime2img(infptr, outfptr, status) > 0) + { + ffpmsg("error copying primary keywords from compressed file"); + } + + fits_movabs_hdu(infptr, 2, NULL, status); /* move back to where we were */ + } + + return (*status); +} +/*---------------------------------------------------------------------------*/ +int fits_read_compressed_img(fitsfile *fptr, /* I - FITS file pointer */ + int datatype, /* I - datatype of the array to be returned */ + LONGLONG *infpixel, /* I - 'bottom left corner' of the subsection */ + LONGLONG *inlpixel, /* I - 'top right corner' of the subsection */ + long *ininc, /* I - increment to be applied in each dimension */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: set undefined pixels = nullval */ + /* 2: set nullarray=1 for undefined pixels */ + void *nullval, /* I - value for undefined pixels */ + void *array, /* O - array of values that are returned */ + char *nullarray, /* O - array of flags = 1 if nullcheck = 2 */ + int *anynul, /* O - set to 1 if any values are null; else 0 */ + int *status) /* IO - error status */ +/* + Read a section of a compressed image; Note: lpixel may be larger than the + size of the uncompressed image. Only the pixels within the image will be + returned. +*/ +{ + int naxis[MAX_COMPRESS_DIM], tiledim[MAX_COMPRESS_DIM]; + long tilesize[MAX_COMPRESS_DIM], thistilesize[MAX_COMPRESS_DIM]; + long ftile[MAX_COMPRESS_DIM], ltile[MAX_COMPRESS_DIM]; + long tfpixel[MAX_COMPRESS_DIM], tlpixel[MAX_COMPRESS_DIM]; + long rowdim[MAX_COMPRESS_DIM], offset[MAX_COMPRESS_DIM],ntemp; + long fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM]; + long inc[MAX_COMPRESS_DIM]; + int ii, i5, i4, i3, i2, i1, i0, ndim, irow, pixlen, tilenul; + void *buffer; + char *bnullarray = 0; + double testnullval = 0.; + + if (*status > 0) + return(*status); + + if (!fits_is_compressed_image(fptr, status) ) + { + ffpmsg("CHDU is not a compressed image (fits_read_compressed_img)"); + return(*status = DATA_DECOMPRESSION_ERR); + } + + /* get temporary space for uncompressing one image tile */ + if (datatype == TSHORT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (short)); + pixlen = sizeof(short); + if (nullval) + testnullval = *(short *) nullval; + } + else if (datatype == TINT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (int)); + pixlen = sizeof(int); + if (nullval) + testnullval = *(int *) nullval; + } + else if (datatype == TLONG) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (long)); + pixlen = sizeof(long); + if (nullval) + testnullval = *(long *) nullval; + } + else if (datatype == TFLOAT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (float)); + pixlen = sizeof(float); + if (nullval) + testnullval = *(float *) nullval; + } + else if (datatype == TDOUBLE) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (double)); + pixlen = sizeof(double); + if (nullval) + testnullval = *(double *) nullval; + } + else if (datatype == TUSHORT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned short)); + pixlen = sizeof(short); + if (nullval) + testnullval = *(unsigned short *) nullval; + } + else if (datatype == TUINT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned int)); + pixlen = sizeof(int); + if (nullval) + testnullval = *(unsigned int *) nullval; + } + else if (datatype == TULONG) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned long)); + pixlen = sizeof(long); + if (nullval) + testnullval = *(unsigned long *) nullval; + } + else if (datatype == TBYTE || datatype == TSBYTE) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (char)); + pixlen = 1; + if (nullval) + testnullval = *(unsigned char *) nullval; + } + else + { + ffpmsg("unsupported datatype for uncompressing image"); + return(*status = BAD_DATATYPE); + } + + /* If nullcheck ==1 and nullval == 0, then this means that the */ + /* calling routine does not want to check for null pixels in the array */ + if (nullcheck == 1 && testnullval == 0.) + nullcheck = 0; + + if (buffer == NULL) + { + ffpmsg("Out of memory (fits_read_compress_img)"); + return (*status = MEMORY_ALLOCATION); + } + + /* allocate memory for a null flag array, if needed */ + if (nullcheck == 2) + { + bnullarray = calloc ((fptr->Fptr)->maxtilelen, sizeof (char)); + + if (bnullarray == NULL) + { + ffpmsg("Out of memory (fits_read_compress_img)"); + free(buffer); + return (*status = MEMORY_ALLOCATION); + } + } + + /* initialize all the arrays */ + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + naxis[ii] = 1; + tiledim[ii] = 1; + tilesize[ii] = 1; + ftile[ii] = 1; + ltile[ii] = 1; + rowdim[ii] = 1; + } + + ndim = (fptr->Fptr)->zndim; + ntemp = 1; + for (ii = 0; ii < ndim; ii++) + { + /* support for mirror-reversed image sections */ + if (infpixel[ii] <= inlpixel[ii]) + { + fpixel[ii] = (long) infpixel[ii]; + lpixel[ii] = (long) inlpixel[ii]; + inc[ii] = ininc[ii]; + } + else + { + fpixel[ii] = (long) inlpixel[ii]; + lpixel[ii] = (long) infpixel[ii]; + inc[ii] = -ininc[ii]; + } + + /* calc number of tiles in each dimension, and tile containing */ + /* the first and last pixel we want to read in each dimension */ + naxis[ii] = (fptr->Fptr)->znaxis[ii]; + if (fpixel[ii] < 1) + { + if (nullcheck == 2) + { + free(bnullarray); + } + free(buffer); + return(*status = BAD_PIX_NUM); + } + + tilesize[ii] = (fptr->Fptr)->tilesize[ii]; + tiledim[ii] = (naxis[ii] - 1) / tilesize[ii] + 1; + ftile[ii] = (fpixel[ii] - 1) / tilesize[ii] + 1; + ltile[ii] = minvalue((lpixel[ii] - 1) / tilesize[ii] + 1, + tiledim[ii]); + rowdim[ii] = ntemp; /* total tiles in each dimension */ + ntemp *= tiledim[ii]; + } + + if (anynul) + *anynul = 0; /* initialize */ + + /* support up to 6 dimensions for now */ + /* tfpixel and tlpixel are the first and last image pixels */ + /* along each dimension of the compression tile */ + for (i5 = ftile[5]; i5 <= ltile[5]; i5++) + { + tfpixel[5] = (i5 - 1) * tilesize[5] + 1; + tlpixel[5] = minvalue(tfpixel[5] + tilesize[5] - 1, + naxis[5]); + thistilesize[5] = tlpixel[5] - tfpixel[5] + 1; + offset[5] = (i5 - 1) * rowdim[5]; + for (i4 = ftile[4]; i4 <= ltile[4]; i4++) + { + tfpixel[4] = (i4 - 1) * tilesize[4] + 1; + tlpixel[4] = minvalue(tfpixel[4] + tilesize[4] - 1, + naxis[4]); + thistilesize[4] = thistilesize[5] * (tlpixel[4] - tfpixel[4] + 1); + offset[4] = (i4 - 1) * rowdim[4] + offset[5]; + for (i3 = ftile[3]; i3 <= ltile[3]; i3++) + { + tfpixel[3] = (i3 - 1) * tilesize[3] + 1; + tlpixel[3] = minvalue(tfpixel[3] + tilesize[3] - 1, + naxis[3]); + thistilesize[3] = thistilesize[4] * (tlpixel[3] - tfpixel[3] + 1); + offset[3] = (i3 - 1) * rowdim[3] + offset[4]; + for (i2 = ftile[2]; i2 <= ltile[2]; i2++) + { + tfpixel[2] = (i2 - 1) * tilesize[2] + 1; + tlpixel[2] = minvalue(tfpixel[2] + tilesize[2] - 1, + naxis[2]); + thistilesize[2] = thistilesize[3] * (tlpixel[2] - tfpixel[2] + 1); + offset[2] = (i2 - 1) * rowdim[2] + offset[3]; + for (i1 = ftile[1]; i1 <= ltile[1]; i1++) + { + tfpixel[1] = (i1 - 1) * tilesize[1] + 1; + tlpixel[1] = minvalue(tfpixel[1] + tilesize[1] - 1, + naxis[1]); + thistilesize[1] = thistilesize[2] * (tlpixel[1] - tfpixel[1] + 1); + offset[1] = (i1 - 1) * rowdim[1] + offset[2]; + for (i0 = ftile[0]; i0 <= ltile[0]; i0++) + { + tfpixel[0] = (i0 - 1) * tilesize[0] + 1; + tlpixel[0] = minvalue(tfpixel[0] + tilesize[0] - 1, + naxis[0]); + thistilesize[0] = thistilesize[1] * (tlpixel[0] - tfpixel[0] + 1); + /* calculate row of table containing this tile */ + irow = i0 + offset[1]; + +/* +printf("row %d, %d %d, %d %d, %d %d; %d\n", + irow, tfpixel[0],tlpixel[0],tfpixel[1],tlpixel[1],tfpixel[2],tlpixel[2], + thistilesize[0]); +*/ + /* read and uncompress this row (tile) of the table */ + /* also do type conversion and undefined pixel substitution */ + /* at this point */ + + imcomp_decompress_tile(fptr, irow, thistilesize[0], + datatype, nullcheck, nullval, buffer, bnullarray, &tilenul, + status); + + if (tilenul && anynul) + *anynul = 1; /* there are null pixels */ +/* +printf(" pixlen=%d, ndim=%d, %d %d %d, %d %d %d, %d %d %d\n", + pixlen, ndim, fpixel[0],lpixel[0],inc[0],fpixel[1],lpixel[1],inc[1], + fpixel[2],lpixel[2],inc[2]); +*/ + /* copy the intersecting pixels from this tile to the output */ + imcomp_copy_overlap(buffer, pixlen, ndim, tfpixel, tlpixel, + bnullarray, array, fpixel, lpixel, inc, nullcheck, + nullarray, status); + } + } + } + } + } + } + if (nullcheck == 2) + { + free(bnullarray); + } + free(buffer); + + return(*status); +} +/*---------------------------------------------------------------------------*/ +int fits_read_write_compressed_img(fitsfile *fptr, /* I - FITS file pointer */ + int datatype, /* I - datatype of the array to be returned */ + LONGLONG *infpixel, /* I - 'bottom left corner' of the subsection */ + LONGLONG *inlpixel, /* I - 'top right corner' of the subsection */ + long *ininc, /* I - increment to be applied in each dimension */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: set undefined pixels = nullval */ + void *nullval, /* I - value for undefined pixels */ + int *anynul, /* O - set to 1 if any values are null; else 0 */ + fitsfile *outfptr, /* I - FITS file pointer */ + int *status) /* IO - error status */ +/* + This is similar to fits_read_compressed_img, except that it writes + the pixels to the output image, on a tile by tile basis instead of returning + the array. +*/ +{ + int naxis[MAX_COMPRESS_DIM], tiledim[MAX_COMPRESS_DIM]; + long tilesize[MAX_COMPRESS_DIM], thistilesize[MAX_COMPRESS_DIM]; + long ftile[MAX_COMPRESS_DIM], ltile[MAX_COMPRESS_DIM]; + long tfpixel[MAX_COMPRESS_DIM], tlpixel[MAX_COMPRESS_DIM]; + long rowdim[MAX_COMPRESS_DIM], offset[MAX_COMPRESS_DIM],ntemp; + long fpixel[MAX_COMPRESS_DIM], lpixel[MAX_COMPRESS_DIM]; + long inc[MAX_COMPRESS_DIM]; + int ii, i5, i4, i3, i2, i1, i0, ndim, irow, pixlen, tilenul; + void *buffer; + char *bnullarray = 0; + double testnullval = 0.; + LONGLONG firstelem; + + if (*status > 0) + return(*status); + + if (!fits_is_compressed_image(fptr, status) ) + { + ffpmsg("CHDU is not a compressed image (fits_read_compressed_img)"); + return(*status = DATA_DECOMPRESSION_ERR); + } + + /* get temporary space for uncompressing one image tile */ + if (datatype == TSHORT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (short)); + pixlen = sizeof(short); + if (nullval) + testnullval = *(short *) nullval; + } + else if (datatype == TINT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (int)); + pixlen = sizeof(int); + if (nullval) + testnullval = *(int *) nullval; + } + else if (datatype == TLONG) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (long)); + pixlen = sizeof(long); + if (nullval) + testnullval = *(long *) nullval; + } + else if (datatype == TFLOAT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (float)); + pixlen = sizeof(float); + if (nullval) + testnullval = *(float *) nullval; + } + else if (datatype == TDOUBLE) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (double)); + pixlen = sizeof(double); + if (nullval) + testnullval = *(double *) nullval; + } + else if (datatype == TUSHORT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned short)); + pixlen = sizeof(short); + if (nullval) + testnullval = *(unsigned short *) nullval; + } + else if (datatype == TUINT) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned int)); + pixlen = sizeof(int); + if (nullval) + testnullval = *(unsigned int *) nullval; + } + else if (datatype == TULONG) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (unsigned long)); + pixlen = sizeof(long); + if (nullval) + testnullval = *(unsigned long *) nullval; + } + else if (datatype == TBYTE || datatype == TSBYTE) + { + buffer = malloc ((fptr->Fptr)->maxtilelen * sizeof (char)); + pixlen = 1; + if (nullval) + testnullval = *(unsigned char *) nullval; + } + else + { + ffpmsg("unsupported datatype for uncompressing image"); + return(*status = BAD_DATATYPE); + } + + /* If nullcheck ==1 and nullval == 0, then this means that the */ + /* calling routine does not want to check for null pixels in the array */ + if (nullcheck == 1 && testnullval == 0.) + nullcheck = 0; + + if (buffer == NULL) + { + ffpmsg("Out of memory (fits_read_compress_img)"); + return (*status = MEMORY_ALLOCATION); + } + + /* initialize all the arrays */ + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + naxis[ii] = 1; + tiledim[ii] = 1; + tilesize[ii] = 1; + ftile[ii] = 1; + ltile[ii] = 1; + rowdim[ii] = 1; + } + + ndim = (fptr->Fptr)->zndim; + ntemp = 1; + for (ii = 0; ii < ndim; ii++) + { + /* support for mirror-reversed image sections */ + if (infpixel[ii] <= inlpixel[ii]) + { + fpixel[ii] = (long) infpixel[ii]; + lpixel[ii] = (long) inlpixel[ii]; + inc[ii] = ininc[ii]; + } + else + { + fpixel[ii] = (long) inlpixel[ii]; + lpixel[ii] = (long) infpixel[ii]; + inc[ii] = -ininc[ii]; + } + + /* calc number of tiles in each dimension, and tile containing */ + /* the first and last pixel we want to read in each dimension */ + naxis[ii] = (fptr->Fptr)->znaxis[ii]; + if (fpixel[ii] < 1) + { + free(buffer); + return(*status = BAD_PIX_NUM); + } + + tilesize[ii] = (fptr->Fptr)->tilesize[ii]; + tiledim[ii] = (naxis[ii] - 1) / tilesize[ii] + 1; + ftile[ii] = (fpixel[ii] - 1) / tilesize[ii] + 1; + ltile[ii] = minvalue((lpixel[ii] - 1) / tilesize[ii] + 1, + tiledim[ii]); + rowdim[ii] = ntemp; /* total tiles in each dimension */ + ntemp *= tiledim[ii]; + } + + if (anynul) + *anynul = 0; /* initialize */ + + firstelem = 1; + + /* support up to 6 dimensions for now */ + /* tfpixel and tlpixel are the first and last image pixels */ + /* along each dimension of the compression tile */ + for (i5 = ftile[5]; i5 <= ltile[5]; i5++) + { + tfpixel[5] = (i5 - 1) * tilesize[5] + 1; + tlpixel[5] = minvalue(tfpixel[5] + tilesize[5] - 1, + naxis[5]); + thistilesize[5] = tlpixel[5] - tfpixel[5] + 1; + offset[5] = (i5 - 1) * rowdim[5]; + for (i4 = ftile[4]; i4 <= ltile[4]; i4++) + { + tfpixel[4] = (i4 - 1) * tilesize[4] + 1; + tlpixel[4] = minvalue(tfpixel[4] + tilesize[4] - 1, + naxis[4]); + thistilesize[4] = thistilesize[5] * (tlpixel[4] - tfpixel[4] + 1); + offset[4] = (i4 - 1) * rowdim[4] + offset[5]; + for (i3 = ftile[3]; i3 <= ltile[3]; i3++) + { + tfpixel[3] = (i3 - 1) * tilesize[3] + 1; + tlpixel[3] = minvalue(tfpixel[3] + tilesize[3] - 1, + naxis[3]); + thistilesize[3] = thistilesize[4] * (tlpixel[3] - tfpixel[3] + 1); + offset[3] = (i3 - 1) * rowdim[3] + offset[4]; + for (i2 = ftile[2]; i2 <= ltile[2]; i2++) + { + tfpixel[2] = (i2 - 1) * tilesize[2] + 1; + tlpixel[2] = minvalue(tfpixel[2] + tilesize[2] - 1, + naxis[2]); + thistilesize[2] = thistilesize[3] * (tlpixel[2] - tfpixel[2] + 1); + offset[2] = (i2 - 1) * rowdim[2] + offset[3]; + for (i1 = ftile[1]; i1 <= ltile[1]; i1++) + { + tfpixel[1] = (i1 - 1) * tilesize[1] + 1; + tlpixel[1] = minvalue(tfpixel[1] + tilesize[1] - 1, + naxis[1]); + thistilesize[1] = thistilesize[2] * (tlpixel[1] - tfpixel[1] + 1); + offset[1] = (i1 - 1) * rowdim[1] + offset[2]; + for (i0 = ftile[0]; i0 <= ltile[0]; i0++) + { + tfpixel[0] = (i0 - 1) * tilesize[0] + 1; + tlpixel[0] = minvalue(tfpixel[0] + tilesize[0] - 1, + naxis[0]); + thistilesize[0] = thistilesize[1] * (tlpixel[0] - tfpixel[0] + 1); + /* calculate row of table containing this tile */ + irow = i0 + offset[1]; + + /* read and uncompress this row (tile) of the table */ + /* also do type conversion and undefined pixel substitution */ + /* at this point */ + + imcomp_decompress_tile(fptr, irow, thistilesize[0], + datatype, nullcheck, nullval, buffer, bnullarray, &tilenul, + status); + + /* write the image to the output file */ + + if (tilenul && anynul) { + /* this assumes that the tiled pixels are in the same order + as in the uncompressed FITS image. This is not necessarily + the case, but it almost alway is in practice. + Note that null checking is not performed for integer images, + so this could only be a problem for tile compressed floating + point images that use an unconventional tiling pattern. + */ + fits_write_imgnull(outfptr, datatype, firstelem, thistilesize[0], + buffer, nullval, status); + } else { + fits_write_subset(outfptr, datatype, tfpixel, tlpixel, + buffer, status); + } + + firstelem += thistilesize[0]; + + } + } + } + } + } + } + + free(buffer); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_read_compressed_pixels(fitsfile *fptr, /* I - FITS file pointer */ + int datatype, /* I - datatype of the array to be returned */ + LONGLONG fpixel, /* I - 'first pixel to read */ + LONGLONG npixel, /* I - number of pixels to read */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: set undefined pixels = nullval */ + /* 2: set nullarray=1 for undefined pixels */ + void *nullval, /* I - value for undefined pixels */ + void *array, /* O - array of values that are returned */ + char *nullarray, /* O - array of flags = 1 if nullcheck = 2 */ + int *anynul, /* O - set to 1 if any values are null; else 0 */ + int *status) /* IO - error status */ +/* + Read a consecutive set of pixels from a compressed image. This routine + interpretes the n-dimensional image as a long one-dimensional array. + This is actually a rather inconvenient way to read compressed images in + general, and could be rather inefficient if the requested pixels to be + read are located in many different image compression tiles. + + The general strategy used here is to read the requested pixels in blocks + that correspond to rectangular image sections. +*/ +{ + int naxis, ii, bytesperpixel, planenul; + long naxes[MAX_COMPRESS_DIM], nread; + long nplane, inc[MAX_COMPRESS_DIM]; + LONGLONG tfirst, tlast, last0, last1, dimsize[MAX_COMPRESS_DIM]; + LONGLONG firstcoord[MAX_COMPRESS_DIM], lastcoord[MAX_COMPRESS_DIM]; + char *arrayptr, *nullarrayptr; + + if (*status > 0) + return(*status); + + arrayptr = (char *) array; + nullarrayptr = nullarray; + + /* get size of array pixels, in bytes */ + bytesperpixel = ffpxsz(datatype); + + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + naxes[ii] = 1; + firstcoord[ii] = 0; + lastcoord[ii] = 0; + inc[ii] = 1; + } + + /* determine the dimensions of the image to be read */ + ffgidm(fptr, &naxis, status); + ffgisz(fptr, MAX_COMPRESS_DIM, naxes, status); + + /* calc the cumulative number of pixels in each successive dimension */ + dimsize[0] = 1; + for (ii = 1; ii < MAX_COMPRESS_DIM; ii++) + dimsize[ii] = dimsize[ii - 1] * naxes[ii - 1]; + + /* determine the coordinate of the first and last pixel in the image */ + /* Use zero based indexes here */ + tfirst = fpixel - 1; + tlast = tfirst + npixel - 1; + for (ii = naxis - 1; ii >= 0; ii--) + { + firstcoord[ii] = tfirst / dimsize[ii]; + lastcoord[ii] = tlast / dimsize[ii]; + tfirst = tfirst - firstcoord[ii] * dimsize[ii]; + tlast = tlast - lastcoord[ii] * dimsize[ii]; + } + + /* to simplify things, treat 1-D, 2-D, and 3-D images as separate cases */ + + if (naxis == 1) + { + /* Simple: just read the requested range of pixels */ + + firstcoord[0] = firstcoord[0] + 1; + lastcoord[0] = lastcoord[0] + 1; + fits_read_compressed_img(fptr, datatype, firstcoord, lastcoord, inc, + nullcheck, nullval, array, nullarray, anynul, status); + return(*status); + } + else if (naxis == 2) + { + nplane = 0; /* read 1st (and only) plane of the image */ + + fits_read_compressed_img_plane(fptr, datatype, bytesperpixel, + nplane, firstcoord, lastcoord, inc, naxes, nullcheck, nullval, + array, nullarray, anynul, &nread, status); + } + else if (naxis == 3) + { + /* test for special case: reading an integral number of planes */ + if (firstcoord[0] == 0 && firstcoord[1] == 0 && + lastcoord[0] == naxes[0] - 1 && lastcoord[1] == naxes[1] - 1) + { + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + /* convert from zero base to 1 base */ + (firstcoord[ii])++; + (lastcoord[ii])++; + } + + /* we can read the contiguous block of pixels in one go */ + fits_read_compressed_img(fptr, datatype, firstcoord, lastcoord, inc, + nullcheck, nullval, array, nullarray, anynul, status); + + return(*status); + } + + if (anynul) + *anynul = 0; /* initialize */ + + /* save last coordinate in temporary variables */ + last0 = lastcoord[0]; + last1 = lastcoord[1]; + + if (firstcoord[2] < lastcoord[2]) + { + /* we will read up to the last pixel in all but the last plane */ + lastcoord[0] = naxes[0] - 1; + lastcoord[1] = naxes[1] - 1; + } + + /* read one plane of the cube at a time, for simplicity */ + for (nplane = (long) firstcoord[2]; nplane <= lastcoord[2]; nplane++) + { + if (nplane == lastcoord[2]) + { + lastcoord[0] = last0; + lastcoord[1] = last1; + } + + fits_read_compressed_img_plane(fptr, datatype, bytesperpixel, + nplane, firstcoord, lastcoord, inc, naxes, nullcheck, nullval, + arrayptr, nullarrayptr, &planenul, &nread, status); + + if (planenul && anynul) + *anynul = 1; /* there are null pixels */ + + /* for all subsequent planes, we start with the first pixel */ + firstcoord[0] = 0; + firstcoord[1] = 0; + + /* increment pointers to next elements to be read */ + arrayptr = arrayptr + nread * bytesperpixel; + if (nullarrayptr && (nullcheck == 2) ) + nullarrayptr = nullarrayptr + nread; + } + } + else + { + ffpmsg("only 1D, 2D, or 3D images are currently supported"); + return(*status = DATA_DECOMPRESSION_ERR); + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_read_compressed_img_plane(fitsfile *fptr, /* I - FITS file */ + int datatype, /* I - datatype of the array to be returned */ + int bytesperpixel, /* I - number of bytes per pixel in array */ + long nplane, /* I - which plane of the cube to read */ + LONGLONG *firstcoord, /* coordinate of first pixel to read */ + LONGLONG *lastcoord, /* coordinate of last pixel to read */ + long *inc, /* increment of pixels to read */ + long *naxes, /* size of each image dimension */ + int nullcheck, /* I - 0 for no null checking */ + /* 1: set undefined pixels = nullval */ + /* 2: set nullarray=1 for undefined pixels */ + void *nullval, /* I - value for undefined pixels */ + void *array, /* O - array of values that are returned */ + char *nullarray, /* O - array of flags = 1 if nullcheck = 2 */ + int *anynul, /* O - set to 1 if any values are null; else 0 */ + long *nread, /* O - total number of pixels read and returned*/ + int *status) /* IO - error status */ + + /* + in general we have to read the first partial row of the image, + followed by the middle complete rows, followed by the last + partial row of the image. If the first or last rows are complete, + then read them at the same time as all the middle rows. + */ +{ + /* bottom left coord. and top right coord. */ + LONGLONG blc[MAX_COMPRESS_DIM], trc[MAX_COMPRESS_DIM]; + char *arrayptr, *nullarrayptr; + int tnull; + + if (anynul) + *anynul = 0; + + *nread = 0; + + arrayptr = (char *) array; + nullarrayptr = nullarray; + + blc[2] = nplane + 1; + trc[2] = nplane + 1; + + if (firstcoord[0] != 0) + { + /* have to read a partial first row */ + blc[0] = firstcoord[0] + 1; + blc[1] = firstcoord[1] + 1; + trc[1] = blc[1]; + if (lastcoord[1] == firstcoord[1]) + trc[0] = lastcoord[0] + 1; /* 1st and last pixels in same row */ + else + trc[0] = naxes[0]; /* read entire rest of the row */ + + fits_read_compressed_img(fptr, datatype, blc, trc, inc, + nullcheck, nullval, arrayptr, nullarrayptr, &tnull, status); + + *nread = *nread + (long) (trc[0] - blc[0] + 1); + + if (tnull && anynul) + *anynul = 1; /* there are null pixels */ + + if (lastcoord[1] == firstcoord[1]) + { + return(*status); /* finished */ + } + + /* set starting coord to beginning of next line */ + firstcoord[0] = 0; + firstcoord[1] += 1; + arrayptr = arrayptr + (trc[0] - blc[0] + 1) * bytesperpixel; + if (nullarrayptr && (nullcheck == 2) ) + nullarrayptr = nullarrayptr + (trc[0] - blc[0] + 1); + + } + + /* read contiguous complete rows of the image, if any */ + blc[0] = 1; + blc[1] = firstcoord[1] + 1; + trc[0] = naxes[0]; + + if (lastcoord[0] + 1 == naxes[0]) + { + /* can read the last complete row, too */ + trc[1] = lastcoord[1] + 1; + } + else + { + /* last row is incomplete; have to read it separately */ + trc[1] = lastcoord[1]; + } + + if (trc[1] >= blc[1]) /* must have at least one whole line to read */ + { + fits_read_compressed_img(fptr, datatype, blc, trc, inc, + nullcheck, nullval, arrayptr, nullarrayptr, &tnull, status); + + *nread = *nread + (long) ((trc[1] - blc[1] + 1) * naxes[0]); + + if (tnull && anynul) + *anynul = 1; + + if (lastcoord[1] + 1 == trc[1]) + return(*status); /* finished */ + + /* increment pointers for the last partial row */ + arrayptr = arrayptr + (trc[1] - blc[1] + 1) * naxes[0] * bytesperpixel; + if (nullarrayptr && (nullcheck == 2) ) + nullarrayptr = nullarrayptr + (trc[1] - blc[1] + 1) * naxes[0]; + } + + if (trc[1] == lastcoord[1] + 1) + return(*status); /* all done */ + + /* set starting and ending coord to last line */ + + trc[0] = lastcoord[0] + 1; + trc[1] = lastcoord[1] + 1; + blc[1] = trc[1]; + + fits_read_compressed_img(fptr, datatype, blc, trc, inc, + nullcheck, nullval, arrayptr, nullarrayptr, &tnull, status); + + if (tnull && anynul) + *anynul = 1; + + *nread = *nread + (long) (trc[0] - blc[0] + 1); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_get_compressed_image_par(fitsfile *infptr, int *status) + +/* + This routine reads keywords from a BINTABLE extension containing a + compressed image. +*/ +{ + char keyword[FLEN_KEYWORD]; + char value[FLEN_VALUE]; + int ii, tstatus, doffset; + long expect_nrows, maxtilelen; + + if (*status > 0) + return(*status); + + /* Copy relevant header keyword values to structure */ + if (ffgky (infptr, TSTRING, "ZCMPTYPE", value, NULL, status) > 0) + { + ffpmsg("required ZCMPTYPE compression keyword not found in"); + ffpmsg(" imcomp_get_compressed_image_par"); + return(*status); + } + + (infptr->Fptr)->zcmptype[0] = '\0'; + strncat((infptr->Fptr)->zcmptype, value, 11); + + if (!FSTRCMP(value, "RICE_1") ) + (infptr->Fptr)->compress_type = RICE_1; + else if (!FSTRCMP(value, "HCOMPRESS_1") ) + (infptr->Fptr)->compress_type = HCOMPRESS_1; + else if (!FSTRCMP(value, "GZIP_1") ) + (infptr->Fptr)->compress_type = GZIP_1; + else if (!FSTRCMP(value, "GZIP_2") ) + (infptr->Fptr)->compress_type = GZIP_2; + else if (!FSTRCMP(value, "BZIP2_1") ) + (infptr->Fptr)->compress_type = BZIP2_1; + else if (!FSTRCMP(value, "PLIO_1") ) + (infptr->Fptr)->compress_type = PLIO_1; + else if (!FSTRCMP(value, "NOCOMPRESS") ) + (infptr->Fptr)->compress_type = NOCOMPRESS; + else + { + ffpmsg("Unknown image compression type:"); + ffpmsg(value); + return (*status = DATA_DECOMPRESSION_ERR); + } + + /* get the floating point to integer quantization type, if present. */ + /* FITS files produced before 2009 will not have this keyword */ + tstatus = 0; + if (ffgky(infptr, TSTRING, "ZQUANTIZ", value, NULL, &tstatus) > 0) + { + (infptr->Fptr)->quantize_dither = 0; + } else { + if (!FSTRCMP(value, "NONE") ) + (infptr->Fptr)->quantize_level = NO_QUANTIZE; + else if (!FSTRCMP(value, "SUBTRACTIVE_DITHER_1") ) + (infptr->Fptr)->quantize_dither = SUBTRACTIVE_DITHER_1; + else + (infptr->Fptr)->quantize_dither = 0; + } + + /* get the floating point quantization dithering offset, if present. */ + /* FITS files produced before October 2009 will not have this keyword */ + tstatus = 0; + if (ffgky(infptr, TINT, "ZDITHER0", &doffset, NULL, &tstatus) > 0) + { + /* by default start with 1st element of random sequence */ + (infptr->Fptr)->dither_offset = 1; + } else { + (infptr->Fptr)->dither_offset = doffset; + } + + if (ffgky (infptr, TINT, "ZBITPIX", &(infptr->Fptr)->zbitpix, + NULL, status) > 0) + { + ffpmsg("required ZBITPIX compression keyword not found"); + return(*status); + } + + if (ffgky (infptr,TINT, "ZNAXIS", &(infptr->Fptr)->zndim, NULL, status) > 0) + { + ffpmsg("required ZNAXIS compression keyword not found"); + return(*status); + } + + if ((infptr->Fptr)->zndim < 1) + { + ffpmsg("Compressed image has no data (ZNAXIS < 1)"); + return (*status = BAD_NAXIS); + } + + if ((infptr->Fptr)->zndim > MAX_COMPRESS_DIM) + { + ffpmsg("Compressed image has too many dimensions"); + return(*status = BAD_NAXIS); + } + + expect_nrows = 1; + maxtilelen = 1; + for (ii = 0; ii < (infptr->Fptr)->zndim; ii++) + { + /* get image size */ + sprintf (keyword, "ZNAXIS%d", ii+1); + ffgky (infptr, TLONG,keyword, &(infptr->Fptr)->znaxis[ii],NULL,status); + + if (*status > 0) + { + ffpmsg("required ZNAXISn compression keyword not found"); + return(*status); + } + + /* get compression tile size */ + sprintf (keyword, "ZTILE%d", ii+1); + + /* set default tile size in case keywords are not present */ + if (ii == 0) + (infptr->Fptr)->tilesize[0] = (infptr->Fptr)->znaxis[0]; + else + (infptr->Fptr)->tilesize[ii] = 1; + + tstatus = 0; + ffgky (infptr, TLONG, keyword, &(infptr->Fptr)->tilesize[ii], NULL, + &tstatus); + + expect_nrows *= (((infptr->Fptr)->znaxis[ii] - 1) / + (infptr->Fptr)->tilesize[ii]+ 1); + maxtilelen *= (infptr->Fptr)->tilesize[ii]; + } + + /* check number of rows */ + if (expect_nrows != (infptr->Fptr)->numrows) + { + ffpmsg( + "number of table rows != the number of tiles in compressed image"); + return (*status = DATA_DECOMPRESSION_ERR); + } + + /* read any algorithm specific parameters */ + if ((infptr->Fptr)->compress_type == RICE_1 ) + { + if (ffgky(infptr, TINT,"ZVAL1", &(infptr->Fptr)->rice_blocksize, + NULL, status) > 0) + { + ffpmsg("required ZVAL1 compression keyword not found"); + return(*status); + } + + tstatus = 0; + if (ffgky(infptr, TINT,"ZVAL2", &(infptr->Fptr)->rice_bytepix, + NULL, &tstatus) > 0) + { + (infptr->Fptr)->rice_bytepix = 4; /* default value */ + } + + if ((infptr->Fptr)->rice_blocksize < 16 && + (infptr->Fptr)->rice_bytepix > 8) { + /* values are reversed */ + tstatus = (infptr->Fptr)->rice_bytepix; + (infptr->Fptr)->rice_bytepix = (infptr->Fptr)->rice_blocksize; + (infptr->Fptr)->rice_blocksize = tstatus; + } + } else if ((infptr->Fptr)->compress_type == HCOMPRESS_1 ) { + + if (ffgky(infptr, TFLOAT,"ZVAL1", &(infptr->Fptr)->hcomp_scale, + NULL, status) > 0) + { + ffpmsg("required ZVAL1 compression keyword not found"); + return(*status); + } + + tstatus = 0; + ffgky(infptr, TINT,"ZVAL2", &(infptr->Fptr)->hcomp_smooth, + NULL, &tstatus); + } + + /* store number of pixels in each compression tile, */ + /* and max size of the compressed tile buffer */ + (infptr->Fptr)->maxtilelen = maxtilelen; + + (infptr->Fptr)->maxelem = + imcomp_calc_max_elem ((infptr->Fptr)->compress_type, maxtilelen, + (infptr->Fptr)->zbitpix, (infptr->Fptr)->rice_blocksize); + + /* Get Column numbers. */ + if (ffgcno(infptr, CASEINSEN, "COMPRESSED_DATA", + &(infptr->Fptr)->cn_compressed, status) > 0) + { + ffpmsg("couldn't find COMPRESSED_DATA column (fits_get_compressed_img_par)"); + return(*status = DATA_DECOMPRESSION_ERR); + } + + ffpmrk(); /* put mark on message stack; erase any messages after this */ + + tstatus = 0; + ffgcno(infptr,CASEINSEN, "UNCOMPRESSED_DATA", + &(infptr->Fptr)->cn_uncompressed, &tstatus); + + tstatus = 0; + ffgcno(infptr,CASEINSEN, "GZIP_COMPRESSED_DATA", + &(infptr->Fptr)->cn_gzip_data, &tstatus); + + tstatus = 0; + if (ffgcno(infptr, CASEINSEN, "ZSCALE", &(infptr->Fptr)->cn_zscale, + &tstatus) > 0) + { + /* CMPSCALE column doesn't exist; see if there is a keyword */ + tstatus = 0; + if (ffgky(infptr, TDOUBLE, "ZSCALE", &(infptr->Fptr)->zscale, NULL, + &tstatus) <= 0) + (infptr->Fptr)->cn_zscale = -1; /* flag for a constant ZSCALE */ + } + + tstatus = 0; + if (ffgcno(infptr, CASEINSEN, "ZZERO", &(infptr->Fptr)->cn_zzero, + &tstatus) > 0) + { + /* CMPZERO column doesn't exist; see if there is a keyword */ + tstatus = 0; + if (ffgky(infptr, TDOUBLE, "ZZERO", &(infptr->Fptr)->zzero, NULL, + &tstatus) <= 0) + (infptr->Fptr)->cn_zzero = -1; /* flag for a constant ZZERO */ + } + + tstatus = 0; + if (ffgcno(infptr, CASEINSEN, "ZBLANK", &(infptr->Fptr)->cn_zblank, + &tstatus) > 0) + { + /* ZBLANK column doesn't exist; see if there is a keyword */ + tstatus = 0; + if (ffgky(infptr, TINT, "ZBLANK", &(infptr->Fptr)->zblank, NULL, + &tstatus) <= 0) { + (infptr->Fptr)->cn_zblank = -1; /* flag for a constant ZBLANK */ + + } else { + /* ZBLANK keyword doesn't exist; see if there is a BLANK keyword */ + tstatus = 0; + if (ffgky(infptr, TINT, "BLANK", &(infptr->Fptr)->zblank, NULL, + &tstatus) <= 0) + (infptr->Fptr)->cn_zblank = -1; /* flag for a constant ZBLANK */ + } + } + + /* read the conventional BSCALE and BZERO scaling keywords, if present */ + tstatus = 0; + if (ffgky (infptr, TDOUBLE, "BSCALE", &(infptr->Fptr)->cn_bscale, + NULL, &tstatus) > 0) + { + (infptr->Fptr)->cn_bscale = 1.0; + } + + tstatus = 0; + if (ffgky (infptr, TDOUBLE, "BZERO", &(infptr->Fptr)->cn_bzero, + NULL, &tstatus) > 0) + { + (infptr->Fptr)->cn_bzero = 0.0; + (infptr->Fptr)->cn_actual_bzero = 0.0; + } else { + (infptr->Fptr)->cn_actual_bzero = (infptr->Fptr)->cn_bzero; + } + + ffcmrk(); /* clear any spurious error messages, back to the mark */ + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_copy_imheader(fitsfile *infptr, fitsfile *outfptr, int *status) +/* + This routine reads the header keywords from the input image and + copies them to the output image; the manditory structural keywords + and the checksum keywords are not copied. If the DATE keyword is copied, + then it is updated with the current date and time. +*/ +{ + int nkeys, ii, keyclass; + char card[FLEN_CARD]; /* a header record */ + + if (*status > 0) + return(*status); + + ffghsp(infptr, &nkeys, NULL, status); /* get number of keywords in image */ + + for (ii = 5; ii <= nkeys; ii++) /* skip the first 4 keywords */ + { + ffgrec(infptr, ii, card, status); + + keyclass = ffgkcl(card); /* Get the type/class of keyword */ + + /* don't copy structural keywords or checksum keywords */ + if ((keyclass <= TYP_CMPRS_KEY) || (keyclass == TYP_CKSUM_KEY)) + continue; + + if (FSTRNCMP(card, "DATE ", 5) == 0) /* write current date */ + { + ffpdat(outfptr, status); + } + else if (FSTRNCMP(card, "EXTNAME ", 8) == 0) + { + /* don't copy default EXTNAME keyword from a compressed image */ + if (FSTRNCMP(card, "EXTNAME = 'COMPRESSED_IMAGE'", 28)) + { + /* if EXTNAME keyword already exists, overwrite it */ + /* otherwise append a new EXTNAME keyword */ + ffucrd(outfptr, "EXTNAME", card, status); + } + } + else + { + /* just copy the keyword to the output header */ + ffprec (outfptr, card, status); + } + + if (*status > 0) + return (*status); + } + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_copy_img2comp(fitsfile *infptr, fitsfile *outfptr, int *status) +/* + This routine copies the header keywords from the uncompressed input image + and to the compressed image (in a binary table) +*/ +{ + char card[FLEN_CARD], card2[FLEN_CARD]; /* a header record */ + int nkeys, nmore, ii, jj, tstatus, bitpix; + + /* tile compressed image keyword translation table */ + /* INPUT OUTPUT */ + /* 01234567 01234567 */ + char *patterns[][2] = {{"SIMPLE", "ZSIMPLE" }, + {"XTENSION", "ZTENSION" }, + {"BITPIX", "ZBITPIX" }, + {"NAXIS", "ZNAXIS" }, + {"NAXISm", "ZNAXISm" }, + {"EXTEND", "ZEXTEND" }, + {"BLOCKED", "ZBLOCKED"}, + {"PCOUNT", "ZPCOUNT" }, + {"GCOUNT", "ZGCOUNT" }, + + {"CHECKSUM","ZHECKSUM"}, /* save original checksums */ + {"DATASUM", "ZDATASUM"}, + + {"*", "+" }}; /* copy all other keywords */ + int npat; + + if (*status > 0) + return(*status); + + /* write a default EXTNAME keyword if it doesn't exist in input file*/ + fits_read_card(infptr, "EXTNAME", card, status); + + if (*status) { + *status = 0; + strcpy(card, "EXTNAME = 'COMPRESSED_IMAGE'"); + fits_write_record(outfptr, card, status); + } + + /* copy all the keywords from the input file to the output */ + npat = sizeof(patterns)/sizeof(patterns[0][0])/2; + fits_translate_keywords(infptr, outfptr, 1, patterns, npat, + 0, 0, 0, status); + + + if ( (outfptr->Fptr)->request_lossy_int_compress != 0) { + + /* request was made to compress integer images as if they had float pixels. */ + /* If input image has positive bitpix value, then reset the output ZBITPIX */ + /* value to -32. */ + + fits_read_key(infptr, TINT, "BITPIX", &bitpix, NULL, status); + + if (*status <= 0 && bitpix > 0) { + fits_modify_key_lng(outfptr, "ZBITPIX", -32, NULL, status); + + /* also delete the BSCALE, BZERO, and BLANK keywords */ + tstatus = 0; + fits_delete_key(outfptr, "BSCALE", &tstatus); + tstatus = 0; + fits_delete_key(outfptr, "BZERO", &tstatus); + tstatus = 0; + fits_delete_key(outfptr, "BLANK", &tstatus); + } + } + + /* + For compatibility with software that uses an older version of CFITSIO, + we must make certain that the new ZQUANTIZ keyword, if it exists, must + occur after the other peudo-required keywords (e.g., ZSIMPLE, ZBITPIX, + etc.). Do this by trying to delete the keyword. If that succeeds (and + thus the keyword did exist) then rewrite the keyword at the end of header. + In principle this should not be necessary once all software has upgraded + to a newer version of CFITSIO (version number greater than 3.181, newer + than August 2009). + + Do the same for the new ZDITHER0 keyword. + */ + + tstatus = 0; + if (fits_read_card(outfptr, "ZQUANTIZ", card, &tstatus) == 0) + { + fits_delete_key(outfptr, "ZQUANTIZ", status); + + /* rewrite the deleted keyword at the end of the header */ + fits_write_record(outfptr, card, status); + + fits_write_history(outfptr, + "Image was compressed by CFITSIO using scaled integer quantization:", status); + sprintf(card2, " q = %f / quantized level scaling parameter", + (outfptr->Fptr)->quantize_level); + fits_write_history(outfptr, card2, status); + fits_write_history(outfptr, card+10, status); + } + + tstatus = 0; + if (fits_read_card(outfptr, "ZDITHER0", card, &tstatus) == 0) + { + fits_delete_key(outfptr, "ZDITHER0", status); + + /* rewrite the deleted keyword at the end of the header */ + fits_write_record(outfptr, card, status); + } + + + ffghsp(infptr, &nkeys, &nmore, status); /* get number of keywords in image */ + + nmore = nmore / 36; /* how many completely empty header blocks are there? */ + + /* preserve the same number of spare header blocks in the output header */ + + for (jj = 0; jj < nmore; jj++) + for (ii = 0; ii < 36; ii++) + fits_write_record(outfptr, " ", status); + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_copy_comp2img(fitsfile *infptr, fitsfile *outfptr, + int norec, int *status) +/* + This routine copies the header keywords from the compressed input image + and to the uncompressed image (in a binary table) +*/ +{ + char card[FLEN_CARD]; /* a header record */ + char *patterns[40][2]; + char negative[] = "-"; + int ii,jj, npat, nreq, nsp, tstatus = 0; + int nkeys, nmore; + + /* tile compressed image keyword translation table */ + /* INPUT OUTPUT */ + /* 01234567 01234567 */ + + /* only translate these if required keywords not already written */ + char *reqkeys[][2] = { + {"ZSIMPLE", "SIMPLE" }, + {"ZTENSION", "XTENSION"}, + {"ZBITPIX", "BITPIX" }, + {"ZNAXIS", "NAXIS" }, + {"ZNAXISm", "NAXISm" }, + {"ZEXTEND", "EXTEND" }, + {"ZBLOCKED", "BLOCKED"}, + {"ZPCOUNT", "PCOUNT" }, + {"ZGCOUNT", "GCOUNT" }, + {"ZHECKSUM", "CHECKSUM"}, /* restore original checksums */ + {"ZDATASUM", "DATASUM"}}; + + /* other special keywords */ + char *spkeys[][2] = { + {"XTENSION", "-" }, + {"BITPIX", "-" }, + {"NAXIS", "-" }, + {"NAXISm", "-" }, + {"PCOUNT", "-" }, + {"GCOUNT", "-" }, + {"TFIELDS", "-" }, + {"TTYPEm", "-" }, + {"TFORMm", "-" }, + {"ZIMAGE", "-" }, + {"ZQUANTIZ", "-" }, + {"ZDITHER0", "-" }, + {"ZTILEm", "-" }, + {"ZCMPTYPE", "-" }, + {"ZBLANK", "-" }, + {"ZNAMEm", "-" }, + {"ZVALm", "-" }, + + {"CHECKSUM","-" }, /* delete checksums */ + {"DATASUM", "-" }, + {"EXTNAME", "+" }, /* we may change this, below */ + {"*", "+" }}; + + + if (*status > 0) + return(*status); + + nreq = sizeof(reqkeys)/sizeof(reqkeys[0][0])/2; + nsp = sizeof(spkeys)/sizeof(spkeys[0][0])/2; + + /* construct translation patterns */ + + for (ii = 0; ii < nreq; ii++) { + patterns[ii][0] = reqkeys[ii][0]; + + if (norec) + patterns[ii][1] = negative; + else + patterns[ii][1] = reqkeys[ii][1]; + } + + for (ii = 0; ii < nsp; ii++) { + patterns[ii+nreq][0] = spkeys[ii][0]; + patterns[ii+nreq][1] = spkeys[ii][1]; + } + + npat = nreq + nsp; + + /* see if the EXTNAME keyword should be copied or not */ + fits_read_card(infptr, "EXTNAME", card, &tstatus); + + if (tstatus == 0) { + if (!strncmp(card, "EXTNAME = 'COMPRESSED_IMAGE'", 28)) + patterns[npat-2][1] = negative; + } + + /* translate and copy the keywords from the input file to the output */ + fits_translate_keywords(infptr, outfptr, 1, patterns, npat, + 0, 0, 0, status); + + ffghsp(infptr, &nkeys, &nmore, status); /* get number of keywords in image */ + + nmore = nmore / 36; /* how many completely empty header blocks are there? */ + + /* preserve the same number of spare header blocks in the output header */ + + for (jj = 0; jj < nmore; jj++) + for (ii = 0; ii < 36; ii++) + fits_write_record(outfptr, " ", status); + + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_copy_prime2img(fitsfile *infptr, fitsfile *outfptr, int *status) +/* + This routine copies any unexpected keywords from the primary array + of the compressed input image into the header of the uncompressed image + (which is the primary array of the output file). +*/ +{ + int nsp; + + /* keywords that will not be copied */ + char *spkeys[][2] = { + {"SIMPLE", "-" }, + {"BITPIX", "-" }, + {"NAXIS", "-" }, + {"NAXISm", "-" }, + {"PCOUNT", "-" }, + {"EXTEND", "-" }, + {"GCOUNT", "-" }, + {"CHECKSUM","-" }, + {"DATASUM", "-" }, + {"EXTNAME", "-" }, + {"HISTORY", "-" }, + {"COMMENT", "-" }, + {"*", "+" }}; + + if (*status > 0) + return(*status); + + nsp = sizeof(spkeys)/sizeof(spkeys[0][0])/2; + + /* translate and copy the keywords from the input file to the output */ + fits_translate_keywords(infptr, outfptr, 1, spkeys, nsp, + 0, 0, 0, status); + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_decompress_tile (fitsfile *infptr, + int nrow, /* I - row of table to read and uncompress */ + int tilelen, /* I - number of pixels in the tile */ + int datatype, /* I - datatype to be returned in 'buffer' */ + int nullcheck, /* I - 0 for no null checking */ + void *nulval, /* I - value to be used for undefined pixels */ + void *buffer, /* O - buffer for returned decompressed values */ + char *bnullarray, /* O - buffer for returned null flags */ + int *anynul, /* O - any null values returned? */ + int *status) + +/* This routine decompresses one tile of the image */ +{ + int *idata = 0; + int tiledatatype, pixlen; /* uncompressed integer data */ + size_t idatalen, tilebytesize; + int ii, tnull; /* value in the data which represents nulls */ + unsigned char *cbuf; /* compressed data */ + unsigned char charnull = 0; + short snull = 0; + int blocksize; + float fnulval=0; + float *tempfloat = 0; + double dnulval=0; + double bscale, bzero, actual_bzero, dummy = 0; /* scaling parameters */ + long nelem = 0, offset = 0, tilesize; /* number of bytes */ + int smooth, nx, ny, scale; /* hcompress parameters */ + + if (*status > 0) + return(*status); + + /* **************************************************************** */ + /* check if this tile was cached; if so, just copy it out */ + if (nrow == (infptr->Fptr)->tilerow && datatype == (infptr->Fptr)->tiletype ) { + + memcpy(buffer, (infptr->Fptr)->tiledata, (infptr->Fptr)->tiledatasize); + + if (nullcheck == 2) + memcpy(bnullarray, (infptr->Fptr)->tilenullarray, tilelen); + + *anynul = (infptr->Fptr)->tileanynull; + return(*status); + } + + /* **************************************************************** */ + /* get length of the compressed byte stream */ + ffgdes (infptr, (infptr->Fptr)->cn_compressed, nrow, &nelem, &offset, + status); + + /* EOF error here indicates that this tile has not yet been written */ + if (*status == END_OF_FILE) + return(*status = NO_COMPRESSED_TILE); + + /* **************************************************************** */ + if (nelem == 0) /* special case: tile was not compressed normally */ + { + if ((infptr->Fptr)->cn_uncompressed >= 1 ) { + + /* This option of writing the uncompressed floating point data */ + /* to the tile compressed file was used until about May 2011. */ + /* This was replaced by the more efficient option of gzipping the */ + /* floating point data before writing it to the tile-compressed file */ + + /* no compressed data, so simply read the uncompressed data */ + /* directly from the UNCOMPRESSED_DATA column */ + ffgdes (infptr, (infptr->Fptr)->cn_uncompressed, nrow, &nelem, + &offset, status); + + if (nelem == 0 && offset == 0) /* this should never happen */ + return (*status = NO_COMPRESSED_TILE); + + if (nullcheck <= 1) { /* set any null values in the array = nulval */ + fits_read_col(infptr, datatype, (infptr->Fptr)->cn_uncompressed, + nrow, 1, nelem, nulval, buffer, anynul, status); + } else { /* set the bnullarray = 1 for any null values in the array */ + fits_read_colnull(infptr, datatype, (infptr->Fptr)->cn_uncompressed, + nrow, 1, nelem, buffer, bnullarray, anynul, status); + } + } else if ((infptr->Fptr)->cn_gzip_data >= 1) { + + /* This is the newer option, that was introduced in May 2011 */ + /* floating point data was not quantized, so read the losslessly */ + /* compressed data from the GZIP_COMPRESSED_DATA column */ + + ffgdes (infptr, (infptr->Fptr)->cn_gzip_data, nrow, &nelem, + &offset, status); + + if (nelem == 0 && offset == 0) /* this should never happen */ + return (*status = NO_COMPRESSED_TILE); + + /* allocate memory for the compressed tile of data */ + cbuf = (unsigned char *) malloc (nelem); + if (cbuf == NULL) { + ffpmsg("error allocating memory for gzipped tile (imcomp_decompress_tile)"); + return (*status = MEMORY_ALLOCATION); + } + + /* read array of compressed bytes */ + if (fits_read_col(infptr, TBYTE, (infptr->Fptr)->cn_gzip_data, nrow, + 1, nelem, &charnull, cbuf, NULL, status) > 0) { + ffpmsg("error reading compressed byte stream from binary table"); + free (cbuf); + return (*status); + } + + /* size of the returned (uncompressed) data buffer, in bytes */ + if ((infptr->Fptr)->zbitpix == FLOAT_IMG) { + idatalen = tilelen * sizeof(float); + } else if ((infptr->Fptr)->zbitpix == DOUBLE_IMG) { + idatalen = tilelen * sizeof(double); + } else { + /* this should never happen! */ + ffpmsg("incompatible data type in gzipped floating-point tile-compressed image"); + free (cbuf); + return (*status = DATA_DECOMPRESSION_ERR); + } + + if (datatype == TDOUBLE && (infptr->Fptr)->zbitpix == FLOAT_IMG) { + /* have to allocat a temporary buffer for the uncompressed data in the */ + /* case where a gzipped "float" tile is returned as a "double" array */ + tempfloat = (float*) malloc (idatalen); + + if (tempfloat == NULL) { + ffpmsg("Memory allocation failure for tempfloat. (imcomp_decompress_tile)"); + free (cbuf); + return (*status = MEMORY_ALLOCATION); + } + + /* uncompress the data into temp buffer */ + if (uncompress2mem_from_mem ((char *)cbuf, nelem, + (char **) &tempfloat, &idatalen, NULL, &tilebytesize, status)) { + ffpmsg("failed to gunzip the image tile"); + free (tempfloat); + free (cbuf); + return (*status); + } + } else { + + /* uncompress the data directly into the output buffer in all other cases */ + if (uncompress2mem_from_mem ((char *)cbuf, nelem, + (char **) &buffer, &idatalen, NULL, &tilebytesize, status)) { + ffpmsg("failed to gunzip the image tile"); + free (cbuf); + return (*status); + } + } + + free(cbuf); + + /* do byte swapping and null value substitution for the tile of pixels */ + if (tilebytesize == 4 * tilelen) { /* float pixels */ + +#if BYTESWAPPED + if (tempfloat) + ffswap4((int *) tempfloat, tilelen); + else + ffswap4((int *) buffer, tilelen); +#endif + if (datatype == TFLOAT) { + if (nulval) { + fnulval = *(float *) nulval; + } + + fffr4r4((float *) buffer, (long) tilelen, 1., 0., nullcheck, + fnulval, bnullarray, anynul, + (float *) buffer, status); + } else if (datatype == TDOUBLE) { + if (nulval) { + dnulval = *(double *) nulval; + } + + /* note that the R*4 data are in the tempfloat array in this case */ + fffr4r8((float *) tempfloat, (long) tilelen, 1., 0., nullcheck, + dnulval, bnullarray, anynul, + (double *) buffer, status); + free(tempfloat); + + } else { + ffpmsg("implicit data type conversion is not supported for gzipped image tiles"); + return (*status = DATA_DECOMPRESSION_ERR); + } + } else if (tilebytesize == 8 * tilelen) { /* double pixels */ + +#if BYTESWAPPED + ffswap8((double *) buffer, tilelen); +#endif + if (datatype == TFLOAT) { + if (nulval) { + fnulval = *(float *) nulval; + } + + fffr8r4((double *) buffer, (long) tilelen, 1., 0., nullcheck, + fnulval, bnullarray, anynul, + (float *) buffer, status); + } else if (datatype == TDOUBLE) { + if (nulval) { + dnulval = *(double *) nulval; + } + + fffr8r8((double *) buffer, (long) tilelen, 1., 0., nullcheck, + dnulval, bnullarray, anynul, + (double *) buffer, status); + } else { + ffpmsg("implicit data type conversion is not supported in tile-compressed images"); + return (*status = DATA_DECOMPRESSION_ERR); + } + } else { + ffpmsg("error: uncompressed tile has wrong size"); + return (*status = DATA_DECOMPRESSION_ERR); + } + + /* end of special case of losslessly gzipping a floating-point image tile */ + } else { /* this should never happen */ + *status = NO_COMPRESSED_TILE; + } + + return(*status); + } + + /* **************************************************************** */ + /* deal with the normal case of a compressed tile of pixels */ + if (nullcheck == 2) { + for (ii = 0; ii < tilelen; ii++) /* initialize the null flage array */ + bnullarray[ii] = 0; + } + + if (anynul) + *anynul = 0; + + /* get linear scaling and offset values, if they exist */ + actual_bzero = (infptr->Fptr)->cn_actual_bzero; + if ((infptr->Fptr)->cn_zscale == 0) { + /* set default scaling, if scaling is not defined */ + bscale = 1.; + bzero = 0.; + } else if ((infptr->Fptr)->cn_zscale == -1) { + bscale = (infptr->Fptr)->zscale; + bzero = (infptr->Fptr)->zzero; + } else { + /* read the linear scale and offset values for this row */ + ffgcvd (infptr, (infptr->Fptr)->cn_zscale, nrow, 1, 1, 0., + &bscale, NULL, status); + ffgcvd (infptr, (infptr->Fptr)->cn_zzero, nrow, 1, 1, 0., + &bzero, NULL, status); + if (*status > 0) + { + ffpmsg("error reading scaling factor and offset for compressed tile"); + return (*status); + } + + /* test if floating-point FITS image also has non-default BSCALE and */ + /* BZERO keywords. If so, we have to combine the 2 linear scaling factors. */ + + if ( ((infptr->Fptr)->zbitpix == FLOAT_IMG || + (infptr->Fptr)->zbitpix == DOUBLE_IMG ) + && + ((infptr->Fptr)->cn_bscale != 1.0 || + (infptr->Fptr)->cn_bzero != 0.0 ) ) + { + bscale = bscale * (infptr->Fptr)->cn_bscale; + bzero = bzero * (infptr->Fptr)->cn_bscale + (infptr->Fptr)->cn_bzero; + } + } + + if (bscale == 1.0 && bzero == 0.0 ) { + /* if no other scaling has been specified, try using the values + given by the BSCALE and BZERO keywords, if any */ + + bscale = (infptr->Fptr)->cn_bscale; + bzero = (infptr->Fptr)->cn_bzero; + } + + /* ************************************************************* */ + /* get the value used to represent nulls in the int array */ + if ((infptr->Fptr)->cn_zblank == 0) { + nullcheck = 0; /* no null value; don't check for nulls */ + } else if ((infptr->Fptr)->cn_zblank == -1) { + tnull = (infptr->Fptr)->zblank; /* use the the ZBLANK keyword */ + } else { + /* read the null value for this row */ + ffgcvk (infptr, (infptr->Fptr)->cn_zblank, nrow, 1, 1, 0, + &tnull, NULL, status); + if (*status > 0) { + ffpmsg("error reading null value for compressed tile"); + return (*status); + } + } + + /* ************************************************************* */ + /* allocate memory for the uncompressed array of tile integers */ + /* The size depends on the datatype and the compression type. */ + + if ((infptr->Fptr)->compress_type == HCOMPRESS_1 && + ((infptr->Fptr)->zbitpix != BYTE_IMG && + (infptr->Fptr)->zbitpix != SHORT_IMG) ) { + + idatalen = tilelen * sizeof(LONGLONG); /* 8 bytes per pixel */ + + } else if ( (infptr->Fptr)->compress_type == RICE_1 && + (infptr->Fptr)->zbitpix == BYTE_IMG && + (infptr->Fptr)->rice_bytepix == 1) { + + idatalen = tilelen * sizeof(char); /* 1 byte per pixel */ + } else if ( ( (infptr->Fptr)->compress_type == GZIP_1 || + (infptr->Fptr)->compress_type == GZIP_2 || + (infptr->Fptr)->compress_type == BZIP2_1 ) && + (infptr->Fptr)->zbitpix == BYTE_IMG ) { + + idatalen = tilelen * sizeof(char); /* 1 byte per pixel */ + } else if ( (infptr->Fptr)->compress_type == RICE_1 && + (infptr->Fptr)->zbitpix == SHORT_IMG && + (infptr->Fptr)->rice_bytepix == 2) { + + idatalen = tilelen * sizeof(short); /* 2 bytes per pixel */ + } else if ( ( (infptr->Fptr)->compress_type == GZIP_1 || + (infptr->Fptr)->compress_type == GZIP_2 || + (infptr->Fptr)->compress_type == BZIP2_1 ) && + (infptr->Fptr)->zbitpix == SHORT_IMG ) { + + idatalen = tilelen * sizeof(short); /* 2 bytes per pixel */ + } else if ( ( (infptr->Fptr)->compress_type == GZIP_1 || + (infptr->Fptr)->compress_type == GZIP_2 || + (infptr->Fptr)->compress_type == BZIP2_1 ) && + (infptr->Fptr)->zbitpix == DOUBLE_IMG ) { + + idatalen = tilelen * sizeof(double); /* 8 bytes per pixel */ + } else { + idatalen = tilelen * sizeof(int); /* all other cases have int pixels */ + } + + idata = (int*) malloc (idatalen); + if (idata == NULL) { + ffpmsg("Memory allocation failure for idata. (imcomp_decompress_tile)"); + return (*status = MEMORY_ALLOCATION); + } + + /* ************************************************************* */ + /* allocate memory for the compressed bytes */ + + if ((infptr->Fptr)->compress_type == PLIO_1) { + cbuf = (unsigned char *) malloc (nelem * sizeof (short)); + } else { + cbuf = (unsigned char *) malloc (nelem); + } + if (cbuf == NULL) { + ffpmsg("Out of memory for cbuf. (imcomp_decompress_tile)"); + free(idata); + return (*status = MEMORY_ALLOCATION); + } + + /* ************************************************************* */ + /* read the compressed bytes from the FITS file */ + + if ((infptr->Fptr)->compress_type == PLIO_1) { + fits_read_col(infptr, TSHORT, (infptr->Fptr)->cn_compressed, nrow, + 1, nelem, &snull, (short *) cbuf, NULL, status); + } else { + fits_read_col(infptr, TBYTE, (infptr->Fptr)->cn_compressed, nrow, + 1, nelem, &charnull, cbuf, NULL, status); + } + + if (*status > 0) { + ffpmsg("error reading compressed byte stream from binary table"); + free (cbuf); + free(idata); + return (*status); + } + + /* ************************************************************* */ + /* call the algorithm-specific code to uncompress the tile */ + + if ((infptr->Fptr)->compress_type == RICE_1) { + + blocksize = (infptr->Fptr)->rice_blocksize; + + if ((infptr->Fptr)->rice_bytepix == 1 ) { + *status = fits_rdecomp_byte (cbuf, nelem, (unsigned char *)idata, + tilelen, blocksize); + tiledatatype = TBYTE; + } else if ((infptr->Fptr)->rice_bytepix == 2 ) { + *status = fits_rdecomp_short (cbuf, nelem, (unsigned short *)idata, + tilelen, blocksize); + tiledatatype = TSHORT; + } else { + *status = fits_rdecomp (cbuf, nelem, (unsigned int *)idata, + tilelen, blocksize); + tiledatatype = TINT; + } + + /* ************************************************************* */ + } else if ((infptr->Fptr)->compress_type == HCOMPRESS_1) { + + smooth = (infptr->Fptr)->hcomp_smooth; + + if ( ((infptr->Fptr)->zbitpix == BYTE_IMG || (infptr->Fptr)->zbitpix == SHORT_IMG)) { + *status = fits_hdecompress(cbuf, smooth, idata, &nx, &ny, + &scale, status); + } else { /* zbitpix = LONG_IMG (32) */ + /* idata must have been allocated twice as large for this to work */ + *status = fits_hdecompress64(cbuf, smooth, (LONGLONG *) idata, &nx, &ny, + &scale, status); + } + + tiledatatype = TINT; + + /* ************************************************************* */ + } else if ((infptr->Fptr)->compress_type == PLIO_1) { + + pl_l2pi ((short *) cbuf, 1, idata, tilelen); /* uncompress the data */ + tiledatatype = TINT; + + /* ************************************************************* */ + } else if ( ((infptr->Fptr)->compress_type == GZIP_1) || + ((infptr->Fptr)->compress_type == GZIP_2) ) { + + uncompress2mem_from_mem ((char *)cbuf, nelem, + (char **) &idata, &idatalen, realloc, &tilebytesize, status); + + /* determine the data type of the uncompressed array, and */ + /* do byte unshuffling and unswapping if needed */ + if (tilebytesize == (size_t) (tilelen * 2)) { + /* this is a short I*2 array */ + tiledatatype = TSHORT; + + if ( (infptr->Fptr)->compress_type == GZIP_2 ) + fits_unshuffle_2bytes((char *) idata, tilelen, status); + +#if BYTESWAPPED + ffswap2((short *) idata, tilelen); +#endif + + } else if (tilebytesize == (size_t) (tilelen * 4)) { + /* this is a int I*4 array (or maybe R*4) */ + tiledatatype = TINT; + + if ( (infptr->Fptr)->compress_type == GZIP_2 ) + fits_unshuffle_4bytes((char *) idata, tilelen, status); + +#if BYTESWAPPED + ffswap4(idata, tilelen); +#endif + + } else if (tilebytesize == (size_t) (tilelen * 8)) { + /* this is a R*8 double array */ + tiledatatype = TDOUBLE; + + if ( (infptr->Fptr)->compress_type == GZIP_2 ) + fits_unshuffle_8bytes((char *) idata, tilelen, status); +#if BYTESWAPPED + ffswap8((double *) idata, tilelen); +#endif + + } else if (tilebytesize == (size_t) tilelen) { + + /* this is an unsigned char I*1 array */ + tiledatatype = TBYTE; + + } else { + ffpmsg("error: uncompressed tile has wrong size"); + free(idata); + return (*status = DATA_DECOMPRESSION_ERR); + } + + /* ************************************************************* */ + } else if ((infptr->Fptr)->compress_type == BZIP2_1) { + +/* BZIP2 is not supported in the public release; this is only for test purposes + + if (BZ2_bzBuffToBuffDecompress ((char *) idata, &idatalen, + (char *)cbuf, (unsigned int) nelem, 0, 0) ) +*/ + { + ffpmsg("bzip2 decompression error"); + free(idata); + free (cbuf); + return (*status = DATA_DECOMPRESSION_ERR); + } + + if ((infptr->Fptr)->zbitpix == BYTE_IMG) { + tiledatatype = TBYTE; + } else if ((infptr->Fptr)->zbitpix == SHORT_IMG) { + tiledatatype = TSHORT; +#if BYTESWAPPED + ffswap2((short *) idata, tilelen); +#endif + } else { + tiledatatype = TINT; +#if BYTESWAPPED + ffswap4(idata, tilelen); +#endif + } + + /* ************************************************************* */ + } else { + ffpmsg("unknown compression algorithm"); + free(idata); + return (*status = DATA_DECOMPRESSION_ERR); + } + + free(cbuf); + if (*status) { /* error uncompressing the tile */ + free(idata); + return (*status); + } + + /* ************************************************************* */ + /* copy the uncompressed tile data to the output buffer, doing */ + /* null checking, datatype conversion and linear scaling, if necessary */ + + if (nulval == 0) + nulval = &dummy; /* set address to dummy value */ + + if (datatype == TSHORT) + { + pixlen = sizeof(short); + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4i2((float *) idata, tilelen, bscale, bzero, nullcheck, + *(short *) nulval, bnullarray, anynul, + (short *) buffer, status); + } else { + fffr8i2((double *) idata, tilelen, bscale, bzero, nullcheck, + *(short *) nulval, bnullarray, anynul, + (short *) buffer, status); + } + } else if (tiledatatype == TINT) + if ((infptr->Fptr)->compress_type == PLIO_1 && + bzero == 0. && actual_bzero == 32768.) { + /* special case where unsigned 16-bit integers have been */ + /* offset by +32768 when using PLIO */ + fffi4i2(idata, tilelen, bscale, -32768., nullcheck, tnull, + *(short *) nulval, bnullarray, anynul, + (short *) buffer, status); + } else { + fffi4i2(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(short *) nulval, bnullarray, anynul, + (short *) buffer, status); + } + else if (tiledatatype == TSHORT) + fffi2i2((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(short *) nulval, bnullarray, anynul, + (short *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1i2((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(short *) nulval, bnullarray, anynul, + (short *) buffer, status); + } + else if (datatype == TINT) + { + pixlen = sizeof(int); + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4int((float *) idata, tilelen, bscale, bzero, nullcheck, + *(int *) nulval, bnullarray, anynul, + (int *) buffer, status); + } else { + fffr8int((double *) idata, tilelen, bscale, bzero, nullcheck, + *(int *) nulval, bnullarray, anynul, + (int *) buffer, status); + } + } else if (tiledatatype == TINT) + fffi4int(idata, (long) tilelen, bscale, bzero, nullcheck, tnull, + *(int *) nulval, bnullarray, anynul, + (int *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2int((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(int *) nulval, bnullarray, anynul, + (int *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1int((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(int *) nulval, bnullarray, anynul, + (int *) buffer, status); + } + else if (datatype == TLONG) + { + pixlen = sizeof(long); + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4i4((float *) idata, tilelen, bscale, bzero, nullcheck, + *(long *) nulval, bnullarray, anynul, + (long *) buffer, status); + } else { + fffr8i4((double *) idata, tilelen, bscale, bzero, nullcheck, + *(long *) nulval, bnullarray, anynul, + (long *) buffer, status); + } + } else if (tiledatatype == TINT) + fffi4i4(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(long *) nulval, bnullarray, anynul, + (long *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2i4((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(long *) nulval, bnullarray, anynul, + (long *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1i4((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(long *) nulval, bnullarray, anynul, + (long *) buffer, status); + } + else if (datatype == TFLOAT) + { + pixlen = sizeof(float); + if (nulval) { + fnulval = *(float *) nulval; + } + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4r4((float *) idata, tilelen, bscale, bzero, nullcheck, + fnulval, bnullarray, anynul, + (float *) buffer, status); + } else { + fffr8r4((double *) idata, tilelen, bscale, bzero, nullcheck, + fnulval, bnullarray, anynul, + (float *) buffer, status); + } + + } else if ((infptr->Fptr)->quantize_dither == SUBTRACTIVE_DITHER_1) { + + /* use the new dithering algorithm (introduced in July 2009) */ + + if (tiledatatype == TINT) + unquantize_i4r4(nrow + (infptr->Fptr)->dither_offset - 1, idata, + tilelen, bscale, bzero, nullcheck, tnull, + fnulval, bnullarray, anynul, + (float *) buffer, status); + else if (tiledatatype == TSHORT) + unquantize_i2r4(nrow + (infptr->Fptr)->dither_offset - 1, (short *)idata, + tilelen, bscale, bzero, nullcheck, (short) tnull, + fnulval, bnullarray, anynul, + (float *) buffer, status); + else if (tiledatatype == TBYTE) + unquantize_i1r4(nrow + (infptr->Fptr)->dither_offset - 1, (unsigned char *)idata, + tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + fnulval, bnullarray, anynul, + (float *) buffer, status); + + } else { /* use the old "round to nearest level" quantization algorithm */ + + if (tiledatatype == TINT) + fffi4r4(idata, tilelen, bscale, bzero, nullcheck, tnull, + fnulval, bnullarray, anynul, + (float *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2r4((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + fnulval, bnullarray, anynul, + (float *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1r4((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + fnulval, bnullarray, anynul, + (float *) buffer, status); + } + } + else if (datatype == TDOUBLE) + { + pixlen = sizeof(double); + if (nulval) { + dnulval = *(double *) nulval; + } + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4r8((float *) idata, tilelen, bscale, bzero, nullcheck, + dnulval, bnullarray, anynul, + (double *) buffer, status); + } else { + fffr8r8((double *) idata, tilelen, bscale, bzero, nullcheck, + dnulval, bnullarray, anynul, + (double *) buffer, status); + } + + } else if ((infptr->Fptr)->quantize_dither == SUBTRACTIVE_DITHER_1) { + + /* use the new dithering algorithm (introduced in July 2009) */ + if (tiledatatype == TINT) + unquantize_i4r8(nrow + (infptr->Fptr)->dither_offset - 1, idata, + tilelen, bscale, bzero, nullcheck, tnull, + dnulval, bnullarray, anynul, + (double *) buffer, status); + else if (tiledatatype == TSHORT) + unquantize_i2r8(nrow + (infptr->Fptr)->dither_offset - 1, (short *)idata, + tilelen, bscale, bzero, nullcheck, (short) tnull, + dnulval, bnullarray, anynul, + (double *) buffer, status); + else if (tiledatatype == TBYTE) + unquantize_i1r8(nrow + (infptr->Fptr)->dither_offset - 1, (unsigned char *)idata, + tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + dnulval, bnullarray, anynul, + (double *) buffer, status); + + } else { /* use the old "round to nearest level" quantization algorithm */ + + if (tiledatatype == TINT) + fffi4r8(idata, tilelen, bscale, bzero, nullcheck, tnull, + dnulval, bnullarray, anynul, + (double *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2r8((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + dnulval, bnullarray, anynul, + (double *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1r8((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + dnulval, bnullarray, anynul, + (double *) buffer, status); + } + } + else if (datatype == TBYTE) + { + pixlen = sizeof(char); + if (tiledatatype == TINT) + fffi4i1(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(unsigned char *) nulval, bnullarray, anynul, + (unsigned char *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2i1((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(unsigned char *) nulval, bnullarray, anynul, + (unsigned char *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1i1((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(unsigned char *) nulval, bnullarray, anynul, + (unsigned char *) buffer, status); + } + else if (datatype == TSBYTE) + { + pixlen = sizeof(char); + if (tiledatatype == TINT) + fffi4s1(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(signed char *) nulval, bnullarray, anynul, + (signed char *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2s1((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(signed char *) nulval, bnullarray, anynul, + (signed char *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1s1((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(signed char *) nulval, bnullarray, anynul, + (signed char *) buffer, status); + } + else if (datatype == TUSHORT) + { + pixlen = sizeof(short); + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4u2((float *) idata, tilelen, bscale, bzero, nullcheck, + *(unsigned short *) nulval, bnullarray, anynul, + (unsigned short *) buffer, status); + } else { + fffr8u2((double *) idata, tilelen, bscale, bzero, nullcheck, + *(unsigned short *) nulval, bnullarray, anynul, + (unsigned short *) buffer, status); + } + } else if (tiledatatype == TINT) + fffi4u2(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(unsigned short *) nulval, bnullarray, anynul, + (unsigned short *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2u2((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(unsigned short *) nulval, bnullarray, anynul, + (unsigned short *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1u2((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(unsigned short *) nulval, bnullarray, anynul, + (unsigned short *) buffer, status); + } + else if (datatype == TUINT) + { + pixlen = sizeof(int); + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4uint((float *) idata, tilelen, bscale, bzero, nullcheck, + *(unsigned int *) nulval, bnullarray, anynul, + (unsigned int *) buffer, status); + } else { + fffr8uint((double *) idata, tilelen, bscale, bzero, nullcheck, + *(unsigned int *) nulval, bnullarray, anynul, + (unsigned int *) buffer, status); + } + } else if (tiledatatype == TINT) + fffi4uint(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(unsigned int *) nulval, bnullarray, anynul, + (unsigned int *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2uint((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(unsigned int *) nulval, bnullarray, anynul, + (unsigned int *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1uint((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(unsigned int *) nulval, bnullarray, anynul, + (unsigned int *) buffer, status); + } + else if (datatype == TULONG) + { + pixlen = sizeof(long); + + if ((infptr->Fptr)->quantize_level == NO_QUANTIZE) { + /* the floating point pixels were losselessly compressed with GZIP */ + /* Just have to copy the values to the output array */ + + if (tiledatatype == TINT) { + fffr4u4((float *) idata, tilelen, bscale, bzero, nullcheck, + *(unsigned long *) nulval, bnullarray, anynul, + (unsigned long *) buffer, status); + } else { + fffr8u4((double *) idata, tilelen, bscale, bzero, nullcheck, + *(unsigned long *) nulval, bnullarray, anynul, + (unsigned long *) buffer, status); + } + } else if (tiledatatype == TINT) + fffi4u4(idata, tilelen, bscale, bzero, nullcheck, tnull, + *(unsigned long *) nulval, bnullarray, anynul, + (unsigned long *) buffer, status); + else if (tiledatatype == TSHORT) + fffi2u4((short *)idata, tilelen, bscale, bzero, nullcheck, (short) tnull, + *(unsigned long *) nulval, bnullarray, anynul, + (unsigned long *) buffer, status); + else if (tiledatatype == TBYTE) + fffi1u4((unsigned char *)idata, tilelen, bscale, bzero, nullcheck, (unsigned char) tnull, + *(unsigned long *) nulval, bnullarray, anynul, + (unsigned long *) buffer, status); + } + else + *status = BAD_DATATYPE; + + free(idata); /* don't need the uncompressed tile any more */ + + /* **************************************************************** */ + /* cache the tile, in case the application wants it again */ + + /* Don't cache the tile if tile is a single row of the image; + it is less likely that the cache will be used in this cases, + so it is not worth the time and the memory overheads. + */ + if ((infptr->Fptr)->znaxis[0] != (infptr->Fptr)->tilesize[0] || + (infptr->Fptr)->tilesize[1] != 1 ) + { + tilesize = pixlen * tilelen; + + /* check that tile size/type has not changed */ + if (tilesize != (infptr->Fptr)->tiledatasize || + datatype != (infptr->Fptr)->tiletype ) { + + if ((infptr->Fptr)->tiledata) { + free((infptr->Fptr)->tiledata); + } + + (infptr->Fptr)->tiledata = 0; + + if ((infptr->Fptr)->tilenullarray) { + free((infptr->Fptr)->tilenullarray); + } + + (infptr->Fptr)->tilenullarray = 0; + (infptr->Fptr)->tilerow = 0; + (infptr->Fptr)->tiledatasize = 0; + (infptr->Fptr)->tiletype = 0; + + /* allocate new array(s) */ + (infptr->Fptr)->tiledata = malloc(tilesize); + if ((infptr->Fptr)->tiledata == 0) + return (*status); + + if (nullcheck == 2) { /* also need array of null pixel flags */ + (infptr->Fptr)->tilenullarray = malloc(tilelen); + if ((infptr->Fptr)->tilenullarray == 0) + return (*status); + } + + (infptr->Fptr)->tiledatasize = tilesize; + (infptr->Fptr)->tiletype = datatype; + } + + /* copy the tile array(s) into cache buffer */ + memcpy((infptr->Fptr)->tiledata, buffer, tilesize); + + if (nullcheck == 2) { + if ((infptr->Fptr)->tilenullarray == 0) { + (infptr->Fptr)->tilenullarray = malloc(tilelen); + } + memcpy((infptr->Fptr)->tilenullarray, bnullarray, tilelen); + } + + (infptr->Fptr)->tilerow = nrow; + (infptr->Fptr)->tileanynull = *anynul; + } + + return (*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_copy_overlap ( + char *tile, /* I - multi dimensional array of tile pixels */ + int pixlen, /* I - number of bytes in each tile or image pixel */ + int ndim, /* I - number of dimension in the tile and image */ + long *tfpixel, /* I - first pixel number in each dim. of the tile */ + long *tlpixel, /* I - last pixel number in each dim. of the tile */ + char *bnullarray, /* I - array of null flags; used if nullcheck = 2 */ + char *image, /* O - multi dimensional output image */ + long *fpixel, /* I - first pixel number in each dim. of the image */ + long *lpixel, /* I - last pixel number in each dim. of the image */ + long *ininc, /* I - increment to be applied in each image dimen. */ + int nullcheck, /* I - 0, 1: do nothing; 2: set nullarray for nulls */ + char *nullarray, + int *status) + +/* + copy the intersecting pixels from a decompressed tile to the output image. + Both the tile and the image must have the same number of dimensions. +*/ +{ + long imgdim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */ + /* output image, allowing for inc factor */ + long tiledim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */ + /* tile, array; inc factor is not relevant */ + long imgfpix[MAX_COMPRESS_DIM]; /* 1st img pix overlapping tile: 0 base, */ + /* allowing for inc factor */ + long imglpix[MAX_COMPRESS_DIM]; /* last img pix overlapping tile 0 base, */ + /* allowing for inc factor */ + long tilefpix[MAX_COMPRESS_DIM]; /* 1st tile pix overlapping img 0 base, */ + /* allowing for inc factor */ + long inc[MAX_COMPRESS_DIM]; /* local copy of input ininc */ + long i1, i2, i3, i4; /* offset along each axis of the image */ + long it1, it2, it3, it4; + long im1, im2, im3, im4; /* offset to image pixel, allowing for inc */ + long ipos, tf, tl; + long t2, t3, t4; /* offset along each axis of the tile */ + long tilepix, imgpix, tilepixbyte, imgpixbyte; + int ii, overlap_bytes, overlap_flags; + + if (*status > 0) + return(*status); + + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + /* set default values for higher dimensions */ + inc[ii] = 1; + imgdim[ii] = 1; + tiledim[ii] = 1; + imgfpix[ii] = 0; + imglpix[ii] = 0; + tilefpix[ii] = 0; + } + + /* ------------------------------------------------------------ */ + /* calc amount of overlap in each dimension; if there is zero */ + /* overlap in any dimension then just return */ + /* ------------------------------------------------------------ */ + + for (ii = 0; ii < ndim; ii++) + { + if (tlpixel[ii] < fpixel[ii] || tfpixel[ii] > lpixel[ii]) + return(*status); /* there are no overlapping pixels */ + + inc[ii] = ininc[ii]; + + /* calc dimensions of the output image section */ + imgdim[ii] = (lpixel[ii] - fpixel[ii]) / labs(inc[ii]) + 1; + if (imgdim[ii] < 1) + return(*status = NEG_AXIS); + + /* calc dimensions of the tile */ + tiledim[ii] = tlpixel[ii] - tfpixel[ii] + 1; + if (tiledim[ii] < 1) + return(*status = NEG_AXIS); + + if (ii > 0) + tiledim[ii] *= tiledim[ii - 1]; /* product of dimensions */ + + /* first and last pixels in image that overlap with the tile, 0 base */ + tf = tfpixel[ii] - 1; + tl = tlpixel[ii] - 1; + + /* skip this plane if it falls in the cracks of the subsampled image */ + while ((tf-(fpixel[ii] - 1)) % labs(inc[ii])) + { + tf++; + if (tf > tl) + return(*status); /* no overlapping pixels */ + } + + while ((tl-(fpixel[ii] - 1)) % labs(inc[ii])) + { + tl--; + if (tf > tl) + return(*status); /* no overlapping pixels */ + } + imgfpix[ii] = maxvalue((tf - fpixel[ii] +1) / labs(inc[ii]) , 0); + imglpix[ii] = minvalue((tl - fpixel[ii] +1) / labs(inc[ii]) , + imgdim[ii] - 1); + + /* first pixel in the tile that overlaps with the image (0 base) */ + tilefpix[ii] = maxvalue(fpixel[ii] - tfpixel[ii], 0); + + while ((tfpixel[ii] + tilefpix[ii] - fpixel[ii]) % labs(inc[ii])) + { + (tilefpix[ii])++; + if (tilefpix[ii] >= tiledim[ii]) + return(*status); /* no overlapping pixels */ + } +/* +printf("ii tfpixel, tlpixel %d %d %d \n",ii, tfpixel[ii], tlpixel[ii]); +printf("ii, tf, tl, imgfpix,imglpix, tilefpix %d %d %d %d %d %d\n",ii, + tf,tl,imgfpix[ii], imglpix[ii],tilefpix[ii]); +*/ + if (ii > 0) + imgdim[ii] *= imgdim[ii - 1]; /* product of dimensions */ + } + + /* ---------------------------------------------------------------- */ + /* calc number of pixels in each row (first dimension) that overlap */ + /* multiply by pixlen to get number of bytes to copy in each loop */ + /* ---------------------------------------------------------------- */ + + if (inc[0] != 1) + overlap_flags = 1; /* can only copy 1 pixel at a time */ + else + overlap_flags = imglpix[0] - imgfpix[0] + 1; /* can copy whole row */ + + overlap_bytes = overlap_flags * pixlen; + + /* support up to 5 dimensions for now */ + for (i4 = 0, it4=0; i4 <= imglpix[4] - imgfpix[4]; i4++, it4++) + { + /* increment plane if it falls in the cracks of the subsampled image */ + while (ndim > 4 && (tfpixel[4] + tilefpix[4] - fpixel[4] + it4) + % labs(inc[4]) != 0) + it4++; + + /* offset to start of hypercube */ + if (inc[4] > 0) + im4 = (i4 + imgfpix[4]) * imgdim[3]; + else + im4 = imgdim[4] - (i4 + 1 + imgfpix[4]) * imgdim[3]; + + t4 = (tilefpix[4] + it4) * tiledim[3]; + for (i3 = 0, it3=0; i3 <= imglpix[3] - imgfpix[3]; i3++, it3++) + { + /* increment plane if it falls in the cracks of the subsampled image */ + while (ndim > 3 && (tfpixel[3] + tilefpix[3] - fpixel[3] + it3) + % labs(inc[3]) != 0) + it3++; + + /* offset to start of cube */ + if (inc[3] > 0) + im3 = (i3 + imgfpix[3]) * imgdim[2] + im4; + else + im3 = imgdim[3] - (i3 + 1 + imgfpix[3]) * imgdim[2] + im4; + + t3 = (tilefpix[3] + it3) * tiledim[2] + t4; + + /* loop through planes of the image */ + for (i2 = 0, it2=0; i2 <= imglpix[2] - imgfpix[2]; i2++, it2++) + { + /* incre plane if it falls in the cracks of the subsampled image */ + while (ndim > 2 && (tfpixel[2] + tilefpix[2] - fpixel[2] + it2) + % labs(inc[2]) != 0) + it2++; + + /* offset to start of plane */ + if (inc[2] > 0) + im2 = (i2 + imgfpix[2]) * imgdim[1] + im3; + else + im2 = imgdim[2] - (i2 + 1 + imgfpix[2]) * imgdim[1] + im3; + + t2 = (tilefpix[2] + it2) * tiledim[1] + t3; + + /* loop through rows of the image */ + for (i1 = 0, it1=0; i1 <= imglpix[1] - imgfpix[1]; i1++, it1++) + { + /* incre row if it falls in the cracks of the subsampled image */ + while (ndim > 1 && (tfpixel[1] + tilefpix[1] - fpixel[1] + it1) + % labs(inc[1]) != 0) + it1++; + + /* calc position of first pixel in tile to be copied */ + tilepix = tilefpix[0] + (tilefpix[1] + it1) * tiledim[0] + t2; + + /* offset to start of row */ + if (inc[1] > 0) + im1 = (i1 + imgfpix[1]) * imgdim[0] + im2; + else + im1 = imgdim[1] - (i1 + 1 + imgfpix[1]) * imgdim[0] + im2; +/* +printf("inc = %d %d %d %d\n",inc[0],inc[1],inc[2],inc[3]); +printf("im1,im2,im3,im4 = %d %d %d %d\n",im1,im2,im3,im4); +*/ + /* offset to byte within the row */ + if (inc[0] > 0) + imgpix = imgfpix[0] + im1; + else + imgpix = imgdim[0] - 1 - imgfpix[0] + im1; +/* +printf("tilefpix0,1, imgfpix1, it1, inc1, t2= %d %d %d %d %d %d\n", + tilefpix[0],tilefpix[1],imgfpix[1],it1,inc[1], t2); +printf("i1, it1, tilepix, imgpix %d %d %d %d \n", i1, it1, tilepix, imgpix); +*/ + /* loop over pixels along one row of the image */ + for (ipos = imgfpix[0]; ipos <= imglpix[0]; ipos += overlap_flags) + { + if (nullcheck == 2) + { + /* copy overlapping null flags from tile to image */ + memcpy(nullarray + imgpix, bnullarray + tilepix, + overlap_flags); + } + + /* convert from image pixel to byte offset */ + tilepixbyte = tilepix * pixlen; + imgpixbyte = imgpix * pixlen; +/* +printf(" tilepix, tilepixbyte, imgpix, imgpixbyte= %d %d %d %d\n", + tilepix, tilepixbyte, imgpix, imgpixbyte); +*/ + /* copy overlapping row of pixels from tile to image */ + memcpy(image + imgpixbyte, tile + tilepixbyte, overlap_bytes); + + tilepix += (overlap_flags * labs(inc[0])); + if (inc[0] > 0) + imgpix += overlap_flags; + else + imgpix -= overlap_flags; + } + } + } + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +int imcomp_merge_overlap ( + char *tile, /* O - multi dimensional array of tile pixels */ + int pixlen, /* I - number of bytes in each tile or image pixel */ + int ndim, /* I - number of dimension in the tile and image */ + long *tfpixel, /* I - first pixel number in each dim. of the tile */ + long *tlpixel, /* I - last pixel number in each dim. of the tile */ + char *bnullarray, /* I - array of null flags; used if nullcheck = 2 */ + char *image, /* I - multi dimensional output image */ + long *fpixel, /* I - first pixel number in each dim. of the image */ + long *lpixel, /* I - last pixel number in each dim. of the image */ + int nullcheck, /* I - 0, 1: do nothing; 2: set nullarray for nulls */ + int *status) + +/* + Similar to imcomp_copy_overlap, except it copies the overlapping pixels from + the 'image' to the 'tile'. +*/ +{ + long imgdim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */ + /* output image, allowing for inc factor */ + long tiledim[MAX_COMPRESS_DIM]; /* product of preceding dimensions in the */ + /* tile, array; inc factor is not relevant */ + long imgfpix[MAX_COMPRESS_DIM]; /* 1st img pix overlapping tile: 0 base, */ + /* allowing for inc factor */ + long imglpix[MAX_COMPRESS_DIM]; /* last img pix overlapping tile 0 base, */ + /* allowing for inc factor */ + long tilefpix[MAX_COMPRESS_DIM]; /* 1st tile pix overlapping img 0 base, */ + /* allowing for inc factor */ + long inc[MAX_COMPRESS_DIM]; /* local copy of input ininc */ + long i1, i2, i3, i4; /* offset along each axis of the image */ + long it1, it2, it3, it4; + long im1, im2, im3, im4; /* offset to image pixel, allowing for inc */ + long ipos, tf, tl; + long t2, t3, t4; /* offset along each axis of the tile */ + long tilepix, imgpix, tilepixbyte, imgpixbyte; + int ii, overlap_bytes, overlap_flags; + + if (*status > 0) + return(*status); + + for (ii = 0; ii < MAX_COMPRESS_DIM; ii++) + { + /* set default values for higher dimensions */ + inc[ii] = 1; + imgdim[ii] = 1; + tiledim[ii] = 1; + imgfpix[ii] = 0; + imglpix[ii] = 0; + tilefpix[ii] = 0; + } + + /* ------------------------------------------------------------ */ + /* calc amount of overlap in each dimension; if there is zero */ + /* overlap in any dimension then just return */ + /* ------------------------------------------------------------ */ + + for (ii = 0; ii < ndim; ii++) + { + if (tlpixel[ii] < fpixel[ii] || tfpixel[ii] > lpixel[ii]) + return(*status); /* there are no overlapping pixels */ + + /* calc dimensions of the output image section */ + imgdim[ii] = (lpixel[ii] - fpixel[ii]) / labs(inc[ii]) + 1; + if (imgdim[ii] < 1) + return(*status = NEG_AXIS); + + /* calc dimensions of the tile */ + tiledim[ii] = tlpixel[ii] - tfpixel[ii] + 1; + if (tiledim[ii] < 1) + return(*status = NEG_AXIS); + + if (ii > 0) + tiledim[ii] *= tiledim[ii - 1]; /* product of dimensions */ + + /* first and last pixels in image that overlap with the tile, 0 base */ + tf = tfpixel[ii] - 1; + tl = tlpixel[ii] - 1; + + /* skip this plane if it falls in the cracks of the subsampled image */ + while ((tf-(fpixel[ii] - 1)) % labs(inc[ii])) + { + tf++; + if (tf > tl) + return(*status); /* no overlapping pixels */ + } + + while ((tl-(fpixel[ii] - 1)) % labs(inc[ii])) + { + tl--; + if (tf > tl) + return(*status); /* no overlapping pixels */ + } + imgfpix[ii] = maxvalue((tf - fpixel[ii] +1) / labs(inc[ii]) , 0); + imglpix[ii] = minvalue((tl - fpixel[ii] +1) / labs(inc[ii]) , + imgdim[ii] - 1); + + /* first pixel in the tile that overlaps with the image (0 base) */ + tilefpix[ii] = maxvalue(fpixel[ii] - tfpixel[ii], 0); + + while ((tfpixel[ii] + tilefpix[ii] - fpixel[ii]) % labs(inc[ii])) + { + (tilefpix[ii])++; + if (tilefpix[ii] >= tiledim[ii]) + return(*status); /* no overlapping pixels */ + } +/* +printf("ii tfpixel, tlpixel %d %d %d \n",ii, tfpixel[ii], tlpixel[ii]); +printf("ii, tf, tl, imgfpix,imglpix, tilefpix %d %d %d %d %d %d\n",ii, + tf,tl,imgfpix[ii], imglpix[ii],tilefpix[ii]); +*/ + if (ii > 0) + imgdim[ii] *= imgdim[ii - 1]; /* product of dimensions */ + } + + /* ---------------------------------------------------------------- */ + /* calc number of pixels in each row (first dimension) that overlap */ + /* multiply by pixlen to get number of bytes to copy in each loop */ + /* ---------------------------------------------------------------- */ + + if (inc[0] != 1) + overlap_flags = 1; /* can only copy 1 pixel at a time */ + else + overlap_flags = imglpix[0] - imgfpix[0] + 1; /* can copy whole row */ + + overlap_bytes = overlap_flags * pixlen; + + /* support up to 5 dimensions for now */ + for (i4 = 0, it4=0; i4 <= imglpix[4] - imgfpix[4]; i4++, it4++) + { + /* increment plane if it falls in the cracks of the subsampled image */ + while (ndim > 4 && (tfpixel[4] + tilefpix[4] - fpixel[4] + it4) + % labs(inc[4]) != 0) + it4++; + + /* offset to start of hypercube */ + if (inc[4] > 0) + im4 = (i4 + imgfpix[4]) * imgdim[3]; + else + im4 = imgdim[4] - (i4 + 1 + imgfpix[4]) * imgdim[3]; + + t4 = (tilefpix[4] + it4) * tiledim[3]; + for (i3 = 0, it3=0; i3 <= imglpix[3] - imgfpix[3]; i3++, it3++) + { + /* increment plane if it falls in the cracks of the subsampled image */ + while (ndim > 3 && (tfpixel[3] + tilefpix[3] - fpixel[3] + it3) + % labs(inc[3]) != 0) + it3++; + + /* offset to start of cube */ + if (inc[3] > 0) + im3 = (i3 + imgfpix[3]) * imgdim[2] + im4; + else + im3 = imgdim[3] - (i3 + 1 + imgfpix[3]) * imgdim[2] + im4; + + t3 = (tilefpix[3] + it3) * tiledim[2] + t4; + + /* loop through planes of the image */ + for (i2 = 0, it2=0; i2 <= imglpix[2] - imgfpix[2]; i2++, it2++) + { + /* incre plane if it falls in the cracks of the subsampled image */ + while (ndim > 2 && (tfpixel[2] + tilefpix[2] - fpixel[2] + it2) + % labs(inc[2]) != 0) + it2++; + + /* offset to start of plane */ + if (inc[2] > 0) + im2 = (i2 + imgfpix[2]) * imgdim[1] + im3; + else + im2 = imgdim[2] - (i2 + 1 + imgfpix[2]) * imgdim[1] + im3; + + t2 = (tilefpix[2] + it2) * tiledim[1] + t3; + + /* loop through rows of the image */ + for (i1 = 0, it1=0; i1 <= imglpix[1] - imgfpix[1]; i1++, it1++) + { + /* incre row if it falls in the cracks of the subsampled image */ + while (ndim > 1 && (tfpixel[1] + tilefpix[1] - fpixel[1] + it1) + % labs(inc[1]) != 0) + it1++; + + /* calc position of first pixel in tile to be copied */ + tilepix = tilefpix[0] + (tilefpix[1] + it1) * tiledim[0] + t2; + + /* offset to start of row */ + if (inc[1] > 0) + im1 = (i1 + imgfpix[1]) * imgdim[0] + im2; + else + im1 = imgdim[1] - (i1 + 1 + imgfpix[1]) * imgdim[0] + im2; +/* +printf("inc = %d %d %d %d\n",inc[0],inc[1],inc[2],inc[3]); +printf("im1,im2,im3,im4 = %d %d %d %d\n",im1,im2,im3,im4); +*/ + /* offset to byte within the row */ + if (inc[0] > 0) + imgpix = imgfpix[0] + im1; + else + imgpix = imgdim[0] - 1 - imgfpix[0] + im1; +/* +printf("tilefpix0,1, imgfpix1, it1, inc1, t2= %d %d %d %d %d %d\n", + tilefpix[0],tilefpix[1],imgfpix[1],it1,inc[1], t2); +printf("i1, it1, tilepix, imgpix %d %d %d %d \n", i1, it1, tilepix, imgpix); +*/ + /* loop over pixels along one row of the image */ + for (ipos = imgfpix[0]; ipos <= imglpix[0]; ipos += overlap_flags) + { + /* convert from image pixel to byte offset */ + tilepixbyte = tilepix * pixlen; + imgpixbyte = imgpix * pixlen; +/* +printf(" tilepix, tilepixbyte, imgpix, imgpixbyte= %d %d %d %d\n", + tilepix, tilepixbyte, imgpix, imgpixbyte); +*/ + /* copy overlapping row of pixels from image to tile */ + memcpy(tile + tilepixbyte, image + imgpixbyte, overlap_bytes); + + tilepix += (overlap_flags * labs(inc[0])); + if (inc[0] > 0) + imgpix += overlap_flags; + else + imgpix -= overlap_flags; + } + } + } + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int unquantize_i1r4(long row, /* tile number = row number in table */ + unsigned char *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + unsigned char tnull, /* I - value of FITS TNULLn keyword if any */ + float nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + float *output, /* O - array of converted pixels */ + int *status) /* IO - error status */ +/* + Unquantize byte values into the scaled floating point values +*/ +{ + long ii; + int nextrand, iseed; + + if (!fits_rand_value) + if (fits_init_randoms()) return(MEMORY_ALLOCATION); + + /* initialize the index to the next random number in the list */ + iseed = (int) ((row - 1) % N_RANDOM); + nextrand = (int) (fits_rand_value[iseed] * 500); + + if (nullcheck == 0) /* no null checking required */ + { + for (ii = 0; ii < ntodo; ii++) + { + output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + } + } + else /* must check for null values */ + { + for (ii = 0; ii < ntodo; ii++) + { + if (input[ii] == tnull) + { + *anynull = 1; + if (nullcheck == 1) + output[ii] = nullval; + else + nullarray[ii] = 1; + } + else + { + output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + } + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int unquantize_i2r4(long row, /* seed for random values */ + short *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + short tnull, /* I - value of FITS TNULLn keyword if any */ + float nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + float *output, /* O - array of converted pixels */ + int *status) /* IO - error status */ +/* + Unquantize short integer values into the scaled floating point values +*/ +{ + long ii; + int nextrand, iseed; + + if (!fits_rand_value) + if (fits_init_randoms()) return(MEMORY_ALLOCATION); + + /* initialize the index to the next random number in the list */ + iseed = (int) ((row - 1) % N_RANDOM); + nextrand = (int) (fits_rand_value[iseed] * 500); + + if (nullcheck == 0) /* no null checking required */ + { + for (ii = 0; ii < ntodo; ii++) + { + output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + } + } + else /* must check for null values */ + { + for (ii = 0; ii < ntodo; ii++) + { + if (input[ii] == tnull) + { + *anynull = 1; + if (nullcheck == 1) + output[ii] = nullval; + else + nullarray[ii] = 1; + } + else + { + output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + } + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int unquantize_i4r4(long row, /* tile number = row number in table */ + INT32BIT *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + INT32BIT tnull, /* I - value of FITS TNULLn keyword if any */ + float nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + float *output, /* O - array of converted pixels */ + int *status) /* IO - error status */ +/* + Unquantize int integer values into the scaled floating point values +*/ +{ + long ii; + int nextrand, iseed; + + if (fits_rand_value == 0) + if (fits_init_randoms()) return(MEMORY_ALLOCATION); + + /* initialize the index to the next random number in the list */ + iseed = (int) ((row - 1) % N_RANDOM); + nextrand = (int) (fits_rand_value[iseed] * 500); + + if (nullcheck == 0) /* no null checking required */ + { + for (ii = 0; ii < ntodo; ii++) + { + output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + } + } + else /* must check for null values */ + { + for (ii = 0; ii < ntodo; ii++) + { + if (input[ii] == tnull) + { + *anynull = 1; + if (nullcheck == 1) + output[ii] = nullval; + else + nullarray[ii] = 1; + } + else + { + output[ii] = (float) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + } + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int unquantize_i1r8(long row, /* tile number = row number in table */ + unsigned char *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + unsigned char tnull, /* I - value of FITS TNULLn keyword if any */ + double nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + double *output, /* O - array of converted pixels */ + int *status) /* IO - error status */ +/* + Unquantize byte values into the scaled floating point values +*/ +{ + long ii; + int nextrand, iseed; + + if (!fits_rand_value) + if (fits_init_randoms()) return(MEMORY_ALLOCATION); + + /* initialize the index to the next random number in the list */ + iseed = (int) ((row - 1) % N_RANDOM); + nextrand = (int) (fits_rand_value[iseed] * 500); + + if (nullcheck == 0) /* no null checking required */ + { + for (ii = 0; ii < ntodo; ii++) + { + output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + } + } + else /* must check for null values */ + { + for (ii = 0; ii < ntodo; ii++) + { + if (input[ii] == tnull) + { + *anynull = 1; + if (nullcheck == 1) + output[ii] = nullval; + else + nullarray[ii] = 1; + } + else + { + output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + } + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int unquantize_i2r8(long row, /* tile number = row number in table */ + short *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + short tnull, /* I - value of FITS TNULLn keyword if any */ + double nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + double *output, /* O - array of converted pixels */ + int *status) /* IO - error status */ +/* + Unquantize short integer values into the scaled floating point values +*/ +{ + long ii; + int nextrand, iseed; + + if (!fits_rand_value) + if (fits_init_randoms()) return(MEMORY_ALLOCATION); + + /* initialize the index to the next random number in the list */ + iseed = (int) ((row - 1) % N_RANDOM); + nextrand = (int) (fits_rand_value[iseed] * 500); + + if (nullcheck == 0) /* no null checking required */ + { + for (ii = 0; ii < ntodo; ii++) + { + output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + } + } + else /* must check for null values */ + { + for (ii = 0; ii < ntodo; ii++) + { + if (input[ii] == tnull) + { + *anynull = 1; + if (nullcheck == 1) + output[ii] = nullval; + else + nullarray[ii] = 1; + } + else + { + output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + } + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int unquantize_i4r8(long row, /* tile number = row number in table */ + INT32BIT *input, /* I - array of values to be converted */ + long ntodo, /* I - number of elements in the array */ + double scale, /* I - FITS TSCALn or BSCALE value */ + double zero, /* I - FITS TZEROn or BZERO value */ + int nullcheck, /* I - null checking code; 0 = don't check */ + /* 1:set null pixels = nullval */ + /* 2: if null pixel, set nullarray = 1 */ + INT32BIT tnull, /* I - value of FITS TNULLn keyword if any */ + double nullval, /* I - set null pixels, if nullcheck = 1 */ + char *nullarray, /* I - bad pixel array, if nullcheck = 2 */ + int *anynull, /* O - set to 1 if any pixels are null */ + double *output, /* O - array of converted pixels */ + int *status) /* IO - error status */ +/* + Unquantize int integer values into the scaled floating point values +*/ +{ + long ii; + int nextrand, iseed; + + if (fits_rand_value == 0) + if (fits_init_randoms()) return(MEMORY_ALLOCATION); + + /* initialize the index to the next random number in the list */ + iseed = (int) ((row - 1) % N_RANDOM); + nextrand = (int) (fits_rand_value[iseed] * 500); + + if (nullcheck == 0) /* no null checking required */ + { + for (ii = 0; ii < ntodo; ii++) + { + output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + } + } + else /* must check for null values */ + { + for (ii = 0; ii < ntodo; ii++) + { + if (input[ii] == tnull) + { + *anynull = 1; + if (nullcheck == 1) + output[ii] = nullval; + else + nullarray[ii] = 1; + } + else + { + output[ii] = (double) (((double) input[ii] - fits_rand_value[nextrand] + 0.5) * scale + zero); + } + + nextrand++; + if (nextrand == N_RANDOM) { + iseed++; + if (iseed == N_RANDOM) iseed = 0; + nextrand = (int) (fits_rand_value[iseed] * 500); + } + + } + } + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int imcomp_float2nan(float *indata, + long tilelen, + int *outdata, + float nullflagval, + int *status) +/* + convert pixels that are equal to nullflag to NaNs. + Note that indata and outdata point to the same location. +*/ +{ + int ii; + + for (ii = 0; ii < tilelen; ii++) { + + if (indata[ii] == nullflagval) + outdata[ii] = -1; /* integer -1 has the same bit pattern as a real*4 NaN */ + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int imcomp_double2nan(double *indata, + long tilelen, + LONGLONG *outdata, + double nullflagval, + int *status) +/* + convert pixels that are equal to nullflag to NaNs. + Note that indata and outdata point to the same location. +*/ +{ + int ii; + + for (ii = 0; ii < tilelen; ii++) { + + if (indata[ii] == nullflagval) + outdata[ii] = -1; /* integer -1 has the same bit pattern as a real*8 NaN */ + } + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_transpose_table(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + Transpose the elements in the input table columns from row-major order into + column-major order, and write to the output table (which may be the same as + the input table). For example, a table with 10000 rows and 2 '1I' columns + will be transformed into a 1 row table with 2 '10000I' columns. + + In addition, compress each column of data and write as a 1-row variable length + array column. +*/ +{ + LONGLONG nrows, incolwidth[999], inrepeat[999], outcolstart[1000], outbytespan[999]; + LONGLONG headstart, datastart, dataend, startbyte, jj, kk, naxis1; + long repeat, width, pcount; + int ii, ncols, coltype, hdutype, ltrue = 1; + char *buffer, *cptr, keyname[9], tform[40], colcode[999], colname[999][50]; + char comm[FLEN_COMMENT], *compressed_data; + size_t dlen, datasize; + float cratio[999]; + + if (*status > 0) + return(*status); + + fits_get_hdu_type(infptr, &hdutype, status); + if (hdutype != BINARY_TBL) { + *status = NOT_BTABLE; + return(*status); + } + + fits_get_num_rowsll(infptr, &nrows, status); + fits_get_num_cols(infptr, &ncols, status); + fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + if (*status > 0) + return(*status); + + if (nrows < 1 || ncols < 1) { + /* just copy the HDU if the table has 0 columns or rows */ + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_hdu (infptr, outfptr, 0, status); + } + return(*status); + } + + /* allocate space for the transposed table */ + buffer = calloc((size_t) naxis1, (size_t) nrows); + if (!buffer) { + ffpmsg("Could not allocate buffer for transformed table"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_header(infptr, outfptr, status); + } + + outcolstart[0] = 0; + + /* do initial setup for each column */ + for (ii = 0; ii < ncols; ii++) { + + /* get the column name */ + fits_make_keyn("TTYPE", ii+1, keyname, status); + fits_read_key(outfptr, TSTRING, keyname, colname[ii], comm, status); + + /* get the column type, repeat count, and unit width */ + fits_make_keyn("TFORM", ii+1, keyname, status); + fits_read_key(outfptr, TSTRING, keyname, tform, comm, status); + + /* preserve the original TFORM value and comment string */ + keyname[0] = 'Z'; + fits_write_key(outfptr, TSTRING, keyname, tform, comm, status); + keyname[0] = 'T'; + + fits_binary_tform(tform, &coltype, &repeat, &width, status); + + /* BIT columns are a difficult case */ + /* round up to a multiple of 8 bits */ +/* + if (coltype == TBIT) { + repeat = (repeat + 7) / 8 * 8; + } +*/ + + cptr = tform; + while(isdigit(*cptr)) cptr++; + colcode[ii] = *cptr; /* save the column type code */ + + /* all columns are now VLAs */ + fits_modify_key_str(outfptr, keyname, "1PB", "&", status); + + if (coltype == TBIT) { + repeat = (repeat + 7) / 8; /* convert from bits to bytes */ + } else if (coltype == TSTRING) { + width = 1; /* ignore the optional 'w' in 'rAw' format */ + } else if (coltype < 0) { /* pointer to variable length array */ + width = 8; + if (colcode[ii] == 'Q') width = 16; /* this is a 'Q' not a 'P' column */ + repeat = 1; + } + + inrepeat[ii] = repeat; + + /* width (in bytes) of each element and field in the INPUT row-major table */ + incolwidth[ii] = repeat * width; + + /* starting offset of each field in the OUTPUT column-major table */ + outcolstart[ii + 1] = outcolstart[ii] + incolwidth[ii] * nrows; + + /* length of each sequence of bytes, after sorting them in signicant order */ + outbytespan[ii] = (incolwidth[ii] * nrows) / width; + } + + /* the transformed table has only 1 row */ + /* output table width 8 bytes per column */ + fits_modify_key_lng(outfptr, "NAXIS2", 1, "&", status); + fits_modify_key_lng(outfptr, "NAXIS1", ncols * 8, "&", status); + + /* move to the start of the input table */ + fits_get_hduaddrll(infptr, &headstart, &datastart, &dataend, status); + ffmbyt(infptr, datastart, 0, status); + + /* now transpose the table into an array in memory */ + for (jj = 0; jj < nrows; jj++) { /* loop over rows */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + kk = 0; + + cptr = buffer + (outcolstart[ii] + (jj * incolwidth[ii])); /* addr to copy to */ + + startbyte = (infptr->Fptr)->bytepos; /* save the starting byte location */ + + ffgbyt(infptr, incolwidth[ii], cptr, status); /* copy all the bytes */ + + if (incolwidth[ii] >= MINDIRECT) { /* have to explicitly move to next byte */ + ffmbyt(infptr, startbyte + incolwidth[ii], 0, status); + } + } + } + + fits_set_hdustruc(outfptr, status); + + /* now compress each column with GZIP and write out to output table */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + datasize = (size_t) (outcolstart[ii + 1] - outcolstart[ii]); + + /* allocate memory for the compressed data */ + compressed_data = malloc(datasize); + if (!compressed_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + + /* gzip compress the data */ + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &compressed_data, &datasize, realloc, + &dlen, status); + + /* write the compressed data to the output column */ + fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status); /* turn off any data scaling, first */ + fits_write_col(outfptr, TBYTE, ii + 1, 1, 1, dlen, compressed_data, status); + + cratio[ii] = (float) datasize / (float) dlen; + free(compressed_data); /* don't need the compressed data any more */ + + sprintf(results[ii]," %3d %10.10s %4d %c %5.2f", ii+1, colname[ii], (int) inrepeat[ii],colcode[ii],cratio[ii]); + trans_ratio[ii] = cratio[ii]; + } + + /* save the original PCOUNT value */ + fits_read_key(infptr, TLONG, "PCOUNT", &pcount, comm, status); + fits_write_key(outfptr, TLONG, "ZPCOUNT", &pcount, comm, status); + + fits_write_key(outfptr, TLONGLONG, "ZNAXIS1", &naxis1, "original rows width", + status); + fits_write_key(outfptr, TLONGLONG, "ZNAXIS2", &nrows, "original number of rows", + status); + + fits_write_key(outfptr, TLOGICAL, "TVIRTUAL", <rue, + "this is a virtual table", status); + fits_write_key(outfptr, TSTRING, "ZMETHOD", "TRANSPOSED_SHUFFLED_GZIP", + "table compression method", status); + + fits_set_hdustruc(outfptr, status); + + /* copy the heap from input to output file */ + fits_gzip_heap(infptr, outfptr, status); + + free(buffer); + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_compress_table_rice(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + Transpose the elements in the input table columns from row-major order into + column-major order, and write to the output table (which may be the same as + the input table). For example, a table with 10000 rows and 2 '1I' columns + will be transformed into a 1 row table with 2 '10000I' columns. + + Integer columns are then compressed with Rice; all other columns compressed + with GZIP. In addition, the bytes in the floating point numeric data values + (columns with TFORM = E, and D) are shuffled so that the most significant + byte of every element occurs first in the array, followed by the next most + significant byte, and so on to the least significant byte. Thus, if you + have 3 4-byte numeric values, the bytes 012301230123 get shuffled to + 000111222333 +*/ +{ + LONGLONG nrows, incolwidth[999], inrepeat[999], outcolstart[1000], outbytespan[999]; + LONGLONG headstart, datastart, dataend, startbyte, jj, kk, naxis1; + long repeat, width, pcount; + int ii, ncols, coltype, hdutype, ltrue = 1; + char *buffer, *cptr, keyname[9], tform[40], colcode[999], tempstring[20]; + char comm[FLEN_COMMENT], *compressed_data; + float cratio[999]; + + size_t dlen, datasize; + + if (*status > 0) + return(*status); + + fits_get_hdu_type(infptr, &hdutype, status); + if (hdutype != BINARY_TBL) { + *status = NOT_BTABLE; + return(*status); + } + + fits_get_num_rowsll(infptr, &nrows, status); + fits_get_num_cols(infptr, &ncols, status); + fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + if (*status > 0) + return(*status); + + if (nrows < 1 || ncols < 1) { + /* just copy the HDU if the table has 0 columns or rows */ + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_hdu (infptr, outfptr, 0, status); + } + return(*status); + } + + /* allocate space for the transposed table */ + buffer = calloc((size_t) naxis1, (size_t) nrows); + if (!buffer) { + ffpmsg("Could not allocate buffer for transformed table"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_header(infptr, outfptr, status); + } + + outcolstart[0] = 0; + for (ii = 0; ii < ncols; ii++) { + + /* get the column type, repeat count, and unit width */ + fits_make_keyn("TFORM", ii+1, keyname, status); + fits_read_key(outfptr, TSTRING, keyname, tform, comm, status); + + /* preserve the original TFORM value and comment string */ + keyname[0] = 'Z'; + fits_write_key(outfptr, TSTRING, keyname, tform, comm, status); + keyname[0] = 'T'; + + fits_binary_tform(tform, &coltype, &repeat, &width, status); + + /* BIT columns are a difficult case */ + /* round up to a multiple of 8 bits */ +/* + if (coltype == TBIT) { + repeat = (repeat + 7) / 8 * 8; + } +*/ + cptr = tform; + while(isdigit(*cptr)) cptr++; + colcode[ii] = *cptr; /* save the column type code */ + +/* all columns are now VLAs */ + fits_modify_key_str(outfptr, keyname, "1PB", "&", status); + + if (coltype == TBIT) { + repeat = (repeat + 7) / 8; /* convert from bits to bytes */ + } else if (coltype == TSTRING) { + width = 1; /* ignore the optional 'w' in 'rAw' format */ + } else if (coltype < 0) { /* pointer to variable length array */ + width = 8; + if (colcode[ii] == 'Q') width = 16; /* this is a 'Q' not a 'P' column */ + repeat = 1; + } + + inrepeat[ii] = repeat; + + /* width (in bytes) of each element and field in the INPUT row-major table */ + incolwidth[ii] = repeat * width; + + /* starting offset of each field in the OUTPUT column-major table */ + outcolstart[ii + 1] = outcolstart[ii] + incolwidth[ii] * nrows; + + /* length of each sequence of bytes, after sorting them in signicant order */ + outbytespan[ii] = (incolwidth[ii] * nrows) / width; + } + + /* the transformed table has only 1 row */ + /* output table width 8 bytes per column */ + + fits_modify_key_lng(outfptr, "NAXIS2", 1, "&", status); + fits_modify_key_lng(outfptr, "NAXIS1", ncols * 8, "&", status); + + /* move to the start of the input table */ + fits_get_hduaddrll(infptr, &headstart, &datastart, &dataend, status); + ffmbyt(infptr, datastart, 0, status); + + for (jj = 0; jj < nrows; jj++) { /* loop over rows */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + kk = 0; + + switch (colcode[ii]) { + /* separate the byte planes for the 2-byte, 4-byte, and 8-byte numeric columns */ + + case 'E': + while(kk < incolwidth[ii]) { + cptr = buffer + (outcolstart[ii] + (jj * inrepeat[ii]) + kk/4); + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + kk += 4; + } + break; + + case 'D': + case 'K': + while(kk < incolwidth[ii]) { + cptr = buffer + (outcolstart[ii] + (jj * inrepeat[ii]) + kk/8); + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + kk += 8; + } + break; + + default: /* don't bother separating the bytes for other column types */ + cptr = buffer + (outcolstart[ii] + (jj * incolwidth[ii])); /* addr to copy to */ + startbyte = (infptr->Fptr)->bytepos; /* save the starting byte location */ + + ffgbyt(infptr, incolwidth[ii], cptr, status); /* copy all the bytes */ + + if (incolwidth[ii] >= MINDIRECT) { /* have to explicitly move to next byte */ + ffmbyt(infptr, startbyte + incolwidth[ii], 0, status); + } + } + } + } + + fits_set_hdustruc(outfptr, status); + + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + datasize = (size_t) (outcolstart[ii + 1] - outcolstart[ii]); + /* allocate memory for the compressed data */ + compressed_data = malloc(datasize*2); + if (!compressed_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + + + switch (colcode[ii]) { + + + case 'I': +#if BYTESWAPPED + ffswap2((short *) (buffer + outcolstart[ii]), datasize / 2); +#endif + dlen = fits_rcomp_short ((short *)(buffer + outcolstart[ii]), datasize / 2, (unsigned char *) compressed_data, + datasize * 2, 32); + + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "RICE_1", + "compression algorithm for column", status); + + break; + + case 'J': + +#if BYTESWAPPED + ffswap4((int *) (buffer + outcolstart[ii]), datasize / 4); +#endif + dlen = fits_rcomp ((int *)(buffer + outcolstart[ii]), datasize / 4, (unsigned char *) compressed_data, + datasize * 2, 32); + + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "RICE_1", + "compression algorithm for column", status); + break; + + case 'B': + dlen = fits_rcomp_byte ((signed char *)(buffer + outcolstart[ii]), datasize, (unsigned char *) compressed_data, + datasize * 2, 32); + + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "RICE_1", + "compression algorithm for column", status); + break; + + default: + /* gzip compress the data */ + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &compressed_data, &datasize, realloc, &dlen, status); + + + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "GZIP_2", + "compression algorithm for column", status); + + } /* end of switch block */ + + if (dlen != 0) + cratio[ii] = (float) datasize / (float) dlen; /* compression ratio of the column */ + + /* write the compressed data to the output column */ + fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status); /* turn off any data scaling, first */ + fits_write_col(outfptr, TBYTE, ii + 1, 1, 1, dlen, compressed_data, status); + + free(compressed_data); /* don't need the compressed data any more */ +/* printf(" %c %5.2f\n",colcode[ii],cratio[ii]); */ + + sprintf(tempstring," %5.2f\n",cratio[ii]); +/* + if (colcode[ii] == 'I' || colcode[ii] == 'J' || colcode[ii] == 'B') + sprintf(tempstring," %5.2f\n",cratio[ii]); + else + sprintf(tempstring," \n"); +*/ + strcat(results[ii],tempstring); + } /* end of loop over ncols */ + + printf(" Trans Shuf Rice\n"); + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + printf("%s", results[ii]); + } + + /* save the original PCOUNT value */ + fits_read_key(infptr, TLONG, "PCOUNT", &pcount, comm, status); + fits_write_key(outfptr, TLONG, "ZPCOUNT", &pcount, comm, status); + + + fits_write_key(outfptr, TLONGLONG, "ZNAXIS1", &naxis1, "original rows width", + status); + fits_write_key(outfptr, TLONGLONG, "ZNAXIS2", &nrows, "original number of rows", + status); + + fits_write_key(outfptr, TLOGICAL, "ZTABLE", <rue, + "this is a compressed table", status); + + free(buffer); + + fits_gzip_heap(infptr, outfptr, status); + fits_set_hdustruc(outfptr, status); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_compress_table_fast(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + Compress the input FITS binary table using the 'fast' method, which consists + of (a) transposing the rows and columns, and (b) shuffling the bytes for + the I, J, K, E, and D columns so that the most significant byte of every + element occurs first in the array, followed by the next most significant byte, + and so on to the least significant byte. Thus, if you have 3 4-byte numeric + values, the bytes 012301230123 get shuffled to 000111222333 + + Finally, (c) compress each column of bytes with gzip and copy to the output table. + +*/ +{ + LONGLONG nrows, incolwidth[999], inrepeat[999], outcolstart[1000], outbytespan[999]; + LONGLONG headstart, datastart, dataend, startbyte, jj, kk, naxis1; + long repeat, width, pcount; + int ii, ncols, coltype, hdutype, ltrue = 1; + char *buffer, *cptr, keyname[9], tform[40], colcode[999]; + char comm[FLEN_COMMENT], *compressed_data, tempstring[20]; + size_t dlen, datasize; + float cratio[999]; + + if (*status > 0) + return(*status); + + fits_get_hdu_type(infptr, &hdutype, status); + if (hdutype != BINARY_TBL) { + *status = NOT_BTABLE; + return(*status); + } + + fits_get_num_rowsll(infptr, &nrows, status); + fits_get_num_cols(infptr, &ncols, status); + fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + if (*status > 0) + return(*status); + + if (nrows < 1 || ncols < 1) { + /* just copy the HDU if the table has 0 columns or rows */ + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_hdu (infptr, outfptr, 0, status); + } + return(*status); + } + + /* allocate space for the transposed table */ + buffer = calloc((size_t) naxis1, (size_t) nrows); + if (!buffer) { + ffpmsg("Could not allocate buffer for transformed table"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_header(infptr, outfptr, status); + } + + fits_write_key_log(outfptr, "ZTABLE", 1, + "extension contains compressed binary table", status); + + fits_write_key(outfptr, TLONGLONG, "ZTILELEN", &nrows, + "number of rows in each tile", status); + + fits_write_key(outfptr, TLONGLONG, "ZNAXIS1", &naxis1, "original rows width", + status); + fits_write_key(outfptr, TLONGLONG, "ZNAXIS2", &nrows, "original number of rows", + status); + + /* save the original PCOUNT value */ + fits_read_key(infptr, TLONG, "PCOUNT", &pcount, comm, status); + fits_write_key(outfptr, TLONG, "ZPCOUNT", &pcount, comm, status); + + /* reset the PCOUNT keyword to zero */ + pcount = 0; + fits_modify_key_lng(outfptr, "PCOUNT", pcount, NULL, status); + + outcolstart[0] = 0; + for (ii = 0; ii < ncols; ii++) { + + /* get the column type, repeat count, and unit width */ + fits_make_keyn("TFORM", ii+1, keyname, status); + fits_read_key(outfptr, TSTRING, keyname, tform, comm, status); + + /* preserve the original TFORM value and comment string */ + keyname[0] = 'Z'; + fits_write_key(outfptr, TSTRING, keyname, tform, comm, status); + keyname[0] = 'T'; + + /* all columns are now VLAs */ + fits_modify_key_str(outfptr, keyname, "1PB", "&", status); + + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "GZIP_2", + "compression algorithm for column", status); + + fits_binary_tform(tform, &coltype, &repeat, &width, status); + + cptr = tform; + while(isdigit(*cptr)) cptr++; + colcode[ii] = *cptr; /* save the column type code */ + + if (coltype == TBIT) { + repeat = (repeat + 7) / 8; /* convert from bits to bytes */ + } else if (coltype == TSTRING) { + width = 1; /* ignore the optional 'w' in 'rAw' format */ + } else if (coltype < 0) { /* pointer to variable length array */ + width = 8; + if (colcode[ii] == 'Q') width = 16; /* this is a 'Q' not a 'P' column */ + repeat = 1; + } + + inrepeat[ii] = repeat; + + /* width (in bytes) of each element and field in the INPUT row-major table */ + incolwidth[ii] = repeat * width; + + /* starting offset of each field in the OUTPUT column-major table */ + outcolstart[ii + 1] = outcolstart[ii] + incolwidth[ii] * nrows; + + /* length of each sequence of bytes, after sorting them in signicant order */ + outbytespan[ii] = (incolwidth[ii] * nrows) / width; + + } + + /* the transformed table has only 1 row */ + /* output table width 8 bytes per column */ + + fits_modify_key_lng(outfptr, "NAXIS2", 1, "&", status); + fits_modify_key_lng(outfptr, "NAXIS1", ncols * 8, "&", status); + + /* move to the start of the input table */ + fits_get_hduaddrll(infptr, &headstart, &datastart, &dataend, status); + ffmbyt(infptr, datastart, 0, status); + + for (jj = 0; jj < nrows; jj++) { /* loop over rows */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + kk = 0; + + switch (colcode[ii]) { + /* separate the byte planes for the 2-byte, 4-byte, and 8-byte numeric columns */ + case 'I': + while(kk < incolwidth[ii]) { + + cptr = buffer + (outcolstart[ii] + (jj * inrepeat[ii]) + kk/2); + ffgbyt(infptr, 1, cptr, status); /* copy 1st byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 2nd byte */ + kk += 2; + } + + break; + + case 'J': + case 'E': + while(kk < incolwidth[ii]) { + cptr = buffer + (outcolstart[ii] + (jj * inrepeat[ii]) + kk/4); + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + kk += 4; + } + break; + + case 'D': + case 'K': + while(kk < incolwidth[ii]) { + cptr = buffer + (outcolstart[ii] + (jj * inrepeat[ii]) + kk/8); + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + cptr += outbytespan[ii]; + ffgbyt(infptr, 1, cptr, status); /* copy 1 byte */ + kk += 8; + } + break; + + default: /* don't bother separating the bytes for other column types */ + cptr = buffer + (outcolstart[ii] + (jj * incolwidth[ii])); /* addr to copy to */ + + startbyte = (infptr->Fptr)->bytepos; /* save the starting byte location */ + + ffgbyt(infptr, incolwidth[ii], cptr, status); /* copy all the bytes */ + + if (incolwidth[ii] >= MINDIRECT) { /* have to explicitly move to next byte */ + ffmbyt(infptr, startbyte + incolwidth[ii], 0, status); + } + } + } + } + + fits_set_hdustruc(outfptr, status); + + /* now compress each column */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + /* write the compression type code for this column */ + switch (colcode[ii]) { + case 'I': + case 'J': + case 'K': + case 'E': + case 'D': + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "GZIP_2", + "compression algorithm for column", status); + break; + default: + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "GZIP_1", + "compression algorithm for column", status); + } + + datasize = (size_t) (outcolstart[ii + 1] - outcolstart[ii]); + + /* allocate memory for the compressed data */ + compressed_data = malloc(datasize); + if (!compressed_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + + /* gzip compress the data */ + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &compressed_data, &datasize, realloc, + &dlen, status); + + /* write the compressed data to the output column */ + fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status); /* turn off any data scaling, first */ + fits_write_col(outfptr, TBYTE, ii + 1, 1, 1, dlen, compressed_data, status); + + cratio[ii] = (float) datasize / (float) dlen; + free(compressed_data); /* don't need the compressed data any more */ + + sprintf(tempstring," %5.2f",cratio[ii]); + + strcat(results[ii],tempstring); + } + + free(buffer); + + /* shuffle and compress the input heap and append to the output file */ + + fits_gzip_heap(infptr, outfptr, status); + fits_set_hdustruc(outfptr, status); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_compress_table_best(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + Compress the input FITS binary table using the 'best' compression method, i.e, + whichever method produces the highest compression for each column. + + First, transpose the rows and columns in the table, then, depending on the + data type of the column, try the different compression methods to see + which one produces the highest amount of compression. + +*/ +{ + LONGLONG nrows, incolwidth[999], inrepeat[999], outcolstart[1000], outbytespan[999]; + LONGLONG headstart, datastart, dataend, startbyte, jj, naxis1; + long repeat, width, pcount; + int ii, ncols, coltype, hdutype, ltrue = 1; + char *buffer, *cptr, keyname[9], tform[40], colcode[999]; + char comm[FLEN_COMMENT]; + char *gzip1_data = 0, *gzip2_data = 0, *rice_data = 0; + size_t gzip1_len, gzip2_len, rice_len, datasize, buffsize; + + if (*status > 0) + return(*status); + + fits_get_hdu_type(infptr, &hdutype, status); + if (hdutype != BINARY_TBL) { + *status = NOT_BTABLE; + return(*status); + } + + fits_get_num_rowsll(infptr, &nrows, status); + fits_get_num_cols(infptr, &ncols, status); + fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + if (*status > 0) + return(*status); + + if (nrows < 1 || ncols < 1) { + /* just copy the HDU if the table has 0 columns or rows */ + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_hdu (infptr, outfptr, 0, status); + } + return(*status); + } + + /* allocate space for the transposed table */ + buffer = calloc((size_t) naxis1, (size_t) nrows); + if (!buffer) { + ffpmsg("Could not allocate buffer for transformed table"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + if (infptr != outfptr) { /* copy input header to the output */ + fits_copy_header(infptr, outfptr, status); + } + + fits_write_key_log(outfptr, "ZTABLE", 1, + "extension contains compressed binary table", status); + + fits_write_key(outfptr, TLONGLONG, "ZTILELEN", &nrows, + "number of rows in each tile", status); + + fits_write_key(outfptr, TLONGLONG, "ZNAXIS1", &naxis1, "original rows width", + status); + fits_write_key(outfptr, TLONGLONG, "ZNAXIS2", &nrows, "original number of rows", + status); + + /* save the original PCOUNT value */ + fits_read_key(infptr, TLONG, "PCOUNT", &pcount, comm, status); + fits_write_key(outfptr, TLONG, "ZPCOUNT", &pcount, comm, status); + /* reset the PCOUNT keyword to zero */ + pcount = 0; + fits_modify_key_lng(outfptr, "PCOUNT", pcount, NULL, status); + + /* Modify the TFORMn keywords; all columns become variable-length arrays. */ + /* Save the original TFORMn values in the corresponding ZFORMn keyword. */ + outcolstart[0] = 0; + for (ii = 0; ii < ncols; ii++) { + + /* get the column type, repeat count, and unit width */ + fits_make_keyn("TFORM", ii+1, keyname, status); + fits_read_key(outfptr, TSTRING, keyname, tform, comm, status); + + /* preserve the original TFORM value and comment string */ + keyname[0] = 'Z'; + fits_write_key(outfptr, TSTRING, keyname, tform, comm, status); + keyname[0] = 'T'; + + /* all columns are now VLAs */ + fits_modify_key_str(outfptr, keyname, "1PB", "&", status); + + fits_binary_tform(tform, &coltype, &repeat, &width, status); + + cptr = tform; + while(isdigit(*cptr)) cptr++; + colcode[ii] = *cptr; /* save the column type code */ + + /* deal with special cases */ + if (coltype == TBIT) { + repeat = (repeat + 7) / 8; /* convert from bits to bytes */ + } else if (coltype == TSTRING) { + width = 1; /* ignore the optional 'w' in 'rAw' format */ + } else if (coltype < 0) { /* pointer to variable length array */ + repeat = 1; + + if (colcode[ii] == 'Q') + width = 16; /* this is a 'Q' column */ + else + width = 8; /* this is a 'P' column */ + } + + inrepeat[ii] = repeat; + + /* width (in bytes) of each element and field in the INPUT row-major table */ + incolwidth[ii] = repeat * width; + + /* starting offset of each field in the OUTPUT column-major table */ + outcolstart[ii + 1] = outcolstart[ii] + incolwidth[ii] * nrows; + + /* length of each sequence of bytes, after sorting them in signicant order */ + outbytespan[ii] = (incolwidth[ii] * nrows) / width; + } + + /* the transformed table has only 1 row */ + /* output table width 8 bytes per column */ + + fits_modify_key_lng(outfptr, "NAXIS2", 1, "&", status); + fits_modify_key_lng(outfptr, "NAXIS1", ncols * 8, "&", status); + + /* move to the start of the input table */ + fits_get_hduaddrll(infptr, &headstart, &datastart, &dataend, status); + ffmbyt(infptr, datastart, 0, status); + + /* now transpose the rows and columns in the table into an array in memory */ + for (jj = 0; jj < nrows; jj++) { /* loop over rows */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + cptr = buffer + (outcolstart[ii] + (jj * incolwidth[ii])); /* output address */ + startbyte = (infptr->Fptr)->bytepos; /* save the starting byte location */ + ffgbyt(infptr, incolwidth[ii], cptr, status); /* copy the column element */ + + if (incolwidth[ii] >= MINDIRECT) { /* have to explicitly move to next byte */ + ffmbyt(infptr, startbyte + incolwidth[ii], 0, status); + } + } + } + + fits_set_hdustruc(outfptr, status); /* reinitialize internal pointers */ + + /* Now compress each column. Depending on the column data type, try */ + /* all the various available compression algorithms, then choose the one */ + /* that gives the most compression. */ + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + datasize = (size_t) (outcolstart[ii + 1] - outcolstart[ii]); + + /* allocate memory for the gzip compressed data */ + gzip1_data = malloc(datasize); + if (!gzip1_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + buffsize = datasize; + + /* First, simply compress the bytes with gzip (GZIP_1 algorithm code). */ + /* This algorithm can be applied to every type of column. */ + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &gzip1_data, &buffsize, realloc, &gzip1_len, status); + + /* depending on the data type, try other compression methods */ + switch (colcode[ii]) { + + case 'I': /* 2-byte Integer columns */ + + /************* first, try rice compression *****************/ + rice_data = malloc(datasize * 2); /* memory for the compressed bytes */ + if (!rice_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + +#if BYTESWAPPED + /* have to swap the bytes on little endian machines */ + ffswap2((short *) (buffer + outcolstart[ii]), datasize / 2); +#endif + rice_len = fits_rcomp_short ((short *)(buffer + outcolstart[ii]), datasize / 2, + (unsigned char *) rice_data, datasize * 2, 32); + +#if BYTESWAPPED + /* un-swap the bytes, to restore the original order */ + ffswap2((short *) (buffer + outcolstart[ii]), datasize / 2); +#endif + + /************* Second, try shuffled gzip compression *****************/ + fits_shuffle_2bytes(buffer + outcolstart[ii], datasize / 2, status); + + /* allocate memory for the shuffled gzip compressed data */ + gzip2_data = malloc(datasize); + if (!gzip2_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + buffsize = datasize; + + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &gzip2_data, &buffsize, realloc, &gzip2_len, status); + break; + + case 'J': /* 4-byte Integer columns */ + + /************* first, try rice compression *****************/ + rice_data = malloc(datasize * 2); /* memory for the compressed bytes */ + if (!rice_data) { + ffpmsg("data memory allocation error"); + return(-1); + } +#if BYTESWAPPED + /* have to swap the bytes on little endian machines */ + ffswap4((int *) (buffer + outcolstart[ii]), datasize / 4); +#endif + rice_len = fits_rcomp ((int *)(buffer + outcolstart[ii]), datasize / 4, + (unsigned char *) rice_data, datasize * 2, 32); + +#if BYTESWAPPED + /* un-swap the bytes, to restore the original order */ + ffswap4((int *) (buffer + outcolstart[ii]), datasize / 4); +#endif + + /************* Second, try shuffled gzip compression *****************/ + fits_shuffle_4bytes(buffer + outcolstart[ii], datasize / 4, status); + + /* allocate memory for the shuffled gzip compressed data */ + gzip2_data = malloc(datasize); + if (!gzip2_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + buffsize = datasize; + + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &gzip2_data, &buffsize, realloc, &gzip2_len, status); + break; + + case 'E': /* 4-byte floating-point */ + + /************* try shuffled gzip compression *****************/ + fits_shuffle_4bytes(buffer + outcolstart[ii], datasize / 4, status); + + /* allocate memory for the gzip compressed data */ + gzip2_data = malloc(datasize); + if (!gzip2_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + buffsize = datasize; + + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &gzip2_data, &buffsize, realloc, &gzip2_len, status); + + rice_len = 100 * datasize; /* rice is not applicable to R*4 data */ + + break; + + case 'K': + case 'D': /* 8-byte floating-point or integers */ + + /************* try shuffled gzip compression *****************/ + fits_shuffle_8bytes(buffer + outcolstart[ii], datasize / 8, status); + + /* allocate memory for the gzip compressed data */ + gzip2_data = malloc(datasize); + if (!gzip2_data) { + ffpmsg("data memory allocation error"); + return(-1); + } + buffsize = datasize; + + compress2mem_from_mem(buffer + outcolstart[ii], datasize, + &gzip2_data, &buffsize, realloc, &gzip2_len, status); + + rice_len = 100 * datasize; /* rice is not applicable to R*8 or I*8 data */ + + break; + + default: /* L, X, B, A, C, M, P, Q type columns: no other compression options */ + rice_len = 100 * datasize; /* rice is not applicable */ + gzip2_len = 100 * datasize; /* shuffled-gzip is not applicable */ + + } /* end of switch block */ + + /* now write the compressed bytes from the best algorithm */ + fits_set_tscale(outfptr, ii + 1, 1.0, 0.0, status); /* turn off any data scaling, first */ + if (gzip1_len <= gzip2_len && gzip1_len <= rice_len) { + + fits_write_col(outfptr, TBYTE, ii + 1, 1, 1, gzip1_len, gzip1_data, status); + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "GZIP_1", + "compression algorithm for column", status); + } else if (gzip2_len <= gzip1_len && gzip2_len <= rice_len) { + fits_write_col(outfptr, TBYTE, ii + 1, 1, 1, gzip2_len, gzip2_data, status); + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "GZIP_2", + "compression algorithm for column", status); + } else { + fits_write_col(outfptr, TBYTE, ii + 1, 1, 1, rice_len, rice_data, status); + fits_make_keyn("ZCTYP", ii+1, keyname, status); + fits_write_key(outfptr, TSTRING, keyname, "RICE_1", + "compression algorithm for column", status); + } + + /* free the temporary memory */ + if (gzip1_data) free(gzip1_data); + if (gzip2_data) free(gzip2_data); + gzip1_data = 0; + gzip2_data = 0; + } + + free(buffer); + + /* shuffle and compress the input heap and append to the output file */ + + fits_gzip_heap(infptr, outfptr, status); + fits_set_hdustruc(outfptr, status); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int fits_uncompress_table(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + Uncompress the table that was compressed with fits_compress_table_fast or + fits_compress_table_best. +*/ +{ + LONGLONG nrows, rmajor_colwidth[999], rmajor_colstart[1000], cmajor_colstart[1000]; + LONGLONG cmajor_repeat[999], rmajor_repeat[999], cmajor_bytespan[999], kk; + LONGLONG headstart, datastart, dataend; + long repeat, width, vla_repeat; + int ncols, coltype, hdutype, anynull, tstatus, zctype[999]; + char *buffer, *transbuffer, *cptr, keyname[9], tform[40], colcode[999]; + long pcount, zheapptr, naxis1, naxis2, ii, jj; + char *ptr, comm[FLEN_COMMENT], zvalue[FLEN_VALUE]; + size_t dlen, fullsize; + + /**** do initial sanity checks *****/ + if (*status > 0) + return(*status); + + fits_get_hdu_type(infptr, &hdutype, status); + if (hdutype != BINARY_TBL) { + *status = NOT_BTABLE; + return(*status); + } + + fits_get_num_rowsll(infptr, &nrows, status); + fits_get_num_cols(infptr, &ncols, status); + + if (nrows != 1 || (ncols < 1)) { + /* just copy the HDU if the table does not have 1 row and + more than 0 columns */ + if (infptr != outfptr) { + fits_copy_hdu (infptr, outfptr, 0, status); + } + return(*status); + } + + /**** get size of the uncompressed table */ + fits_read_key(infptr, TLONG, "ZNAXIS1", &naxis1, comm, status); + if (*status > 0) { + ffpmsg("Could not find the required ZNAXIS1 keyword"); + *status = 1; + return(*status); + } + + fits_read_key(infptr, TLONG, "ZNAXIS2", &naxis2, comm, status); + if (*status > 0) { + ffpmsg("Could not find the required ZNAXIS2 keyword"); + *status = 1; + return(*status); + } + + fits_read_key(infptr, TLONG, "ZPCOUNT", &pcount, comm, status); + if (*status > 0) { + ffpmsg("Could not find the required ZPCOUNT keyword"); + *status = 1; + return(*status); + } + + tstatus = 0; + fits_read_key(infptr, TLONG, "ZHEAPPTR", &zheapptr, comm, &tstatus); + if (tstatus > 0) { + zheapptr = 0; /* uncompressed table has no heap */ + } + + /**** recreate the uncompressed table header keywords ****/ + fits_copy_header(infptr, outfptr, status); + + /* reset the NAXISn keywords to what they were in the original uncompressed table */ + fits_modify_key_lng(outfptr, "NAXIS1", naxis1, "&", status); + fits_modify_key_lng(outfptr, "NAXIS2", naxis2, "&", status); + fits_modify_key_lng(outfptr, "PCOUNT", pcount, "&", status); + + fits_delete_key(outfptr, "ZTABLE", status); + fits_delete_key(outfptr, "ZNAXIS1", status); + fits_delete_key(outfptr, "ZNAXIS2", status); + fits_delete_key(outfptr, "ZPCOUNT", status); + fits_delete_key(outfptr, "ZTILELEN", status); + tstatus = 0; + fits_delete_key(outfptr, "ZHEAPPTR", &tstatus); + + /**** get the compression method that was used for each column ****/ + for (ii = 0; ii < ncols; ii++) { + + /* construct the ZCTYPn keyword name then read the keyword */ + fits_make_keyn("ZCTYP", ii+1, keyname, status); + tstatus = 0; + fits_read_key(infptr, TSTRING, keyname, zvalue, NULL, &tstatus); + if (tstatus) { + zctype[ii] = GZIP_2; + } else { + if (!strcmp(zvalue, "GZIP_2")) { + zctype[ii] = GZIP_2; + } else if (!strcmp(zvalue, "GZIP_1")) { + zctype[ii] = GZIP_1; + } else if (!strcmp(zvalue, "RICE_1")) { + zctype[ii] = RICE_1; + } else { + ffpmsg("Unrecognized ZCTYPn keyword compression code:"); + ffpmsg(zvalue); + *status = DATA_DECOMPRESSION_ERR; + return(*status); + } + + /* delete this keyword from the uncompressed header */ + fits_delete_key(outfptr, keyname, status); + } + } + + /**** allocate space for the full transposed and untransposed table ****/ + fullsize = naxis1 * naxis2; + transbuffer = malloc(fullsize); + if (!transbuffer) { + ffpmsg("Could not allocate buffer for shuffled table"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + buffer = malloc(fullsize); + if (!buffer) { + ffpmsg("Could not allocate buffer for unshuffled table"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + /*** loop over each column: read and uncompress the bytes ****/ + rmajor_colstart[0] = 0; + cmajor_colstart[0] = 0; + for (ii = 0; ii < ncols; ii++) { + + /* get the original column type, repeat count, and unit width */ + fits_make_keyn("ZFORM", ii+1, keyname, status); + fits_read_key(infptr, TSTRING, keyname, tform, comm, status); + + /* restore the original TFORM value and comment */ + keyname[0] = 'T'; + fits_modify_key_str(outfptr, keyname, tform, comm, status); + + /* now delete the ZFORM keyword */ + keyname[0] = 'Z'; + fits_delete_key(outfptr, keyname, status); + + cptr = tform; + while(isdigit(*cptr)) cptr++; + colcode[ii] = *cptr; /* save the column type code */ + + fits_binary_tform(tform, &coltype, &repeat, &width, status); + + /* deal with special cases */ + if (coltype == TBIT) { + repeat = (repeat + 7) / 8 ; /* convert from bits to bytes */ + } else if (coltype == TSTRING) { + width = 1; + } else if (coltype < 0) { /* pointer to variable length array */ + if (colcode[ii] == 'P') + width = 8; /* this is a 'P' column */ + else + width = 16; /* this is a 'Q' not a 'P' column */ + } + + rmajor_repeat[ii] = repeat; + cmajor_repeat[ii] = repeat * naxis2; + + /* width (in bytes) of each field in the row-major table */ + rmajor_colwidth[ii] = rmajor_repeat[ii] * width; + + /* starting offset of each field in the column-major table */ + cmajor_colstart[ii + 1] = cmajor_colstart[ii] + rmajor_colwidth[ii] * naxis2; + + /* length of each sequence of bytes, after sorting them in signicant order */ + cmajor_bytespan[ii] = (rmajor_colwidth[ii] * naxis2) / width; + + /* starting offset of each field in the row-major table */ + rmajor_colstart[ii + 1] = rmajor_colstart[ii] + rmajor_colwidth[ii]; + + /* read compressed bytes from input table */ + fits_read_descript(infptr, ii + 1, 1, &vla_repeat, NULL, status); + + /* allocate memory and read in the compressed bytes */ + ptr = malloc(vla_repeat); + if (!ptr) { + ffpmsg("Could not allocate buffer for compressed bytes"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + fits_set_tscale(infptr, ii + 1, 1.0, 0.0, status); /* turn off any data scaling, first */ + fits_read_col_byt(infptr, ii + 1, 1, 1, vla_repeat, 0, (unsigned char *) ptr, &anynull, status); + + cptr = transbuffer + cmajor_colstart[ii]; + + fullsize = (size_t) (cmajor_colstart[ii+1] - cmajor_colstart[ii]); + + switch (colcode[ii]) { + /* separate the byte planes for the 2-byte, 4-byte, and 8-byte numeric columns */ + + + case 'I': + + if (zctype[ii] == RICE_1) { + dlen = fits_rdecomp_short((unsigned char *)ptr, vla_repeat, (unsigned short *)cptr, + fullsize / 2, 32); +#if BYTESWAPPED + ffswap2((short *) cptr, fullsize / 2); +#endif + } else { /* gunzip the data into the correct location */ + uncompress2mem_from_mem(ptr, vla_repeat, &cptr, &fullsize, realloc, &dlen, status); + } + break; + + case 'J': + + if (zctype[ii] == RICE_1) { + dlen = fits_rdecomp ((unsigned char *) ptr, vla_repeat, (unsigned int *)cptr, + fullsize / 4, 32); +#if BYTESWAPPED + ffswap4((int *) cptr, fullsize / 4); +#endif + } else { /* gunzip the data into the correct location */ + uncompress2mem_from_mem(ptr, vla_repeat, &cptr, &fullsize, realloc, &dlen, status); + } + break; + + case 'B': + + if (zctype[ii] == RICE_1) { + dlen = fits_rdecomp_byte ((unsigned char *) ptr, vla_repeat, (unsigned char *)cptr, + fullsize, 32); + } else { /* gunzip the data into the correct location */ + uncompress2mem_from_mem(ptr, vla_repeat, &cptr, &fullsize, realloc, &dlen, status); + } + break; + + default: + /* gunzip the data into the correct location in the full table buffer */ + uncompress2mem_from_mem(ptr, vla_repeat, + &cptr, &fullsize, realloc, &dlen, status); + + } /* end of switch block */ + + free(ptr); + } + + /* now transpose the rows and columns (from transbuffer to buffer) */ + ptr = transbuffer; + for (ii = 0; ii < ncols; ii++) { /* loop over columns */ + + if ((zctype[ii] == GZIP_2)) { /* need to unshuffle the bytes */ + + switch (colcode[ii]) { + + /* recombine the byte planes for the 2-byte, 4-byte, and 8-byte numeric columns */ + + case 'I': + /* get the 1st byte of each I*2 value */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols])); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 2; + } + } + + /* get the 2nd byte of each I*2 value */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 1); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 2; + } + } + + break; + + case 'J': + case 'E': + + /* get the 1st byte of each 4-byte value */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols])); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 4; + } + } + + /* get the 2nd byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 1); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 4; + } + } + + /* get the 3rd byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 2); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 4; + } + } + + /* get the 4th byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 3); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 4; + } + } + + break; + + case 'D': + case 'K': + + /* get the 1st byte of each 8-byte value */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols])); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 2nd byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 1); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 3rd byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 2); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 4th byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 3); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 5th byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 4); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 6th byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 5); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 7th byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 6); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + /* get the 8th byte */ + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + (jj * rmajor_colstart[ncols]) + 7); + for (kk = 0; kk < rmajor_repeat[ii]; kk++) { + *cptr = *ptr; /* copy 1 byte */ + ptr++; + cptr += 8; + } + } + + break; + default: /* should never get here */ + ffpmsg("Error: unexpected use of GZIP_2 to compress a column"); + *status = DATA_DECOMPRESSION_ERR; + return(*status); + + } /* end of switch */ + + } else { /* not GZIP_2, so just transpose the bytes */ + + for (jj = 0; jj < naxis2; jj++) { /* loop over number of rows in the output table */ + cptr = buffer + (rmajor_colstart[ii] + jj * rmajor_colstart[ncols]); /* addr to copy to */ + memcpy(cptr, ptr, (size_t) rmajor_colwidth[ii]); + + ptr += (rmajor_colwidth[ii]); + } + } + + } /* end of ncols loop */ + + /* copy the buffer of data to the output data unit */ + fits_get_hduaddrll(outfptr, &headstart, &datastart, &dataend, status); + ffmbyt(outfptr, datastart, 1, status); + ffpbyt(outfptr, naxis1 * naxis2, buffer, status); + free(buffer); + free(transbuffer); + + /* reset internal table structure parameters */ + fits_set_hdustruc(outfptr, status); + + /* unshuffle the heap, if it exists */ + fits_gunzip_heap(infptr, outfptr, status); + + return(*status); +} + +/*--------------------------------------------------------------------------*/ +int fits_gzip_datablocks(fitsfile *fptr, size_t *size, int *status) +/* + GZIP compress all the data blocks in the binary table HDU. + Store the size of the compressed byte stream in the PCOUNT keyword. + Save the original PCOUNT value in the ZPCOUNT keyword. +*/ +{ + long headstart, datastart, dataend; + char *ptr, *cptr, *iptr; + size_t dlen, datasize, ii; + + /* allocate memory for the data and the compressed data */ + fits_get_hduaddr(fptr, &headstart, &datastart, &dataend, status); + datasize = dataend - datastart; + ptr = malloc(datasize); + cptr = malloc(datasize); + if (!ptr || !cptr) { + ffpmsg("data memory allocation error in fits_gzip_datablocks\n"); + return(-1); + } + + /* copy the data into memory */ + ffmbyt(fptr,datastart, REPORT_EOF, status); + iptr = ptr; + for (ii = 0; ii < datasize; ii+= 2880) { + ffgbyt(fptr, 2880, iptr, status); + iptr += 2880; + } + + /* gzip compress the data */ + compress2mem_from_mem(ptr, datasize, + &cptr, &datasize, realloc, + &dlen, status); + + *size = dlen; + + free(cptr); /* don't need the compressed data any more */ + free(ptr); /* don't need the original data any more */ + + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_gzip_heap(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + Compress the binary table heap in the input file and write it to the output file. + First, shuffle the bytes for the numeric arrays in the heap, so that + the bytes are sorted in order of decreasing significance. Then gzip + the entire heap as a single block of data. Then append this compressed heap + to the end of any existing data in the output file heap. +*/ +{ + LONGLONG datastart, dataend, nrows, naxis1, heapsize, length, offset, pcount, jj; + int coltype, ncols, ii; + char *heap, *compheap, card[FLEN_CARD]; + size_t theapsize, compsize; + + if (*status > 0) + return(*status); + + /* insert a set of COMMENT keyword to indicate that this is a compressed table */ + fits_read_card(outfptr, "TFIELDS", card, status); + fits_insert_card(outfptr, "COMMENT [FPACK] This is a compressed binary table generated by fpack.", status); + fits_insert_card(outfptr, "COMMENT [FPACK] It can be uncompressed using funpack.", status); + fits_insert_card(outfptr, "COMMENT [FPACK] fpack and funpack are available from the HEASARC Web site.", status); + + /* get the size of the heap (value of PCOUNT keyword) */ + fits_read_key(infptr, TLONGLONG, "PCOUNT", &heapsize, NULL, status); + + /* return if there is no heap */ + if (*status != 0 || heapsize == 0) + return(*status); + + /* allocate memory for the heap and compressed heap */ + + heap = malloc((size_t) heapsize); + if (!heap) { + ffpmsg("Could not allocate buffer for the heap (fits_gzip_heap"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + compheap = malloc((size_t) heapsize); + if (!compheap) { + ffpmsg("Could not allocate buffer for compressed heap (fits_gzip_heap"); + free(heap); + *status = MEMORY_ALLOCATION; + return(*status); + } + + fits_get_hduaddrll(infptr, NULL, &datastart, NULL, status); + fits_get_num_rowsll(infptr, &nrows, status); + fits_get_num_cols(infptr, &ncols, status); + fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + + /* move to start of the heap and copy the heap into memory */ + ffmbyt(infptr, datastart + (nrows * naxis1), REPORT_EOF, status); + ffgbyt(infptr, heapsize, heap, status); + + /* shuffle the bytes for the numeric columns */ + for (ii = 1; ii <= ncols; ii++) { + + fits_get_coltype(infptr, ii, &coltype, NULL, NULL, status); + + if (coltype >= 0) continue; /* only interested in variable length columns */ + + coltype = coltype * (-1); + + switch (coltype) { + /* shuffle the bytes for the 2-byte, 4-byte, and 8-byte numeric columns */ + case TSHORT: + + for (jj = 1; jj <= nrows; jj++) { + fits_read_descriptll(infptr, ii, jj, &length, &offset, status); + fits_shuffle_2bytes(heap + offset, length, status); + } + break; + + case TLONG: + case TFLOAT: + for (jj = 1; jj <= nrows; jj++) { + fits_read_descriptll(infptr, ii, jj, &length, &offset, status); + fits_shuffle_4bytes(heap + offset, length, status); + } + break; + + case TDOUBLE: + case TLONGLONG: + for (jj = 1; jj <= nrows; jj++) { + fits_read_descriptll(infptr, ii, jj, &length, &offset, status); + fits_shuffle_8bytes(heap + offset, length, status); + } + break; + + default: /* don't have to do anything for other column types */ + break; + + } /* end of switch block */ + } + + /* gzip compress the shuffled heap */ + theapsize = (size_t) heapsize; + compress2mem_from_mem(heap, (size_t) heapsize, &compheap, &theapsize, + realloc, &compsize, status); + free(heap); /* don't need the uncompresse heap any more */ + + /* update the internal pointers */ + fits_set_hdustruc(outfptr, status); + + /* save offset to the start of the compressed heap, relative to the + start of the main data table in the ZHEAPPTR keyword, and + update PCOUNT to the new extended heap size */ + + fits_read_key(outfptr, TLONGLONG, "PCOUNT", &pcount, NULL, status); + fits_get_num_rowsll(outfptr, &nrows, status); + fits_read_key(outfptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + + fits_write_key_lng(outfptr, "ZHEAPPTR", (LONGLONG) ((nrows * naxis1) + pcount), + "byte offset to compressed heap", status); + fits_modify_key_lng(outfptr, "PCOUNT", pcount + compsize, NULL, status); + + /* now append the compressed heap to the heap in the output file */ + dataend = (outfptr->Fptr)->datastart + (outfptr->Fptr)->heapstart + + (outfptr->Fptr)->heapsize; + + ffmbyt(outfptr, dataend, IGNORE_EOF, status); + ffpbyt(outfptr, compsize, compheap, status); + free(compheap); + + /* also update the internal pointer to the heap size */ + (outfptr->Fptr)->heapsize = (outfptr->Fptr)->heapsize + compsize; + + /* update the internal pointers again */ + fits_set_hdustruc(outfptr, status); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_shuffle_2bytes(char *heap, LONGLONG length, int *status) + +/* shuffle the bytes in an array of 2-byte integers in the heap */ + +{ + LONGLONG ii; + char *ptr, *cptr, *heapptr; + + ptr = malloc((size_t) (length * 2)); + heapptr = heap; + cptr = ptr; + + for (ii = 0; ii < length; ii++) { + *cptr = *heapptr; + heapptr++; + *(cptr + length) = *heapptr; + heapptr++; + cptr++; + } + + memcpy(heap, ptr, (size_t) (length * 2)); + free(ptr); + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_shuffle_4bytes(char *heap, LONGLONG length, int *status) + +/* shuffle the bytes in an array of 4-byte integers or floats */ + +{ + LONGLONG ii; + char *ptr, *cptr, *heapptr; + + ptr = malloc((size_t) (length * 4)); + if (!ptr) { + ffpmsg("malloc failed\n"); + return(*status); + } + + heapptr = heap; + cptr = ptr; + + for (ii = 0; ii < length; ii++) { + *cptr = *heapptr; + heapptr++; + *(cptr + length) = *heapptr; + heapptr++; + *(cptr + (length * 2)) = *heapptr; + heapptr++; + *(cptr + (length * 3)) = *heapptr; + heapptr++; + cptr++; + } + + memcpy(heap, ptr, (size_t) (length * 4)); + free(ptr); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_shuffle_8bytes(char *heap, LONGLONG length, int *status) + +/* shuffle the bytes in an array of 8-byte integers or doubles in the heap */ + +{ + LONGLONG ii; + char *ptr, *cptr, *heapptr; + + ptr = calloc(1, (size_t) (length * 8)); + heapptr = heap; + +/* for some bizarre reason this loop fails to compile under OpenSolaris using + the proprietary SunStudioExpress C compiler; use the following equivalent + loop instead. + + cptr = ptr; + + for (ii = 0; ii < length; ii++) { + *cptr = *heapptr; + heapptr++; + *(cptr + length) = *heapptr; + heapptr++; + *(cptr + (length * 2)) = *heapptr; + heapptr++; + *(cptr + (length * 3)) = *heapptr; + heapptr++; + *(cptr + (length * 4)) = *heapptr; + heapptr++; + *(cptr + (length * 5)) = *heapptr; + heapptr++; + *(cptr + (length * 6)) = *heapptr; + heapptr++; + *(cptr + (length * 7)) = *heapptr; + heapptr++; + cptr++; + } +*/ + for (ii = 0; ii < length; ii++) { + cptr = ptr + ii; + + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + cptr += length; + *cptr = *heapptr; + + heapptr++; + } + + memcpy(heap, ptr, (size_t) (length * 8)); + free(ptr); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_gunzip_heap(fitsfile *infptr, fitsfile *outfptr, int *status) + +/* + inverse of the fits_gzip_heap function: uncompress and unshuffle the heap + in the input file and write it to the output file +*/ +{ + LONGLONG datastart, nrows, naxis1, length, offset, pcount, jj; + LONGLONG zpcount, zheapptr, cheapsize; + int coltype, ncols, ii; + char *heap, *compheap; + size_t arraysize, theapsize; + + if (*status > 0) + return(*status); + + /* first, delete any COMMENT keywords written by fits_gzip_heap */ + while (*status == 0) { + fits_delete_str(outfptr, "COMMENT [FPACK]", status); + } + if (*status == KEY_NO_EXIST) *status = 0; + + /* ZPCOUNT = size of original uncompressed heap */ + fits_read_key(infptr, TLONGLONG, "ZPCOUNT", &zpcount, NULL, status); + + /* just return if there is no heap */ + if (*status != 0 || zpcount == 0) + return(*status); + + fits_get_num_rowsll(infptr, &nrows, status); + fits_read_key(infptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + + /* ZHEAPPTR = offset to the start of the compressed heap */ + fits_read_key(infptr, TLONGLONG, "ZHEAPPTR", &zheapptr, NULL, status); + + /* PCOUNT = total size of the compressed 2D table plus the compressed heap */ + fits_read_key(infptr, TLONGLONG, "PCOUNT", &pcount, NULL, status); + + /* size of the compressed heap */ + cheapsize = pcount - (zheapptr - (naxis1 * nrows)); + + /* allocate memory for the heap and uncompressed heap */ + arraysize = (size_t) zpcount; + heap = malloc(arraysize); + if (!heap) { + ffpmsg("Could not allocate buffer for the heap (fits_gunzip_heap"); + *status = MEMORY_ALLOCATION; + return(*status); + } + + compheap = malloc((size_t) cheapsize); + if (!compheap) { + ffpmsg("Could not allocate buffer for compressed heap (fits_gunzip_heap"); + free(heap); + *status = MEMORY_ALLOCATION; + return(*status); + } + + fits_get_hduaddrll(infptr, NULL, &datastart, NULL, status); + + /* read the compressed heap into memory */ + ffmbyt(infptr, datastart + zheapptr, REPORT_EOF, status); + ffgbyt(infptr, cheapsize, compheap, status); + + /* uncompress the heap */ + theapsize = (size_t) zpcount; + uncompress2mem_from_mem(compheap, (size_t) cheapsize, &heap, &arraysize, + realloc, &theapsize, status); + + free(compheap); /* don't need the compressed heap any more */ + + if (theapsize != zpcount) { + /* something is wrong */ + ffpmsg("uncompressed heap size != to ZPCOUNT"); + free(heap); + *status = MEMORY_ALLOCATION; + return(*status); + } + + /* get dimensions of the uncompressed table */ + fits_get_num_rowsll(outfptr, &nrows, status); + fits_read_key(outfptr, TLONGLONG, "NAXIS1", &naxis1, NULL, status); + fits_get_num_cols(outfptr, &ncols, status); + + for (ii = ncols; ii > 0; ii--) { + + fits_get_coltype(outfptr, ii, &coltype, NULL, NULL, status); + + if (coltype >= 0) continue; /* only interested in variable length columns */ + + coltype = coltype * (-1); + + switch (coltype) { + /* recombine the byte planes for the 2-byte, 4-byte, and 8-byte numeric columns */ + case TSHORT: + + for (jj = nrows; jj > 0; jj--) { + fits_read_descriptll(outfptr, ii, jj, &length, &offset, status); + fits_unshuffle_2bytes(heap + offset, length, status); + } + break; + + case TLONG: + case TFLOAT: + for (jj = nrows; jj > 0; jj--) { + fits_read_descriptll(outfptr, ii, jj, &length, &offset, status); + fits_unshuffle_4bytes(heap + offset, length, status); + } + break; + + case TDOUBLE: + case TLONGLONG: + for (jj = nrows; jj > 0; jj--) { + fits_read_descriptll(outfptr, ii, jj, &length, &offset, status); + fits_unshuffle_8bytes(heap + offset, length, status); + } + break; + + default: /* don't need to recombine bytes for other column types */ + break; + + } /* end of switch block */ + } + + /* copy the unshuffled heap back to the output file */ + fits_get_hduaddrll(outfptr, NULL, &datastart, NULL, status); + + ffmbyt(outfptr, datastart + (nrows * naxis1), IGNORE_EOF, status); + ffpbyt(outfptr, zpcount, heap, status); + + free(heap); + + /* also update the internal pointer to the heap size */ + (outfptr->Fptr)->heapsize = zpcount; + + /* update the internal pointers again */ + fits_set_hdustruc(outfptr, status); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_unshuffle_2bytes(char *heap, LONGLONG length, int *status) + +/* unshuffle the bytes in an array of 2-byte integers */ + +{ + LONGLONG ii; + char *ptr, *cptr, *heapptr; + + ptr = malloc((size_t) (length * 2)); + heapptr = heap + (2 * length) - 1; + cptr = ptr + (2 * length) - 1; + + for (ii = 0; ii < length; ii++) { + *cptr = *heapptr; + cptr--; + *cptr = *(heapptr - length); + cptr--; + heapptr--; + } + + memcpy(heap, ptr, (size_t) (length * 2)); + free(ptr); + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_unshuffle_4bytes(char *heap, LONGLONG length, int *status) + +/* unshuffle the bytes in an array of 4-byte integers or floats */ + +{ + LONGLONG ii; + char *ptr, *cptr, *heapptr; + + ptr = malloc((size_t) (length * 4)); + heapptr = heap + (4 * length) -1; + cptr = ptr + (4 * length) -1; + + for (ii = 0; ii < length; ii++) { + *cptr = *heapptr; + cptr--; + *cptr = *(heapptr - length); + cptr--; + *cptr = *(heapptr - (2 * length)); + cptr--; + *cptr = *(heapptr - (3 * length)); + cptr--; + heapptr--; + } + + memcpy(heap, ptr, (size_t) (length * 4)); + free(ptr); + return(*status); +} +/*--------------------------------------------------------------------------*/ +static int fits_unshuffle_8bytes(char *heap, LONGLONG length, int *status) + +/* unshuffle the bytes in an array of 8-byte integers or doubles */ + +{ + LONGLONG ii; + char *ptr, *cptr, *heapptr; + + ptr = malloc((size_t) (length * 8)); + heapptr = heap + (8 * length) - 1; + cptr = ptr + (8 * length) -1; + + for (ii = 0; ii < length; ii++) { + *cptr = *heapptr; + cptr--; + *cptr = *(heapptr - length); + cptr--; + *cptr = *(heapptr - (2 * length)); + cptr--; + *cptr = *(heapptr - (3 * length)); + cptr--; + *cptr = *(heapptr - (4 * length)); + cptr--; + *cptr = *(heapptr - (5 * length)); + cptr--; + *cptr = *(heapptr - (6 * length)); + cptr--; + *cptr = *(heapptr - (7 * length)); + cptr--; + heapptr--; + } + + memcpy(heap, ptr, (size_t) (length * 8)); + free(ptr); + return(*status); +} |