/*--------------------------------------------------------------------------*/
int ffcpdt(fitsfile *infptr, /* I - FITS file pointer to input file */
fitsfile *outfptr, /* I - FITS file pointer to output file */
int *status) /* IO - error status */
{
/*
copy the data unit from the CHDU of infptr to the CHDU of outfptr.
This will overwrite any data already in the outfptr CHDU.
*/
long nb, ii;
LONGLONG indatastart, indataend, outdatastart;
char buffer[2880];
if (*status > 0)
return(*status);
if (infptr == outfptr)
return(*status = SAME_FILE);
ffghadll(infptr, NULL, &indatastart, &indataend, status);
ffghadll(outfptr, NULL, &outdatastart, NULL, status);
/* Calculate the number of blocks to be copied */
nb = (long) ((indataend - indatastart) / 2880);
if (nb > 0)
{
if (infptr->Fptr == outfptr->Fptr)
{
/* copying between 2 HDUs in the SAME file */
for (ii = 0; ii < nb; ii++)
{
ffmbyt(infptr, indatastart, REPORT_EOF, status);
ffgbyt(infptr, 2880L, buffer, status); /* read input block */
ffmbyt(outfptr, outdatastart, IGNORE_EOF, status);
ffpbyt(outfptr, 2880L, buffer, status); /* write output block */
indatastart += 2880; /* move address */
outdatastart += 2880; /* move address */
}
}
else
{
/* copying between HDUs in separate files */
/* move to the initial copy position in each of the files */
ffmbyt(infptr, indatastart, REPORT_EOF, status);
ffmbyt(outfptr, outdatastart, IGNORE_EOF, status);
for (ii = 0; ii < nb; ii++)
{
ffgbyt(infptr, 2880L, buffer, status); /* read input block */
ffpbyt(outfptr, 2880L, buffer, status); /* write output block */
}
}
}
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffwrhdu(fitsfile *infptr, /* I - FITS file pointer to input file */
FILE *outstream, /* I - stream to write HDU to */
int *status) /* IO - error status */
{
/*
write the data unit from the CHDU of infptr to the output file stream
*/
long nb, ii;
LONGLONG hdustart, hduend;
char buffer[2880];
if (*status > 0)
return(*status);
ffghadll(infptr, &hdustart, NULL, &hduend, status);
nb = (long) ((hduend - hdustart) / 2880); /* number of blocks to copy */
if (nb > 0)
{
/* move to the start of the HDU */
ffmbyt(infptr, hdustart, REPORT_EOF, status);
for (ii = 0; ii < nb; ii++)
{
ffgbyt(infptr, 2880L, buffer, status); /* read input block */
fwrite(buffer, 1, 2880, outstream ); /* write to output stream */
}
}
return(*status);
}
/*--------------------------------------------------------------------------*/
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 ffdrec(fitsfile *fptr, /* I - FITS file pointer */
int keypos, /* I - position in header of keyword to delete */
int *status) /* IO - error status */
/*
Delete a header keyword at position keypos. The 1st keyword is at keypos=1.
*/
{
int ii, nshift;
long bytepos;
char *inbuff, *outbuff, *tmpbuff, buff1[81], buff2[81];
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
if (keypos < 1 ||
keypos > fptr->headend - fptr->headstart[fptr->curhdu] / 80 )
return(*status = KEY_OUT_BOUNDS);
fptr->nextkey = fptr->headstart[fptr->curhdu] + (keypos - 1) * 80;
nshift=( fptr->headend - fptr->nextkey ) / 80; /* no. keywords to shift */
bytepos = fptr->headend - 80; /* last keyword in header */
/* construct a blank keyword */
strcpy(buff2, " ");
strcat(buff2, " ");
inbuff = buff1;
outbuff = buff2;
for (ii = 0; ii < nshift; ii++) /* shift each keyword up one position */
{
ffmbyt(fptr, bytepos, REPORT_EOF, status);
ffgbyt(fptr, 80, inbuff, status); /* read the current keyword */
ffmbyt(fptr, bytepos, REPORT_EOF, status);
ffpbyt(fptr, 80, outbuff, status); /* overwrite with next keyword */
tmpbuff = inbuff; /* swap input and output buffers */
inbuff = outbuff;
outbuff = tmpbuff;
bytepos -= 80;
}
fptr->headend -= 80; /* decrement the position of the END keyword */
return(*status);
}
/*--------------------------------------------------------------------------*/
int ffpclx( fitsfile *fptr, /* I - FITS file pointer */
int colnum, /* I - number of column to write (1 = 1st col) */
LONGLONG frow, /* I - first row to write (1 = 1st row) */
long fbit, /* I - first bit to write (1 = 1st) */
long nbit, /* I - number of bits to write */
char *larray, /* I - array of logicals corresponding to bits */
int *status) /* IO - error status */
/*
write an array of logical values to a specified bit or byte
column of the binary table. If larray is TRUE, then the corresponding
bit is set to 1, otherwise it is set to 0.
The binary table column being written to must have datatype 'B' or 'X'.
*/
{
LONGLONG offset, bstart, repeat, rowlen, elemnum, rstart, estart, tnull;
long fbyte, lbyte, nbyte, bitloc, ndone;
long ii, twidth, incre;
int tcode, descrp, maxelem, hdutype;
double dummyd;
char tform[12], snull[12];
unsigned char cbuff;
static unsigned char onbit[8] = {128, 64, 32, 16, 8, 4, 2, 1};
static unsigned char offbit[8] = {127, 191, 223, 239, 247, 251, 253, 254};
tcolumn *colptr;
if (*status > 0) /* inherit input status value if > 0 */
return(*status);
/* check input parameters */
if (nbit < 1)
return(*status);
else if (frow < 1)
return(*status = BAD_ROW_NUM);
else if (fbit < 1)
return(*status = BAD_ELEM_NUM);
/* 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);
fbyte = (fbit + 7) / 8;
lbyte = (fbit + nbit + 6) / 8;
nbyte = lbyte - fbyte +1;
/* Save the current heapsize; ffgcprll will increment the value if */
/* we are writing to a variable length column. */
offset = (fptr->Fptr)->heapsize;
/* call ffgcprll in case we are writing beyond the current end of */
/* the table; it will allocate more space and shift any following */
/* HDU's. Otherwise, we have little use for most of the returned */
/* parameters, therefore just use dummy parameters. */
if (ffgcprll( fptr, colnum, frow, fbyte, nbyte, 1, &dummyd, &dummyd,
tform, &twidth, &tcode, &maxelem, &bstart, &elemnum, &incre,
&repeat, &rowlen, &hdutype, &tnull, snull, status) > 0)
return(*status);
bitloc = fbit - 1 - ((fbit - 1) / 8 * 8);
ndone = 0;
rstart = frow - 1;
estart = fbyte - 1;
colptr = (fptr->Fptr)->tableptr; /* point to first column */
colptr += (colnum - 1); /* offset to correct column structure */
tcode = colptr->tdatatype;
if (abs(tcode) > TBYTE)
return(*status = NOT_LOGICAL_COL); /* not correct datatype column */
if (tcode > 0)
{
descrp = FALSE; /* not a variable length descriptor column */
repeat = colptr->trepeat;
if (tcode == TBIT)
repeat = (repeat + 7) / 8; /* convert from bits to bytes */
if (fbyte > repeat)
return(*status = BAD_ELEM_NUM);
/* calc the i/o pointer location to start of sequence of pixels */
bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
colptr->tbcol + estart;
}
else
{
descrp = TRUE; /* a variable length descriptor column */
/* only bit arrays (tform = 'X') are supported for variable */
/* length arrays. REPEAT is the number of BITS in the array. */
repeat = fbit + nbit -1;
/* write the number of elements and the starting offset. */
/* Note: ffgcprll previous wrote the descripter, but with the */
/* wrong repeat value (gave bytes instead of bits). */
if (tcode == -TBIT)
ffpdes(fptr, colnum, frow, (long) repeat, offset, status);
/* Calc the i/o pointer location to start of sequence of pixels. */
/* ffgcprll has already calculated a value for bstart that */
/* points to the first element of the vector; we just have to */
/* increment it to point to the first element we want to write to. */
/* Note: ffgcprll also already updated the size of the heap, so we */
/* don't have to do that again here. */
bstart += estart;
}
/* move the i/o pointer to the start of the pixel sequence */
ffmbyt(fptr, bstart, IGNORE_EOF, status);
/* read the next byte (we may only be modifying some of the bits) */
while (1)
{
if (ffgbyt(fptr, 1, &cbuff, status) == END_OF_FILE)
{
/* hit end of file trying to read the byte, so just set byte = 0 */
*status = 0;
cbuff = 0;
}
/* move back, to be able to overwrite the byte */
ffmbyt(fptr, bstart, IGNORE_EOF, status);
for (ii = bitloc; (ii < 8) && (ndone < nbit); ii++, ndone++)
{
if(larray[ndone])
cbuff = cbuff | onbit[ii];
else
cbuff = cbuff & offbit[ii];
}
ffpbyt(fptr, 1, &cbuff, status); /* write the modified byte */
if (ndone == nbit) /* finished all the bits */
return(*status);
/* not done, so get the next byte */
bstart++;
if (!descrp)
{
estart++;
if (estart == repeat)
{
/* move the i/o pointer to the next row of pixels */
estart = 0;
rstart = rstart + 1;
bstart = (fptr->Fptr)->datastart + ((fptr->Fptr)->rowlength * rstart) +
colptr->tbcol;
ffmbyt(fptr, bstart, IGNORE_EOF, status);
}
}
bitloc = 0;
}
}
