/*--------------------------------------------------------------------------*/
int mem_iraf_open(char *filename, int rwmode, int *hdl)
/*
This routine creates an empty memory buffer, then calls iraf2mem to
open the IRAF disk file and convert it to a FITS file in memeory.
*/
{
int status;
size_t filesize = 0;
/* create a memory file with size = 0 for the FITS converted IRAF file */
status = mem_createmem(filesize, hdl);
if (status)
{
ffpmsg("failed to create empty memory file (mem_iraf_open)");
return(status);
}
/* convert the iraf file into a FITS file in memory */
status = iraf2mem(filename, memTable[*hdl].memaddrptr,
memTable[*hdl].memsizeptr, &filesize, &status);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to convert IRAF file into memory (mem_iraf_open)");
return(status);
}
memTable[*hdl].currentpos = 0; /* save starting position */
memTable[*hdl].fitsfilesize=filesize; /* and initial file size */
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_compress_stdin_open(char *filename, int rwmode, int *hdl)
/*
This routine reads the compressed input stream and creates an empty memory
buffer, then calls mem_uncompress2mem.
*/
{
int status;
char *ptr;
if (rwmode != READONLY)
{
ffpmsg(
"cannot open compressed input stream with WRITE access (mem_compress_stdin_open)");
return(READONLY_FILE);
}
/* create a memory file for the uncompressed file */
status = mem_createmem(28800, hdl);
if (status)
{
ffpmsg("failed to create empty memory file (compress_stdin_open)");
return(status);
}
/* uncompress file into memory */
status = mem_uncompress2mem(filename, stdin, *hdl);
if (status)
{
mem_close_free(*hdl); /* free up the memory */
ffpmsg("failed to uncompress stdin into memory (compress_stdin_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_stdin_open)");
return(MEMORY_ALLOCATION);
}
*(memTable[*hdl].memaddrptr) = ptr;
*(memTable[*hdl].memsizeptr) = memTable[*hdl].fitsfilesize;
}
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_create(char *filename, int *handle)
/*
Create a new empty memory file for subsequent writes.
The file name is ignored in this case.
*/
{
int status;
/* initially allocate 1 FITS block = 2880 bytes */
status = mem_createmem(2880L, handle);
if (status)
{
ffpmsg("failed to create empty memory file (mem_create)");
return(status);
}
return(0);
}
/*--------------------------------------------------------------------------*/
int mem_create_comp(char *filename, int *handle)
/*
Create a new empty memory file for subsequent writes.
Also create an empty compressed .gz file. The memory file
will be compressed and written to the disk file when the file is closed.
*/
{
FILE *diskfile;
char mode[4];
int status;
/* first, create disk file for the compressed output */
if ( !strcmp(filename, "-.gz") || !strcmp(filename, "stdout.gz") ||
!strcmp(filename, "STDOUT.gz") )
{
/* special case: create uncompressed FITS file in memory, then
compress it an write it out to 'stdout' when it is closed. */
diskfile = stdout;
}
else
{
/* normal case: create disk file for the compressed output */
strcpy(mode, "w+b"); /* create file with read-write */
diskfile = fopen(filename, "r"); /* does file already exist? */
if (diskfile)
{
fclose(diskfile); /* close file and exit with error */
return(FILE_NOT_CREATED);
}
#if MACHINE == ALPHAVMS || MACHINE == VAXVMS
/* specify VMS record structure: fixed format, 2880 byte records */
/* but force stream mode access to enable random I/O access */
diskfile = fopen(filename, mode, "rfm=fix", "mrs=2880", "ctx=stm");
#else
diskfile = fopen(filename, mode);
#endif
if (!(diskfile)) /* couldn't create file */
{
return(FILE_NOT_CREATED);
}
}
/* now create temporary memory file */
/* initially allocate 1 FITS block = 2880 bytes */
status = mem_createmem(2880L, handle);
if (status)
{
ffpmsg("failed to create empty memory file (mem_create_comp)");
return(status);
}
memTable[*handle].fileptr = diskfile;
return(0);
}
/*--------------------------------------------------------------------------*/
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 stdin_open(char *filename, int rwmode, int *handle)
/*
open a FITS file from the stdin file stream by copying it into memory
The file name is ignored in this case.
*/
{
int status = 0;
char cbuff;
if (*stdin_outfile)
{
/* copy the stdin stream to the specified disk file then open the file */
/* Create the output file */
status = file_create(stdin_outfile,handle);
if (status)
{
ffpmsg("Unable to create output file to copy stdin (stdin_open):");
ffpmsg(stdin_outfile);
return(status);
}
/* copy the whole stdin stream to the file */
status = stdin2file(*handle);
file_close(*handle);
if (status)
{
ffpmsg("failed to copy stdin to file (stdin_open)");
ffpmsg(stdin_outfile);
return(status);
}
/* reopen file with proper rwmode attribute */
status = file_open(stdin_outfile, rwmode, handle);
}
else
{
/* get the first character, then put it back */
cbuff = fgetc(stdin);
ungetc(cbuff, stdin);
/* compressed files begin with 037 or 'P' */
if (cbuff == 31 || cbuff == 75)
{
/* looks like the input stream is compressed */
status = mem_compress_stdin_open(filename, rwmode, handle);
}
else
{
/* copy the stdin stream into memory then open file in memory */
if (rwmode != READONLY)
{
ffpmsg("cannot open stdin with WRITE access");
return(READONLY_FILE);
}
status = mem_createmem(2880L, handle);
if (status)
{
ffpmsg("failed to create empty memory file (stdin_open)");
return(status);
}
/* copy the whole stdin stream into memory */
status = stdin2mem(*handle);
if (status)
{
ffpmsg("failed to copy stdin into memory (stdin_open)");
free(memTable[*handle].memaddr);
}
}
}
return(status);
}
/*--------------------------------------------------------------------------*/
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);
}