/*--------------------------------------------------------------------------*/
int file_open(char *filename, int rwmode, int *handle)
{
FILE *diskfile;
int copyhandle, ii, status;
char recbuf[2880];
size_t nread;
/*
if an output filename has been specified as part of the input
file, as in "inputfile.fits(outputfile.fit)" then we have to
create the output file, copy the input to it, then reopen the
the new copy.
*/
if (*file_outfile)
{
/* open the original file, with readonly access */
status = file_openfile(filename, READONLY, &diskfile);
if (status) {
file_outfile[0] = '\0';
return(status);
}
/* create the output file */
status = file_create(file_outfile,handle);
if (status)
{
ffpmsg("Unable to create output file for copy of input file:");
ffpmsg(file_outfile);
file_outfile[0] = '\0';
return(status);
}
/* copy the file from input to output */
while(0 != (nread = fread(recbuf,1,2880, diskfile)))
{
status = file_write(*handle, recbuf, nread);
if (status) {
file_outfile[0] = '\0';
return(status);
}
}
/* close both files */
fclose(diskfile);
copyhandle = *handle;
file_close(*handle);
*handle = copyhandle; /* reuse the old file handle */
/* reopen the new copy, with correct rwmode */
status = file_openfile(file_outfile, rwmode, &diskfile);
file_outfile[0] = '\0';
}
else
{
*handle = -1;
for (ii = 0; ii < NMAXFILES; ii++) /* find empty slot in table */
{
if (handleTable[ii].fileptr == 0)
{
*handle = ii;
break;
}
}
if (*handle == -1)
return(TOO_MANY_FILES); /* too many files opened */
/*open the file */
status = file_openfile(filename, rwmode, &diskfile);
}
handleTable[*handle].fileptr = diskfile;
handleTable[*handle].currentpos = 0;
handleTable[*handle].last_io_op = IO_SEEK;
return(status);
}
/*--------------------------------------------------------------------------*/
int file_is_compressed(char *filename) /* I - FITS file name */
/*
Test if the disk file is compressed. Returns 1 if compressed, 0 if not.
This may modify the filename string by appending a compression suffex.
*/
{
FILE *diskfile;
unsigned char buffer[2];
char tmpfilename[FLEN_FILENAME];
/* Open file. Try various suffix combinations */
if (file_openfile(filename, 0, &diskfile))
{
if (strlen(filename) > FLEN_FILENAME - 1)
return(0);
strcpy(tmpfilename,filename);
strcat(filename,".gz");
if (file_openfile(filename, 0, &diskfile))
{
strcpy(filename, tmpfilename);
strcat(filename,".Z");
if (file_openfile(filename, 0, &diskfile))
{
strcpy(filename, tmpfilename);
strcat(filename,".z"); /* it's often lower case on CDROMs */
if (file_openfile(filename, 0, &diskfile))
{
strcpy(filename, tmpfilename);
strcat(filename,".zip");
if (file_openfile(filename, 0, &diskfile))
{
strcpy(filename, tmpfilename);
strcat(filename,"-z"); /* VMS suffix */
if (file_openfile(filename, 0, &diskfile))
{
strcpy(filename, tmpfilename);
strcat(filename,"-gz"); /* VMS suffix */
if (file_openfile(filename, 0, &diskfile))
{
strcpy(filename,tmpfilename); /* restore original name */
return(0); /* file not found */
}
}
}
}
}
}
}
if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */
{
fclose(diskfile); /* error reading file so just return */
return(0);
}
fclose(diskfile);
/* see if the 2 bytes have the magic values for a compressed file */
if ( (memcmp(buffer, "\037\213", 2) == 0) || /* GZIP */
(memcmp(buffer, "\120\113", 2) == 0) || /* PKZIP */
(memcmp(buffer, "\037\036", 2) == 0) || /* PACK */
(memcmp(buffer, "\037\235", 2) == 0) || /* LZW */
(memcmp(buffer, "\037\240", 2) == 0) ) /* LZH */
{
return(1); /* this is a compressed file */
}
else
{
return(0); /* not a compressed file */
}
}
/*--------------------------------------------------------------------------*/
int file_compress_open(char *filename, int rwmode, int *hdl)
/*
This routine opens the compressed diskfile by creating a new uncompressed
file then opening it. The input file name (the name of the compressed
file) gets replaced with the name of the uncompressed file, which is
initially stored in the global file_outfile string. file_outfile
then gets set to a null string.
*/
{
FILE *indiskfile, *outdiskfile;
int status;
char *cptr;
/* open the compressed disk file */
status = file_openfile(filename, READONLY, &indiskfile);
if (status)
{
ffpmsg("failed to open compressed disk file (file_compress_open)");
ffpmsg(filename);
return(status);
}
/* name of the output uncompressed file is stored in the */
/* global variable called 'file_outfile'. */
cptr = file_outfile;
if (*cptr == '!')
{
/* clobber any existing file with the same name */
cptr++;
remove(cptr);
}
else
{
outdiskfile = fopen(file_outfile, "r"); /* does file already exist? */
if (outdiskfile)
{
ffpmsg("uncompressed file already exists: (file_compress_open)");
ffpmsg(file_outfile);
fclose(outdiskfile); /* close file and exit with error */
file_outfile[0] = '\0';
return(FILE_NOT_CREATED);
}
}
outdiskfile = fopen(cptr, "w+b"); /* create new file */
if (!outdiskfile)
{
ffpmsg("could not create uncompressed file: (file_compress_open)");
ffpmsg(file_outfile);
file_outfile[0] = '\0';
return(FILE_NOT_CREATED);
}
/* uncompress file into another file */
uncompress2file(filename, indiskfile, outdiskfile, &status);
fclose(indiskfile);
fclose(outdiskfile);
if (status)
{
ffpmsg("error in file_compress_open: failed to uncompressed file:");
ffpmsg(filename);
ffpmsg(" into new output file:");
ffpmsg(file_outfile);
file_outfile[0] = '\0';
return(status);
}
strcpy(filename, cptr); /* switch the names */
file_outfile[0] = '\0';
status = file_open(filename, rwmode, hdl);
return(status);
}
/*--------------------------------------------------------------------------*/
int mem_rawfile_open(char *filename, int rwmode, int *hdl)
/*
This routine creates an empty memory buffer, writes a minimal
image header, then copies the image data from the raw file into
memory. It will byteswap the pixel values if the raw array
is in little endian byte order.
*/
{
FILE *diskfile;
fitsfile *fptr;
short *sptr;
int status, endian, datatype, bytePerPix, naxis;
long dim[5] = {1,1,1,1,1}, ii, nvals, offset = 0;
size_t filesize = 0, datasize;
char rootfile[FLEN_FILENAME], *cptr = 0, *cptr2 = 0;
void *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open raw binary file with WRITE access (mem_rawfile_open)");
ffpmsg(filename);
return(READONLY_FILE);
}
cptr = strchr(filename, '['); /* search for opening bracket [ */
if (!cptr)
{
ffpmsg("binary file name missing '[' character (mem_rawfile_open)");
ffpmsg(filename);
return(URL_PARSE_ERROR);
}
*rootfile = '\0';
strncat(rootfile, filename, cptr - filename); /* store the rootname */
cptr++;
while (*cptr == ' ')
cptr++; /* skip leading blanks */
/* Get the Data Type of the Image */
if (*cptr == 'b' || *cptr == 'B')
{
datatype = BYTE_IMG;
bytePerPix = 1;
}
else if (*cptr == 'i' || *cptr == 'I')
{
datatype = SHORT_IMG;
bytePerPix = 2;
}
else if (*cptr == 'u' || *cptr == 'U')
{
datatype = USHORT_IMG;
bytePerPix = 2;
}
else if (*cptr == 'j' || *cptr == 'J')
{
datatype = LONG_IMG;
bytePerPix = 4;
}
else if (*cptr == 'r' || *cptr == 'R' || *cptr == 'f' || *cptr == 'F')
{
datatype = FLOAT_IMG;
bytePerPix = 4;
}
else if (*cptr == 'd' || *cptr == 'D')
{
datatype = DOUBLE_IMG;
bytePerPix = 8;
}
else
{
ffpmsg("error in raw binary file datatype (mem_rawfile_open)");
ffpmsg(filename);
return(URL_PARSE_ERROR);
}
cptr++;
/* get Endian: Big or Little; default is same as the local machine */
if (*cptr == 'b' || *cptr == 'B')
{
endian = 0;
cptr++;
}
else if (*cptr == 'l' || *cptr == 'L')
{
endian = 1;
cptr++;
}
else
endian = BYTESWAPPED; /* byteswapped machines are little endian */
/* read each dimension (up to 5) */
naxis = 1;
dim[0] = strtol(cptr, &cptr2, 10);
if (cptr2 && *cptr2 == ',')
{
naxis = 2;
dim[1] = strtol(cptr2+1, &cptr, 10);
if (cptr && *cptr == ',')
{
naxis = 3;
dim[2] = strtol(cptr+1, &cptr2, 10);
if (cptr2 && *cptr2 == ',')
{
naxis = 4;
dim[3] = strtol(cptr2+1, &cptr, 10);
if (cptr && *cptr == ',')
naxis = 5;
dim[4] = strtol(cptr+1, &cptr2, 10);
}
}
}
cptr = maxvalue(cptr, cptr2);
if (*cptr == ':') /* read starting offset value */
offset = strtol(cptr+1, 0, 10);
nvals = dim[0] * dim[1] * dim[2] * dim[3] * dim[4];
datasize = nvals * bytePerPix;
filesize = nvals * bytePerPix + 2880;
filesize = ((filesize - 1) / 2880 + 1) * 2880;
/* open the raw binary disk file */
status = file_openfile(rootfile, READONLY, &diskfile);
if (status)
{
ffpmsg("failed to open raw binary file (mem_rawfile_open)");
ffpmsg(rootfile);
return(status);
}
/* create a memory file with corrct size for the FITS converted raw file */
status = mem_createmem(filesize, hdl);
if (status)
{
ffpmsg("failed to create memory file (mem_rawfile_open)");
fclose(diskfile);
return(status);
}
/* open this piece of memory as a new FITS file */
ffimem(&fptr, (void **) memTable[*hdl].memaddrptr, &filesize, 0, 0, &status);
/* write the required header keywords */
ffcrim(fptr, datatype, naxis, dim, &status);
/* close the FITS file, but keep the memory allocated */
ffclos(fptr, &status);
if (status > 0)
{
ffpmsg("failed to write basic image header (mem_rawfile_open)");
fclose(diskfile);
mem_close_free(*hdl); /* free up the memory */
return(status);
}
if (offset > 0)
fseek(diskfile, offset, 0); /* offset to start of the data */
/* read the raw data into memory */
ptr = *memTable[*hdl].memaddrptr + 2880;
if (fread((char *) ptr, 1, datasize, diskfile) != datasize)
status = READ_ERROR;
fclose(diskfile); /* close the raw binary disk file */
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to copy raw file data into memory (mem_rawfile_open)");
return(status);
}
if (datatype == USHORT_IMG) /* have to subtract 32768 from each unsigned */
{ /* value to conform to FITS convention. More */
/* efficient way to do this is to just flip */
/* the most significant bit. */
sptr = (short *) ptr;
if (endian == BYTESWAPPED) /* working with native format */
{
for (ii = 0; ii < nvals; ii++, sptr++)
{
*sptr = ( *sptr ) ^ 0x8000;
}
}
else /* pixels are byteswapped WRT the native format */
{
for (ii = 0; ii < nvals; ii++, sptr++)
{
*sptr = ( *sptr ) ^ 0x80;
}
}
}
if (endian) /* swap the bytes if array is in little endian byte order */
{
if (datatype == SHORT_IMG || datatype == USHORT_IMG)
{
ffswap2( (short *) ptr, nvals);
}
else if (datatype == LONG_IMG || datatype == FLOAT_IMG)
{
ffswap4( (INT32BIT *) ptr, nvals);
}
else if (datatype == DOUBLE_IMG)
{
ffswap8( (double *) ptr, nvals);
}
}
memTable[*hdl].currentpos = 0; /* save starting position */
memTable[*hdl].fitsfilesize=filesize; /* and initial file size */
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_compress_open(char *filename, int rwmode, int *hdl)
/*
This routine opens the compressed diskfile and creates an empty memory
buffer with an appropriate size, then calls mem_uncompress2mem.
*/
{
FILE *diskfile;
int status, estimated = 1;
unsigned char buffer[4];
size_t finalsize;
char *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open compressed file with WRITE access (mem_compress_open)");
ffpmsg(filename);
return(READONLY_FILE);
}
/* open the compressed disk file */
status = file_openfile(filename, READONLY, &diskfile);
if (status)
{
ffpmsg("failed to open compressed disk file (compress_open)");
ffpmsg(filename);
return(status);
}
if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */
{
fclose(diskfile);
return(READ_ERROR);
}
if (memcmp(buffer, "\037\213", 2) == 0) /* GZIP */
{
/* the uncompressed file size is give at the end of the file */
fseek(diskfile, 0, 2); /* move to end of file */
fseek(diskfile, -4L, 1); /* move back 4 bytes */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
finalsize = buffer[0];
finalsize |= buffer[1] << 8;
finalsize |= buffer[2] << 16;
finalsize |= buffer[3] << 24;
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\120\113", 2) == 0) /* PKZIP */
{
/* the uncompressed file size is give at byte 22 the file */
fseek(diskfile, 22L, 0); /* move to byte 22 */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
finalsize = buffer[0];
finalsize |= buffer[1] << 8;
finalsize |= buffer[2] << 16;
finalsize |= buffer[3] << 24;
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\037\036", 2) == 0) /* PACK */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\235", 2) == 0) /* LZW */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\240", 2) == 0) /* LZH */
finalsize = 0; /* for most methods we can't determine final size */
else
{
/* not a compressed file; this should never happen */
fclose(diskfile);
return(1);
}
if (finalsize == 0) /* estimate uncompressed file size */
{
fseek(diskfile, 0, 2); /* move to end of the compressed file */
finalsize = ftell(diskfile); /* position = size of file */
finalsize = finalsize * 3; /* assume factor of 3 compression */
}
fseek(diskfile, 0, 0); /* move back to beginning of file */
/* create a memory file big enough (hopefully) for the uncompressed file */
status = mem_createmem(finalsize, hdl);
if (status && estimated)
{
/* memory allocation failed, so try a smaller estimated size */
finalsize = finalsize / 3;
status = mem_createmem(finalsize, hdl);
}
if (status)
{
fclose(diskfile);
ffpmsg("failed to create empty memory file (compress_open)");
return(status);
}
/* uncompress file into memory */
status = mem_uncompress2mem(filename, diskfile, *hdl);
fclose(diskfile);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to uncompress file into memory (compress_open)");
return(status);
}
/* if we allocated too much memory initially, then free it */
if (*(memTable[*hdl].memsizeptr) >
(( (size_t) memTable[*hdl].fitsfilesize) + 256L) )
{
ptr = realloc(*(memTable[*hdl].memaddrptr),
memTable[*hdl].fitsfilesize);
if (!ptr)
{
ffpmsg("Failed to reduce size of allocated memory (compress_open)");
return(MEMORY_ALLOCATION);
}
*(memTable[*hdl].memaddrptr) = ptr;
*(memTable[*hdl].memsizeptr) = memTable[*hdl].fitsfilesize;
}
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_compress_open(char *filename, int rwmode, int *hdl)
/*
This routine opens the compressed diskfile and creates an empty memory
buffer with an appropriate size, then calls mem_uncompress2mem.
*/
{
FILE *diskfile;
int status, estimated = 1;
unsigned char buffer[4];
size_t finalsize, filesize;
LONGLONG llsize = 0;
unsigned int modulosize;
char *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open compressed file with WRITE access (mem_compress_open)");
ffpmsg(filename);
return(READONLY_FILE);
}
/* open the compressed disk file */
status = file_openfile(filename, READONLY, &diskfile);
if (status)
{
ffpmsg("failed to open compressed disk file (compress_open)");
ffpmsg(filename);
return(status);
}
if (fread(buffer, 1, 2, diskfile) != 2) /* read 2 bytes */
{
fclose(diskfile);
return(READ_ERROR);
}
if (memcmp(buffer, "\037\213", 2) == 0) /* GZIP */
{
/* the uncompressed file size is give at the end */
/* of the file in the ISIZE field (modulo 2^32) */
fseek(diskfile, 0, 2); /* move to end of file */
filesize = ftell(diskfile); /* position = size of file */
fseek(diskfile, -4L, 1); /* move back 4 bytes */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
modulosize = buffer[0];
modulosize |= buffer[1] << 8;
modulosize |= buffer[2] << 16;
modulosize |= buffer[3] << 24;
/*
the field ISIZE in the gzipped file header only stores 4 bytes and contains
the uncompressed file size modulo 2^32. If the uncompressed file size
is less than the compressed file size (filesize), then one probably needs to
add 2^32 = 4294967296 to the uncompressed file size, assuming that the gzip
produces a compressed file that is smaller than the original file.
But one must allow for the case of very small files, where the
gzipped file may actually be larger then the original uncompressed file.
Therefore, only perform the modulo 2^32 correction test if the compressed
file is greater than 10,000 bytes in size. (Note: this threhold would
fail only if the original file was greater than 2^32 bytes in size AND gzip
was able to compress it by more than a factor of 400,000 (!) which seems
highly unlikely.)
Also, obviously, this 2^32 modulo correction cannot be performed if the
finalsize variable is only 32-bits long. Typically, the 'size_t' integer
type must be 8 bytes or larger in size to support data files that are
greater than 2 GB (2^31 bytes) in size.
*/
finalsize = modulosize;
if (sizeof(size_t) > 4 && filesize > 10000) {
llsize = (LONGLONG) finalsize;
/* use LONGLONG variable to suppress compiler warning */
while (llsize < (LONGLONG) filesize) llsize += 4294967296;
finalsize = (size_t) llsize;
}
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\120\113", 2) == 0) /* PKZIP */
{
/* the uncompressed file size is give at byte 22 the file */
fseek(diskfile, 22L, 0); /* move to byte 22 */
fread(buffer, 1, 4L, diskfile); /* read 4 bytes */
/* have to worry about integer byte order */
modulosize = buffer[0];
modulosize |= buffer[1] << 8;
modulosize |= buffer[2] << 16;
modulosize |= buffer[3] << 24;
finalsize = modulosize;
estimated = 0; /* file size is known, not estimated */
}
else if (memcmp(buffer, "\037\036", 2) == 0) /* PACK */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\235", 2) == 0) /* LZW */
finalsize = 0; /* for most methods we can't determine final size */
else if (memcmp(buffer, "\037\240", 2) == 0) /* LZH */
finalsize = 0; /* for most methods we can't determine final size */
else
{
/* not a compressed file; this should never happen */
fclose(diskfile);
return(1);
}
if (finalsize == 0) /* estimate uncompressed file size */
{
fseek(diskfile, 0, 2); /* move to end of the compressed file */
finalsize = ftell(diskfile); /* position = size of file */
finalsize = finalsize * 3; /* assume factor of 3 compression */
}
fseek(diskfile, 0, 0); /* move back to beginning of file */
/* create a memory file big enough (hopefully) for the uncompressed file */
status = mem_createmem(finalsize, hdl);
if (status && estimated)
{
/* memory allocation failed, so try a smaller estimated size */
finalsize = finalsize / 3;
status = mem_createmem(finalsize, hdl);
}
if (status)
{
fclose(diskfile);
ffpmsg("failed to create empty memory file (compress_open)");
return(status);
}
/* uncompress file into memory */
status = mem_uncompress2mem(filename, diskfile, *hdl);
fclose(diskfile);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to uncompress file into memory (compress_open)");
return(status);
}
/* if we allocated too much memory initially, then free it */
if (*(memTable[*hdl].memsizeptr) >
(( (size_t) memTable[*hdl].fitsfilesize) + 256L) )
{
ptr = realloc(*(memTable[*hdl].memaddrptr),
((size_t) memTable[*hdl].fitsfilesize) );
if (!ptr)
{
ffpmsg("Failed to reduce size of allocated memory (compress_open)");
return(MEMORY_ALLOCATION);
}
*(memTable[*hdl].memaddrptr) = ptr;
*(memTable[*hdl].memsizeptr) = (size_t) (memTable[*hdl].fitsfilesize);
}
return(0);
}
