/*--------------------------------------------------------------------------*/
int ffikey(fitsfile *fptr, /* I - FITS file pointer */
char *card, /* I - card string value */
int *status) /* IO - error status */
/*
insert a keyword at the position of fptr->nextkey
*/
{
int nshift;
size_t ii, len;
long nblocks, bytepos;
char *inbuff, *outbuff, *tmpbuff, buff1[80], buff2[80];
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if ( (fptr->datastart - fptr->headend) == 80) /* only room for END card */
{
nblocks = 1;
if (ffiblk(fptr, nblocks, 0, status) > 0) /* add new 2880-byte block*/
return(*status);
}
nshift=( fptr->headend - fptr->nextkey ) / 80; /* no. keywords to shift */
strncpy(buff2, card, 80); /* copy card to output buffer */
len = strlen(buff2);
for (ii=len; ii < 80; ii++) /* fill buffer with spaces if necessary */
buff2[ii] = ' ';
inbuff = buff1;
outbuff = buff2;
bytepos = fptr->nextkey; /* pointer to next keyword in header */
ffmbyt(fptr, bytepos, REPORT_EOF, status);
for (ii = 0; ii < nshift; ii++) /* shift each keyword down one position */
{
ffgbyt(fptr, 80, inbuff, status); /* read the current keyword */
ffmbyt(fptr, bytepos, REPORT_EOF, status); /* move back */
ffpbyt(fptr, 80, outbuff, status); /* overwrite with other buffer */
tmpbuff = inbuff; /* swap input and output buffers */
inbuff = outbuff;
outbuff = tmpbuff;
bytepos += 80;
}
ffpbyt(fptr, 80, outbuff, status); /* write the final keyword */
fptr->headend += 80; /* increment the position of the END keyword */
fptr->nextkey += 80; /* increment the pointer to next keyword */
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffibin(fitsfile *fptr, /* I - FITS file pointer */
LONGLONG naxis2, /* I - number of rows in the table */
int tfields, /* I - number of columns in the table */
char **ttype, /* I - name of each column */
char **tform, /* I - value of TFORMn keyword for each column */
char **tunit, /* I - value of TUNITn keyword for each column */
const char *extnmx, /* I - value of EXTNAME keyword, if any */
LONGLONG pcount, /* I - size of special data area (heap) */
int *status) /* IO - error status */
/*
insert a Binary table extension following the current HDU
*/
{
int nexthdu, maxhdu, ii, nunit, nhead, datacode;
LONGLONG naxis1;
long nblocks, repeat, width;
LONGLONG datasize, newstart;
char errmsg[81], extnm[FLEN_VALUE];
if (*status > 0)
return(*status);
extnm[0] = '\0';
if (extnmx)
strncat(extnm, extnmx, FLEN_VALUE-1);
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
maxhdu = (fptr->Fptr)->maxhdu;
/* if the current header is completely empty ... */
if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
/* or, if we are at the end of the file, ... */
|| ( (((fptr->Fptr)->curhdu) == maxhdu ) &&
((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) )
{
/* then simply append new image extension */
ffcrtb(fptr, BINARY_TBL, naxis2, tfields, ttype, tform, tunit,
extnm, status);
return(*status);
}
if (naxis2 < 0)
return(*status = NEG_ROWS);
else if (tfields < 0 || tfields > 999)
{
sprintf(errmsg,
"Illegal value for TFIELDS keyword: %d", tfields);
ffpmsg(errmsg);
return(*status = BAD_TFIELDS);
}
/* count number of optional TUNIT keywords to be written */
nunit = 0;
for (ii = 0; ii < tfields; ii++)
{
if (tunit && *tunit && *tunit[ii])
nunit++;
}
if (extnm && *extnm)
nunit++; /* add one for the EXTNAME keyword */
nhead = (9 + (2 * tfields) + nunit + 35) / 36; /* no. of header blocks */
/* calculate total width of the table */
naxis1 = 0;
for (ii = 0; ii < tfields; ii++)
{
ffbnfm(tform[ii], &datacode, &repeat, &width, status);
if (datacode == TBIT)
naxis1 = naxis1 + ((repeat + 7) / 8);
else if (datacode == TSTRING)
naxis1 += repeat;
else
naxis1 = naxis1 + (repeat * width);
}
datasize = ((LONGLONG)naxis1 * naxis2) + pcount; /* size of table in bytes */
nblocks = (long) ((datasize + 2879) / 2880) + nhead; /* size of HDU */
if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */
{ /* close the CHDU */
ffrdef(fptr, status); /* scan header to redefine structure */
ffpdfl(fptr, status); /* insure correct data file values */
}
else
return(*status = READONLY_FILE);
nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */
newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */
(fptr->Fptr)->hdutype = BINARY_TBL; /* so that correct fill value is used */
/* ffiblk also increments headstart for all following HDUs */
if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */
return(*status);
((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */
for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--)
(fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */
(fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */
/* set default parameters for this new empty HDU */
(fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */
fptr->HDUposition = nexthdu; /* we are now located at the next HDU */
(fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + (nhead * 2880);
(fptr->Fptr)->hdutype = BINARY_TBL; /* might need to be reset... */
/* write the required header keywords. This will write PCOUNT = 0 */
/* so that the variable length data will be written at the right place */
ffphbn(fptr, naxis2, tfields, ttype, tform, tunit, extnm, pcount,
status);
/* redefine internal structure for this HDU (with PCOUNT = 0) */
ffrdef(fptr, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffitab(fitsfile *fptr, /* I - FITS file pointer */
LONGLONG naxis1, /* I - width of row in the table */
LONGLONG naxis2, /* I - number of rows in the table */
int tfields, /* I - number of columns in the table */
char **ttype, /* I - name of each column */
long *tbcol, /* I - byte offset in row to each column */
char **tform, /* I - value of TFORMn keyword for each column */
char **tunit, /* I - value of TUNITn keyword for each column */
const char *extnmx, /* I - value of EXTNAME keyword, if any */
int *status) /* IO - error status */
/*
insert an ASCII table extension following the current HDU
*/
{
int nexthdu, maxhdu, ii, nunit, nhead, ncols, gotmem = 0;
long nblocks, rowlen;
LONGLONG datasize, newstart;
char errmsg[81], extnm[FLEN_VALUE];
if (*status > 0)
return(*status);
extnm[0] = '\0';
if (extnmx)
strncat(extnm, extnmx, FLEN_VALUE-1);
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
maxhdu = (fptr->Fptr)->maxhdu;
/* if the current header is completely empty ... */
if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu] )
/* or, if we are at the end of the file, ... */
|| ( (((fptr->Fptr)->curhdu) == maxhdu ) &&
((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) )
{
/* then simply append new image extension */
ffcrtb(fptr, ASCII_TBL, naxis2, tfields, ttype, tform, tunit,
extnm, status);
return(*status);
}
if (naxis1 < 0)
return(*status = NEG_WIDTH);
else if (naxis2 < 0)
return(*status = NEG_ROWS);
else if (tfields < 0 || tfields > 999)
{
sprintf(errmsg,
"Illegal value for TFIELDS keyword: %d", tfields);
ffpmsg(errmsg);
return(*status = BAD_TFIELDS);
}
/* count number of optional TUNIT keywords to be written */
nunit = 0;
for (ii = 0; ii < tfields; ii++)
{
if (tunit && *tunit && *tunit[ii])
nunit++;
}
if (extnm && *extnm)
nunit++; /* add one for the EXTNAME keyword */
rowlen = (long) naxis1;
if (!tbcol || !tbcol[0] || (!naxis1 && tfields)) /* spacing not defined? */
{
/* allocate mem for tbcol; malloc may have problems allocating small */
/* arrays, so allocate at least 20 bytes */
ncols = maxvalue(5, tfields);
tbcol = (long *) calloc(ncols, sizeof(long));
if (tbcol)
{
gotmem = 1;
/* calculate width of a row and starting position of each column. */
/* Each column will be separated by 1 blank space */
ffgabc(tfields, tform, 1, &rowlen, tbcol, status);
}
}
nhead = (9 + (3 * tfields) + nunit + 35) / 36; /* no. of header blocks */
datasize = (LONGLONG)rowlen * naxis2; /* size of table in bytes */
nblocks = (long) (((datasize + 2879) / 2880) + nhead); /* size of HDU */
if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */
{ /* close the CHDU */
ffrdef(fptr, status); /* scan header to redefine structure */
ffpdfl(fptr, status); /* insure correct data file values */
}
else
return(*status = READONLY_FILE);
nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */
newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */
(fptr->Fptr)->hdutype = ASCII_TBL; /* so that correct fill value is used */
/* ffiblk also increments headstart for all following HDUs */
if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */
{
if (gotmem)
free(tbcol);
return(*status);
}
((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */
for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--)
(fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */
(fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */
/* set default parameters for this new empty HDU */
(fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */
fptr->HDUposition = nexthdu; /* we are now located at the next HDU */
(fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + (nhead * 2880);
(fptr->Fptr)->hdutype = ASCII_TBL; /* might need to be reset... */
/* write the required header keywords */
ffphtb(fptr, rowlen, naxis2, tfields, ttype, tbcol, tform, tunit,
extnm, status);
if (gotmem)
free(tbcol);
/* redefine internal structure for this HDU */
ffrdef(fptr, status);
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffiimgll(fitsfile *fptr, /* I - FITS file pointer */
int bitpix, /* I - bits per pixel */
int naxis, /* I - number of axes in the array */
LONGLONG *naxes, /* I - size of each axis */
int *status) /* IO - error status */
/*
insert an IMAGE extension following the current HDU
*/
{
int bytlen, nexthdu, maxhdu, ii, onaxis;
long nblocks;
LONGLONG npixels, newstart, datasize;
char errmsg[FLEN_ERRMSG], card[FLEN_CARD], naxiskey[FLEN_KEYWORD];
if (*status > 0)
return(*status);
if (fptr->HDUposition != (fptr->Fptr)->curhdu)
ffmahd(fptr, (fptr->HDUposition) + 1, NULL, status);
maxhdu = (fptr->Fptr)->maxhdu;
if (*status != PREPEND_PRIMARY)
{
/* if the current header is completely empty ... */
if (( (fptr->Fptr)->headend == (fptr->Fptr)->headstart[(fptr->Fptr)->curhdu])
/* or, if we are at the end of the file, ... */
|| ( (((fptr->Fptr)->curhdu) == maxhdu ) &&
((fptr->Fptr)->headstart[maxhdu + 1] >= (fptr->Fptr)->logfilesize ) ) )
{
/* then simply append new image extension */
ffcrimll(fptr, bitpix, naxis, naxes, status);
return(*status);
}
}
if (bitpix == 8)
bytlen = 1;
else if (bitpix == 16)
bytlen = 2;
else if (bitpix == 32 || bitpix == -32)
bytlen = 4;
else if (bitpix == 64 || bitpix == -64)
bytlen = 8;
else
{
sprintf(errmsg,
"Illegal value for BITPIX keyword: %d", bitpix);
ffpmsg(errmsg);
return(*status = BAD_BITPIX); /* illegal bitpix value */
}
if (naxis < 0 || naxis > 999)
{
sprintf(errmsg,
"Illegal value for NAXIS keyword: %d", naxis);
ffpmsg(errmsg);
return(*status = BAD_NAXIS);
}
for (ii = 0; ii < naxis; ii++)
{
if (naxes[ii] < 0)
{
sprintf(errmsg,
"Illegal value for NAXIS%d keyword: %ld", ii + 1, (long) naxes[ii]);
ffpmsg(errmsg);
return(*status = BAD_NAXES);
}
}
/* calculate number of pixels in the image */
if (naxis == 0)
npixels = 0;
else
npixels = naxes[0];
for (ii = 1; ii < naxis; ii++)
npixels = npixels * naxes[ii];
datasize = npixels * bytlen; /* size of image in bytes */
nblocks = (long) (((datasize + 2879) / 2880) + 1); /* +1 for the header */
if ((fptr->Fptr)->writemode == READWRITE) /* must have write access */
{ /* close the CHDU */
ffrdef(fptr, status); /* scan header to redefine structure */
ffpdfl(fptr, status); /* insure correct data file values */
}
else
return(*status = READONLY_FILE);
if (*status == PREPEND_PRIMARY)
{
/* inserting a new primary array; the current primary */
/* array must be transformed into an image extension. */
*status = 0;
ffmahd(fptr, 1, NULL, status); /* move to the primary array */
ffgidm(fptr, &onaxis, status);
if (onaxis > 0)
ffkeyn("NAXIS",onaxis, naxiskey, status);
else
strcpy(naxiskey, "NAXIS");
ffgcrd(fptr, naxiskey, card, status); /* read last NAXIS keyword */
ffikyj(fptr, "PCOUNT", 0, "required keyword", status); /* add PCOUNT and */
ffikyj(fptr, "GCOUNT", 1, "required keyword", status); /* GCOUNT keywords */
if (*status > 0)
return(*status);
if (ffdkey(fptr, "EXTEND", status) ) /* delete the EXTEND keyword */
*status = 0;
/* redefine internal structure for this HDU */
ffrdef(fptr, status);
/* insert space for the primary array */
if (ffiblk(fptr, nblocks, -1, status) > 0) /* insert the blocks */
return(*status);
nexthdu = 0; /* number of the new hdu */
newstart = 0; /* starting addr of HDU */
}
else
{
nexthdu = ((fptr->Fptr)->curhdu) + 1; /* number of the next (new) hdu */
newstart = (fptr->Fptr)->headstart[nexthdu]; /* save starting addr of HDU */
(fptr->Fptr)->hdutype = IMAGE_HDU; /* so that correct fill value is used */
/* ffiblk also increments headstart for all following HDUs */
if (ffiblk(fptr, nblocks, 1, status) > 0) /* insert the blocks */
return(*status);
}
((fptr->Fptr)->maxhdu)++; /* increment known number of HDUs in the file */
for (ii = (fptr->Fptr)->maxhdu; ii > (fptr->Fptr)->curhdu; ii--)
(fptr->Fptr)->headstart[ii + 1] = (fptr->Fptr)->headstart[ii]; /* incre start addr */
if (nexthdu == 0)
(fptr->Fptr)->headstart[1] = nblocks * 2880; /* start of the old Primary array */
(fptr->Fptr)->headstart[nexthdu] = newstart; /* set starting addr of HDU */
/* set default parameters for this new empty HDU */
(fptr->Fptr)->curhdu = nexthdu; /* we are now located at the next HDU */
fptr->HDUposition = nexthdu; /* we are now located at the next HDU */
(fptr->Fptr)->nextkey = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->headend = (fptr->Fptr)->headstart[nexthdu];
(fptr->Fptr)->datastart = ((fptr->Fptr)->headstart[nexthdu]) + 2880;
(fptr->Fptr)->hdutype = IMAGE_HDU; /* might need to be reset... */
/* write the required header keywords */
ffphprll(fptr, TRUE, bitpix, naxis, naxes, 0, 1, TRUE, status);
/* redefine internal structure for this HDU */
ffrdef(fptr, status);
return(*status);
}
