diff options
Diffstat (limited to 'vendor/cfitsio/zcompress.c')
| -rw-r--r-- | vendor/cfitsio/zcompress.c | 504 |
1 files changed, 504 insertions, 0 deletions
diff --git a/vendor/cfitsio/zcompress.c b/vendor/cfitsio/zcompress.c new file mode 100644 index 00000000..b8d7e79f --- /dev/null +++ b/vendor/cfitsio/zcompress.c @@ -0,0 +1,504 @@ +#include <stdio.h> +#include <errno.h> +#include <stdlib.h> +#include <string.h> +#include "zlib.h" + +unsigned int GZBUFSIZE = 115200; /* 40 FITS blocks */ +int BUFFINCR = 28800; /* 10 FITS blocks */ + +/* prototype for the following functions */ +int uncompress2mem(char *filename, + FILE *diskfile, + char **buffptr, + size_t *buffsize, + void *(*mem_realloc)(void *p, size_t newsize), + size_t *filesize, + int *status); + +int uncompress2mem_from_mem( + char *inmemptr, + size_t inmemsize, + char **buffptr, + size_t *buffsize, + void *(*mem_realloc)(void *p, size_t newsize), + size_t *filesize, + int *status); + +int uncompress2file(char *filename, + FILE *indiskfile, + FILE *outdiskfile, + int *status); + + +int compress2mem_from_mem( + char *inmemptr, + size_t inmemsize, + char **buffptr, + size_t *buffsize, + void *(*mem_realloc)(void *p, size_t newsize), + size_t *filesize, + int *status); + +int compress2file_from_mem( + char *inmemptr, + size_t inmemsize, + FILE *outdiskfile, + size_t *filesize, /* O - size of file, in bytes */ + int *status); + + +/*--------------------------------------------------------------------------*/ +int uncompress2mem(char *filename, /* name of input file */ + FILE *diskfile, /* I - file pointer */ + char **buffptr, /* IO - memory pointer */ + size_t *buffsize, /* IO - size of buffer, in bytes */ + void *(*mem_realloc)(void *p, size_t newsize), /* function */ + size_t *filesize, /* O - size of file, in bytes */ + int *status) /* IO - error status */ + +/* + Uncompress the disk file into memory. Fill whatever amount of memory has + already been allocated, then realloc more memory, using the supplied + input function, if necessary. +*/ +{ + int err, len; + char *filebuff; + z_stream d_stream; /* decompression stream */ + + if (*status > 0) + return(*status); + + /* Allocate memory to hold compressed bytes read from the file. */ + filebuff = (char*)malloc(GZBUFSIZE); + if (!filebuff) return(*status = 113); /* memory error */ + + d_stream.zalloc = (alloc_func)0; + d_stream.zfree = (free_func)0; + d_stream.opaque = (voidpf)0; + d_stream.next_out = (unsigned char*) *buffptr; + d_stream.avail_out = *buffsize; + + /* Initialize the decompression. The argument (15+16) tells the + decompressor that we are to use the gzip algorithm */ + + err = inflateInit2(&d_stream, (15+16)); + if (err != Z_OK) return(*status = 414); + + /* loop through the file, reading a buffer and uncompressing it */ + for (;;) + { + len = fread(filebuff, 1, GZBUFSIZE, diskfile); + if (ferror(diskfile)) { + inflateEnd(&d_stream); + free(filebuff); + return(*status = 414); + } + + if (len == 0) break; /* no more data */ + + d_stream.next_in = (unsigned char*)filebuff; + d_stream.avail_in = len; + + for (;;) { + /* uncompress as much of the input as will fit in the output */ + err = inflate(&d_stream, Z_NO_FLUSH); + + if (err == Z_STREAM_END ) { /* We reached the end of the input */ + break; + } else if (err == Z_OK ) { + + if (!d_stream.avail_in) break; /* need more input */ + + /* need more space in output buffer */ + if (mem_realloc) { + *buffptr = mem_realloc(*buffptr,*buffsize + BUFFINCR); + if (*buffptr == NULL){ + inflateEnd(&d_stream); + free(filebuff); + return(*status = 414); /* memory allocation failed */ + } + + d_stream.avail_out = BUFFINCR; + d_stream.next_out = (unsigned char*) (*buffptr + *buffsize); + *buffsize = *buffsize + BUFFINCR; + } else { /* error: no realloc function available */ + inflateEnd(&d_stream); + free(filebuff); + return(*status = 414); + } + } else { /* some other error */ + inflateEnd(&d_stream); + free(filebuff); + return(*status = 414); + } + } + + if (feof(diskfile)) break; + + d_stream.next_out = (unsigned char*) (*buffptr + d_stream.total_out); + d_stream.avail_out = *buffsize - d_stream.total_out; + } + + /* Set the output file size to be the total output data */ + *filesize = d_stream.total_out; + + free(filebuff); /* free temporary output data buffer */ + + err = inflateEnd(&d_stream); /* End the decompression */ + if (err != Z_OK) return(*status = 414); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int uncompress2mem_from_mem( + char *inmemptr, /* I - memory pointer to compressed bytes */ + size_t inmemsize, /* I - size of input compressed file */ + char **buffptr, /* IO - memory pointer */ + size_t *buffsize, /* IO - size of buffer, in bytes */ + void *(*mem_realloc)(void *p, size_t newsize), /* function */ + size_t *filesize, /* O - size of file, in bytes */ + int *status) /* IO - error status */ + +/* + Uncompress the file in memory into memory. Fill whatever amount of memory has + already been allocated, then realloc more memory, using the supplied + input function, if necessary. +*/ +{ + int err; + z_stream d_stream; /* decompression stream */ + + if (*status > 0) + return(*status); + + d_stream.zalloc = (alloc_func)0; + d_stream.zfree = (free_func)0; + d_stream.opaque = (voidpf)0; + + /* Initialize the decompression. The argument (15+16) tells the + decompressor that we are to use the gzip algorithm */ + err = inflateInit2(&d_stream, (15+16)); + if (err != Z_OK) return(*status = 414); + + d_stream.next_in = (unsigned char*)inmemptr; + d_stream.avail_in = inmemsize; + + d_stream.next_out = (unsigned char*) *buffptr; + d_stream.avail_out = *buffsize; + + for (;;) { + /* uncompress as much of the input as will fit in the output */ + err = inflate(&d_stream, Z_NO_FLUSH); + + if (err == Z_STREAM_END) { /* We reached the end of the input */ + break; + } else if (err == Z_OK ) { /* need more space in output buffer */ + + if (mem_realloc) { + *buffptr = mem_realloc(*buffptr,*buffsize + BUFFINCR); + if (*buffptr == NULL){ + inflateEnd(&d_stream); + return(*status = 414); /* memory allocation failed */ + } + + d_stream.avail_out = BUFFINCR; + d_stream.next_out = (unsigned char*) (*buffptr + *buffsize); + *buffsize = *buffsize + BUFFINCR; + + } else { /* error: no realloc function available */ + inflateEnd(&d_stream); + return(*status = 414); + } + } else { /* some other error */ + inflateEnd(&d_stream); + return(*status = 414); + } + } + + /* Set the output file size to be the total output data */ + if (filesize) *filesize = d_stream.total_out; + + /* End the decompression */ + err = inflateEnd(&d_stream); + + if (err != Z_OK) return(*status = 414); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int uncompress2file(char *filename, /* name of input file */ + FILE *indiskfile, /* I - input file pointer */ + FILE *outdiskfile, /* I - output file pointer */ + int *status) /* IO - error status */ +/* + Uncompress the file into another file. +*/ +{ + int err, len; + unsigned long bytes_out = 0; + char *infilebuff, *outfilebuff; + z_stream d_stream; /* decompression stream */ + + if (*status > 0) + return(*status); + + /* Allocate buffers to hold compressed and uncompressed */ + infilebuff = (char*)malloc(GZBUFSIZE); + if (!infilebuff) return(*status = 113); /* memory error */ + + outfilebuff = (char*)malloc(GZBUFSIZE); + if (!outfilebuff) return(*status = 113); /* memory error */ + + d_stream.zalloc = (alloc_func)0; + d_stream.zfree = (free_func)0; + d_stream.opaque = (voidpf)0; + + d_stream.next_out = (unsigned char*) outfilebuff; + d_stream.avail_out = GZBUFSIZE; + + /* Initialize the decompression. The argument (15+16) tells the + decompressor that we are to use the gzip algorithm */ + + err = inflateInit2(&d_stream, (15+16)); + if (err != Z_OK) return(*status = 414); + + /* loop through the file, reading a buffer and uncompressing it */ + for (;;) + { + len = fread(infilebuff, 1, GZBUFSIZE, indiskfile); + if (ferror(indiskfile)) { + inflateEnd(&d_stream); + free(infilebuff); + free(outfilebuff); + return(*status = 414); + } + + if (len == 0) break; /* no more data */ + + d_stream.next_in = (unsigned char*)infilebuff; + d_stream.avail_in = len; + + for (;;) { + /* uncompress as much of the input as will fit in the output */ + err = inflate(&d_stream, Z_NO_FLUSH); + + if (err == Z_STREAM_END ) { /* We reached the end of the input */ + break; + } else if (err == Z_OK ) { + + if (!d_stream.avail_in) break; /* need more input */ + + /* flush out the full output buffer */ + if ((int)fwrite(outfilebuff, 1, GZBUFSIZE, outdiskfile) != GZBUFSIZE) { + inflateEnd(&d_stream); + free(infilebuff); + free(outfilebuff); + return(*status = 414); + } + bytes_out += GZBUFSIZE; + d_stream.next_out = (unsigned char*) outfilebuff; + d_stream.avail_out = GZBUFSIZE; + + } else { /* some other error */ + inflateEnd(&d_stream); + free(infilebuff); + free(outfilebuff); + return(*status = 414); + } + } + + if (feof(indiskfile)) break; + } + + /* write out any remaining bytes in the buffer */ + if (d_stream.total_out > bytes_out) { + if ((int)fwrite(outfilebuff, 1, (d_stream.total_out - bytes_out), outdiskfile) + != (d_stream.total_out - bytes_out)) { + inflateEnd(&d_stream); + free(infilebuff); + free(outfilebuff); + return(*status = 414); + } + } + + free(infilebuff); /* free temporary output data buffer */ + free(outfilebuff); /* free temporary output data buffer */ + + err = inflateEnd(&d_stream); /* End the decompression */ + if (err != Z_OK) return(*status = 414); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int compress2mem_from_mem( + char *inmemptr, /* I - memory pointer to uncompressed bytes */ + size_t inmemsize, /* I - size of input uncompressed file */ + char **buffptr, /* IO - memory pointer for compressed file */ + size_t *buffsize, /* IO - size of buffer, in bytes */ + void *(*mem_realloc)(void *p, size_t newsize), /* function */ + size_t *filesize, /* O - size of file, in bytes */ + int *status) /* IO - error status */ + +/* + Compress the file into memory. Fill whatever amount of memory has + already been allocated, then realloc more memory, using the supplied + input function, if necessary. +*/ +{ + int err; + z_stream c_stream; /* compression stream */ + + if (*status > 0) + return(*status); + + c_stream.zalloc = (alloc_func)0; + c_stream.zfree = (free_func)0; + c_stream.opaque = (voidpf)0; + + /* Initialize the compression. The argument (15+16) tells the + compressor that we are to use the gzip algorythm. + Also use Z_BEST_SPEED for maximum speed with very minor loss + in compression factor. */ + err = deflateInit2(&c_stream, Z_BEST_SPEED, Z_DEFLATED, + (15+16), 8, Z_DEFAULT_STRATEGY); + + if (err != Z_OK) return(*status = 413); + + c_stream.next_in = (unsigned char*)inmemptr; + c_stream.avail_in = inmemsize; + + c_stream.next_out = (unsigned char*) *buffptr; + c_stream.avail_out = *buffsize; + + for (;;) { + /* compress as much of the input as will fit in the output */ + err = deflate(&c_stream, Z_FINISH); + + if (err == Z_STREAM_END) { /* We reached the end of the input */ + break; + } else if (err == Z_OK ) { /* need more space in output buffer */ + + if (mem_realloc) { + *buffptr = mem_realloc(*buffptr,*buffsize + BUFFINCR); + if (*buffptr == NULL){ + deflateEnd(&c_stream); + return(*status = 413); /* memory allocation failed */ + } + + c_stream.avail_out = BUFFINCR; + c_stream.next_out = (unsigned char*) (*buffptr + *buffsize); + *buffsize = *buffsize + BUFFINCR; + + } else { /* error: no realloc function available */ + deflateEnd(&c_stream); + return(*status = 413); + } + } else { /* some other error */ + deflateEnd(&c_stream); + return(*status = 413); + } + } + + /* Set the output file size to be the total output data */ + if (filesize) *filesize = c_stream.total_out; + + /* End the compression */ + err = deflateEnd(&c_stream); + + if (err != Z_OK) return(*status = 413); + + return(*status); +} +/*--------------------------------------------------------------------------*/ +int compress2file_from_mem( + char *inmemptr, /* I - memory pointer to uncompressed bytes */ + size_t inmemsize, /* I - size of input uncompressed file */ + FILE *outdiskfile, + size_t *filesize, /* O - size of file, in bytes */ + int *status) + +/* + Compress the memory file into disk file. +*/ +{ + int err; + unsigned long bytes_out = 0; + char *outfilebuff; + z_stream c_stream; /* compression stream */ + + if (*status > 0) + return(*status); + + /* Allocate buffer to hold compressed bytes */ + outfilebuff = (char*)malloc(GZBUFSIZE); + if (!outfilebuff) return(*status = 113); /* memory error */ + + c_stream.zalloc = (alloc_func)0; + c_stream.zfree = (free_func)0; + c_stream.opaque = (voidpf)0; + + /* Initialize the compression. The argument (15+16) tells the + compressor that we are to use the gzip algorythm. + Also use Z_BEST_SPEED for maximum speed with very minor loss + in compression factor. */ + err = deflateInit2(&c_stream, Z_BEST_SPEED, Z_DEFLATED, + (15+16), 8, Z_DEFAULT_STRATEGY); + + if (err != Z_OK) return(*status = 413); + + c_stream.next_in = (unsigned char*)inmemptr; + c_stream.avail_in = inmemsize; + + c_stream.next_out = (unsigned char*) outfilebuff; + c_stream.avail_out = GZBUFSIZE; + + for (;;) { + /* compress as much of the input as will fit in the output */ + err = deflate(&c_stream, Z_FINISH); + + if (err == Z_STREAM_END) { /* We reached the end of the input */ + break; + } else if (err == Z_OK ) { /* need more space in output buffer */ + + /* flush out the full output buffer */ + if ((int)fwrite(outfilebuff, 1, GZBUFSIZE, outdiskfile) != GZBUFSIZE) { + deflateEnd(&c_stream); + free(outfilebuff); + return(*status = 413); + } + bytes_out += GZBUFSIZE; + c_stream.next_out = (unsigned char*) outfilebuff; + c_stream.avail_out = GZBUFSIZE; + + + } else { /* some other error */ + deflateEnd(&c_stream); + free(outfilebuff); + return(*status = 413); + } + } + + /* write out any remaining bytes in the buffer */ + if (c_stream.total_out > bytes_out) { + if ((int)fwrite(outfilebuff, 1, (c_stream.total_out - bytes_out), outdiskfile) + != (c_stream.total_out - bytes_out)) { + deflateEnd(&c_stream); + free(outfilebuff); + return(*status = 413); + } + } + + free(outfilebuff); /* free temporary output data buffer */ + + /* Set the output file size to be the total output data */ + if (filesize) *filesize = c_stream.total_out; + + /* End the compression */ + err = deflateEnd(&c_stream); + + if (err != Z_OK) return(*status = 413); + + return(*status); +} |