/*-----------------------------------------------------
Parameters:
Returns value:
Description
------------------------------------------------------*/
int
ImageFWrite(IMAGE *I, FILE *fp, const char*fname)
{
byte *image ;
int ecode, type, frame;
char buf[100] ;
if (!fname)
fname = "ImageFWrite" ;
strcpy(buf, fname) ; /* don't destroy callers string */
ImageUnpackFileName(buf, &frame, &type, buf) ;
switch (type)
{
case RGBI_IMAGE:
RGBwrite(I, buf, frame) ;
break ;
case TIFF_IMAGE:
TiffWriteImage(I, buf, frame) ;
break ;
default:
case JPEG_IMAGE:
JPEGWriteImage(I, buf, frame);
break;
case PGM_IMAGE:
PGMWriteImage(I, buf, frame);
break;
case PPM_IMAGE:
PPMWriteImage(I, buf, frame);
break;
case HIPS_IMAGE:
if (endian == END_UNDEF)
endian = FindMachineEndian();
if (findparam(I,"endian"))
clearparam(I,"endian"); /* Clear any existing endian parameter */
setparam(I, "endian", PFBYTE, 1, endian);
ecode = fwrite_header(fp,I,"fwrite") ;
if (ecode != HIPS_OK)
ErrorExit(ERROR_NO_FILE,"ImageFWrite: fwrite_header failed (%d)\n",ecode);
image = I->image ;
for (frame = 0 ; frame < I->num_frame ; frame++)
{
ecode = fwrite_image(fp, I, frame, "fwrite") ;
if (ecode != HIPS_OK)
ErrorExit(ERROR_NO_FILE,
"ImageFWrite: fwrite_image frame %d failed (%d)\n",ecode,frame);
I->image += I->sizeimage ; /* next frame */
}
I->image = image ;
break ;
}
return(0) ;
}
void hh_save(value out_filename) {
CAMLparam1(out_filename);
FILE* fp = fopen(String_val(out_filename), "wb");
fwrite_header(fp);
fwrite_no_fail(&heap_init_size, sizeof heap_init_size, 1, fp);
/*
* Format of the compressed shared memory:
* LZ4 can only work in chunks of 2GB, so we compress each chunk individually,
* and write out each one as
* [compressed size of chunk][uncompressed size of chunk][chunk]
* A compressed size of zero indicates the end of the compressed section.
*/
char* chunk_start = save_start();
int compressed_size = 0;
while (chunk_start < *heap) {
uintptr_t remaining = *heap - chunk_start;
uintptr_t chunk_size = LZ4_MAX_INPUT_SIZE < remaining ?
LZ4_MAX_INPUT_SIZE : remaining;
char* compressed = malloc(chunk_size * sizeof(char));
assert(compressed != NULL);
compressed_size = LZ4_compressHC(chunk_start, compressed,
chunk_size);
assert(compressed_size > 0);
fwrite_no_fail(&compressed_size, sizeof compressed_size, 1, fp);
fwrite_no_fail(&chunk_size, sizeof chunk_size, 1, fp);
fwrite_no_fail((void*)compressed, 1, compressed_size, fp);
chunk_start += chunk_size;
free(compressed);
}
compressed_size = 0;
fwrite_no_fail(&compressed_size, sizeof compressed_size, 1, fp);
fclose(fp);
CAMLreturn0;
}
void hh_save_dep_table(value out_filename) {
CAMLparam1(out_filename);
FILE* fp = fopen(String_val(out_filename), "wb");
fwrite_header(fp);
int compressed_size = 0;
assert(LZ4_MAX_INPUT_SIZE >= DEP_SIZE_B);
char* compressed = malloc(DEP_SIZE_B);
assert(compressed != NULL);
compressed_size = LZ4_compressHC((char*)deptbl, compressed, DEP_SIZE_B);
assert(compressed_size > 0);
fwrite_no_fail(&compressed_size, sizeof compressed_size, 1, fp);
fwrite_no_fail((void*)compressed, 1, compressed_size, fp);
free(compressed);
fclose(fp);
CAMLreturn0;
}
/*----------------------------------------------------------------------
Parameters:
Description:
append an image to the end of a hips sequence file, incrementing
the number of frames recorded in the header.
----------------------------------------------------------------------*/
int
ImageAppend(IMAGE *I, const char*fname)
{
FILE *fp ;
int ecode, frame = 0, nframes ;
IMAGE Iheader, *Iframe ;
char tmpname[200] ;
fp = fopen(fname, "r+b") ;
#if 0
if (!fp)
ErrorReturn(-1, (ERROR_NO_FILE, "ImageAppend(%s) failed\n", fname)) ;
#endif
if (!fp)
return(ImageWrite(I, fname)) ;
ecode = fread_header(fp, &Iheader, fname) ;
if (ecode != HIPS_OK)
ErrorExit(ERROR_NO_FILE, "ImageAppend: fread_header failed (%d)\n",ecode);
/* increment # of frames, and update file header */
Iheader.num_frame++ ;
nframes = Iheader.num_frame ;
if (nframes == 10 || nframes == 100 || nframes == 1000)
{
/* header size will grow by 1 byte, must copy whole file (ughhh) */
fclose(fp) ;
strcpy(tmpname,FileTmpName(NULL)) ;
FileRename(fname, tmpname) ;
/* write out new header */
fp = fopen(fname, "wb") ;
if (!fp)
ErrorReturn(-1, (ERROR_NO_FILE, "ImageAppend(%s) failed\n", fname)) ;
ecode = fwrite_header(fp, &Iheader, fname) ;
if (ecode != HIPS_OK)
ErrorExit(ERROR_NO_FILE,"ImageAppend: fwrite_header failed (%d)\n",ecode);
nframes = Iheader.num_frame - 1 ;
for (frame = 0 ; frame < nframes ; frame++)
{
Iframe = ImageReadFrames(tmpname, frame, 1) ;
if (!Iframe)
ErrorReturn(-3, (ERROR_BADFILE,
"ImageAppend: could not read %dth frame", frame)) ;
ecode = fwrite_image(fp, Iframe, frame, fname) ;
if (ecode != HIPS_OK)
ErrorReturn(-4, (ERROR_BADFILE,
"ImageAppend: fwrite_image frame %d failed (%d)\n",
ecode,frame));
}
unlink(tmpname) ;
}
else /* seek back to start and increment # of frames */
{
if (fseek(fp, 0L, SEEK_SET) < 0)
ErrorReturn(-2,(ERROR_BADFILE,"ImageAppend(%s): could not seek to end"));
ecode = fwrite_header(fp, &Iheader, fname) ;
if (ecode != HIPS_OK)
ErrorExit(ERROR_NO_FILE,"ImageAppend: fwrite_header failed (%d)\n",ecode);
}
if (fseek(fp, 0L, SEEK_END) < 0)
ErrorReturn(-2, (ERROR_BADFILE, "ImageAppend(%s): could not seek to end"));
ecode = fwrite_image(fp, I, frame, "fwrite") ;
if (ecode != HIPS_OK)
ErrorReturn(-1, (ERROR_BADFILE,
"ImageAppend: fwrite_image frame %d failed (%d)\n",ecode,frame));
free_hdrcon(&Iheader) ;
fclose(fp) ;
return(NO_ERROR) ;
}
int
LPAFwriteImageAnswer(LPAF *lpaf, int current)
{
char *fullname, tmpname[100], fname[100] ;
IMAGE Iheader, *I ;
FILE *infp, *outfp ;
int ecode, frame, nframes, *parms, i, current_frame, type ;
LP_BOX *lpb ;
struct extpar *xp ;
fullname = lpaf->filelist[current] ;
ImageUnpackFileName(fullname, ¤t_frame, &type, fname) ;
if (type != HIPS_IMAGE)
return(0) ;
infp = fopen(fname, "rb") ;
if (!infp)
ErrorReturn(-1,(ERROR_NO_FILE,
"LPAFwriteImageAnswer(%d): could not open %s",
current, fname)) ;
ecode = fread_header(infp, &Iheader, fname) ;
if (ecode)
{
fclose(infp) ;
ErrorReturn(-2, (ERROR_BADFILE,
"LPAFwriteImageAnswer(%d): could not read header", current));
}
fclose(infp) ;
if (Iheader.numparam == 0) /* must make room for header in image file */
{
lpafAllocParms(&Iheader) ;
/* now copy the old image file to a new one which has room for parms */
nframes = Iheader.num_frame ;
strcpy(tmpname, FileTmpName(NULL)) ;
outfp = fopen(tmpname, "wb") ;
Iheader.num_frame = 0 ; /* ImageAppend will bump num_frame on each call */
ecode = fwrite_header(outfp, &Iheader, tmpname) ;
fclose(outfp) ; /* flush file */
fprintf(stderr, "rewriting image file to make room for parms...\n") ;
for (frame = 0 ; frame < nframes ; frame++)
{
I = ImageReadFrames(fname, frame, 1) ;
if (!I)
ErrorExit(ERROR_BADFILE, "LPwriteImageAnswer: could not read frame");
ImageAppend(I, tmpname) ;
ImageFree(&I) ;
}
FileRename(tmpname, fname) ;
Iheader.num_frame = nframes ; /* reset correct # of frames */
}
/* now put answer into header */
lpb = &lpaf->coords[current] ;
for (frame = 0, xp = Iheader.params ; xp ; xp = xp->nextp)
if (frame++ == current_frame)
break ;
parms = xp->val.v_pi ;
parms[0] = lpb->xc ;
parms[1] = lpb->yc ;
for (i = 0 ; i < NPOINTS ; i++)
{
parms[2+2*i] = lpb->xp[i] ;
parms[2+2*i+1] = lpb->yp[i] ;
}
ImageUpdateHeader(&Iheader, fname) ;
free_hdrcon(&Iheader) ;
return(1) ;
}
