int
fwritescan( /* write out a scanline */
COLOR *scanline,
int len,
FILE *fp
)
{
COLR *clrscan;
int n;
COLR *sp;
/* get scanline buffer */
if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
return(-1);
clrscan = sp;
/* convert scanline */
n = len;
while (n-- > 0) {
setcolr(sp[0], scanline[0][RED],
scanline[0][GRN],
scanline[0][BLU]);
scanline++;
sp++;
}
return(fwritecolrs(clrscan, len, fp));
}
int imb_savehdr(struct ImBuf *ibuf, const char *name, int flags)
{
FILE* file = fopen(name, "wb");
float *fp= NULL;
int y, width=ibuf->x, height=ibuf->y;
unsigned char *cp= NULL;
(void)flags; /* unused */
if (file==NULL) return 0;
writeHeader(file, width, height);
if(ibuf->rect)
cp= (unsigned char *)ibuf->rect + ibuf->channels*(height-1)*width;
if(ibuf->rect_float)
fp= ibuf->rect_float + ibuf->channels*(height-1)*width;
for (y=height-1;y>=0;y--) {
if (fwritecolrs(file, width, ibuf->channels, cp, fp) < 0) {
fclose(file);
printf("HDR write error\n");
return 0;
}
if(cp) cp-= ibuf->channels*width;
if(fp) fp-= ibuf->channels*width;
}
fclose(file);
return 1;
}
void
writepict( /* write the picture to a file */
char *s
)
{
static char buf[128];
char *fname;
FILE *fp;
COLR *scanline;
int y;
/* XXX relies on words.c 2.11 behavior */
if (nextword(buf, sizeof(buf), s) == NULL && !buf[0]) {
error(COMMAND, "no file");
return;
}
if ((fname = getpath(buf, NULL, 0)) == NULL ||
(fp = fopen(fname, "w")) == NULL) {
sprintf(errmsg, "cannot open \"%s\"", buf);
error(COMMAND, errmsg);
return;
}
SET_FILE_BINARY(fp);
(*dev->comout)("writing \"");
(*dev->comout)(fname);
(*dev->comout)("\"...\n");
/* write header */
newheader("RADIANCE", fp);
fputs(progname, fp);
fprintview(&ourview, fp);
if (octname != NULL)
fprintf(fp, " %s\n", octname);
else
putc('\n', fp);
fprintf(fp, "SOFTWARE= %s\n", VersionID);
fputnow(fp);
if (exposure != 1.0)
fputexpos(exposure, fp);
if (dev->pixaspect != 1.0)
fputaspect(dev->pixaspect, fp);
fputformat(COLRFMT, fp);
putc('\n', fp);
fprtresolu(hresolu, vresolu, fp);
scanline = (COLR *)malloc(hresolu*sizeof(COLR));
if (scanline == NULL) {
error(COMMAND, "not enough memory!");
fclose(fp);
unlink(fname);
return;
}
for (y = vresolu-1; y >= 0; y--) {
getpictcolrs(y, scanline, &ptrunk, hresolu, vresolu);
if (fwritecolrs(scanline, hresolu, fp) < 0)
break;
}
free((void *)scanline);
if (fclose(fp) < 0)
error(COMMAND, "write error");
}
bool CHDRImageFileType::write(const Image *image,
std::ostream &os,
const std::string &mimetype)
{
#if 0
if(image->getDataType() != Image::OSG_FLOAT32_IMAGEDATA)
{
FWARNING(("HDRImageFileType::write: Image has non float data "
"type!\n"));
return false;
}
if(!os.good())
return false;
int width = image->getWidth();
int height = image->getHeight();
os << "#?RADIANCE" << std::endl;
os << "# Written with OpenSG" << std::endl;
os << "FORMAT=32-bit_rle_rgbe" << std::endl;
os << "EXPOSURE=" << 1.0f << std::endl << std::endl;
os << "-Y " << height << " +X " << width << std::endl;
RGBE *rgbe_scan = new RGBE[width];
Real32 *data = ((Real32 *)(image->getData()));
//upside down !!!
for(int y=height-1; y>=0; y--)
{
if (fwritecolrs(os,
&data[y * width * 3],
rgbe_scan,
width,
height) < 0)
{
delete [] rgbe_scan;
return false;
}
}
delete [] rgbe_scan;
#endif
return true;
}
static void
rotateccw( /* rotate picture counter-clockwise */
FILE *fp
)
{
register COLR *inln;
register int xoff, inx, iny;
long start, ftell();
if ((inln = (COLR *)malloc(xres*sizeof(COLR))) == NULL) {
fprintf(stderr, "%s: out of memory\n", progname);
exit(1);
}
start = ftell(fp);
for (xoff = xres-1; xoff >= 0; xoff -= nrows) {
if (fseek(fp, start, 0) < 0) {
fprintf(stderr, "%s: seek error\n", progname);
exit(1);
}
for (iny = 0; iny < yres; iny++) {
if (freadcolrs(inln, xres, fp) < 0) {
fprintf(stderr, "%s: read error\n", progname);
exit(1);
}
for (inx = 0; inx < nrows && xoff-inx >= 0; inx++)
copycolr(scanbar[inx*yres+iny],
inln[xoff-inx]);
}
for (inx = 0; inx < nrows && xoff-inx >= 0; inx++)
if (fwritecolrs(scanbar+inx*yres, yres, stdout) < 0) {
fprintf(stderr, "%s: write error\n", progname);
exit(1);
}
}
free((void *)inln);
}
static void
ppm2ra( /* convert 1-byte Pixmap to Radiance picture */
colrscanf_t *getscan
)
{
COLR *scanout;
int y;
/* allocate scanline */
scanout = (COLR *)malloc(xmax*sizeof(COLR));
if (scanout == NULL)
quiterr("out of memory in ppm2ra");
/* convert image */
for (y = ymax-1; y >= 0; y--) {
if ((*getscan)(scanout, xmax, stdin) < 0)
quiterr("error reading Pixmap");
gambs_colrs(scanout, xmax);
if (bradj)
shiftcolrs(scanout, xmax, bradj);
if (fwritecolrs(scanout, xmax, stdout) < 0)
quiterr("error writing Radiance picture");
}
/* free scanline */
free((void *)scanout);
}
static void
compos(void) /* composite pictures */
{
COLR *scanin, *scanout;
int y;
register int x, i;
scanin = (COLR *)malloc((xmax-xmin)*sizeof(COLR));
if (scanin == NULL)
goto memerr;
scanin -= xmin;
if (checkthresh) {
scanout = (COLR *)malloc(xsiz*sizeof(COLR));
if (scanout == NULL)
goto memerr;
} else
scanout = scanin;
for (y = ymax-1; y >= 0; y--) {
for (x = 0; x < xsiz; x++)
copycolr(scanout[x], bgcolr);
for (i = 0; i < nfile; i++) {
if (input[i].yloc > y ||
input[i].yloc+input[i].yres <= y)
continue;
if (freadcolrs(scanin+input[i].xloc,
input[i].xres, input[i].fp) < 0) {
fprintf(stderr, "%s: read error (y==%d)\n",
input[i].name,
y-input[i].yloc);
quit(1);
}
if (y >= ysiz)
continue;
if (checkthresh) {
x = input[i].xloc+input[i].xres;
if (x > xsiz)
x = xsiz;
for (x--; x >= 0 && x >= input[i].xloc; x--) {
if (input[i].flags & HASMIN &&
cmpcolr(scanin[x], input[i].thmin) <= 0)
continue;
if (input[i].flags & HASMAX &&
cmpcolr(scanin[x], input[i].thmax) >= 0)
continue;
copycolr(scanout[x], scanin[x]);
}
}
}
if (y >= ysiz)
continue;
if (fwritecolrs(scanout, xsiz, stdout) < 0) {
perror(progname);
quit(1);
}
}
/* read remainders from streams */
for (i = 0; i < nfile; i++)
if (input[i].name[0] == '<')
while (getc(input[i].fp) != EOF)
;
return;
memerr:
perror(progname);
quit(1);
}
static void
clrdebug(void) /* put out debug picture from color input */
{
static COLR blkclr = BLKCOLR;
COLR mbclr[24], cvclr[24], orclr[24];
COLR *scan;
COLOR ctmp, ct2;
int y, i;
register int x, rg;
/* convert colors */
for (i = 0; i < 24; i++) {
copycolor(ctmp, mbRGB[i]);
clipgamut(ctmp, bright(ctmp), CGAMUT, cblack, cwhite);
setcolr(mbclr[i], colval(ctmp,RED),
colval(ctmp,GRN), colval(ctmp,BLU));
if (inpflags & 1L<<i) {
copycolor(ctmp, inpRGB[i]);
clipgamut(ctmp, bright(ctmp), CGAMUT, cblack, cwhite);
setcolr(orclr[i], colval(ctmp,RED),
colval(ctmp,GRN), colval(ctmp,BLU));
if (rawmap)
copycolr(cvclr[i], mbclr[i]);
else {
bresp(ctmp, inpRGB[i]);
colortrans(ct2, solmat, ctmp);
clipgamut(ct2, bright(ct2), CGAMUT,
cblack, cwhite);
setcolr(cvclr[i], colval(ct2,RED),
colval(ct2,GRN),
colval(ct2,BLU));
}
}
}
/* allocate scanline */
scan = (COLR *)malloc(xmax*sizeof(COLR));
if (scan == NULL) {
perror(progname);
exit(1);
}
/* finish debug header */
fputformat(COLRFMT, debugfp);
putc('\n', debugfp);
fprtresolu(xmax, ymax, debugfp);
/* write debug picture */
for (y = ymax-1; y >= 0; y--) {
for (x = 0; x < xmax; x++) {
rg = chartndx(x, y, &i);
if (rg == RG_CENT) {
if (!(1L<<i & gmtflags) || (x+y)&07)
copycolr(scan[x], mbclr[i]);
else
copycolr(scan[x], blkclr);
} else if (rg == RG_BORD || !(1L<<i & inpflags))
copycolr(scan[x], blkclr);
else if (rg == RG_ORIG)
copycolr(scan[x], orclr[i]);
else /* rg == RG_CORR */
copycolr(scan[x], cvclr[i]);
}
if (fwritecolrs(scan, xmax, debugfp) < 0) {
fprintf(stderr, "%s: error writing debugging picture\n",
progname);
exit(1);
}
}
/* clean up */
fclose(debugfp);
free((void *)scan);
}
static int
transfer( /* transfer a Radiance picture */
char *ospec
)
{
char oname[PATH_MAX];
FILE *fp;
int order;
int xmax, ymax;
COLR *scanin;
int y;
/* get header info. */
if (!(y = loadheader(stdin)))
return(0);
if (y < 0 || (order = fgetresolu(&xmax, &ymax, stdin)) < 0) {
fprintf(stderr, "%s: bad input format\n", progname);
exit(1);
}
/* did we pass the target frame? */
if (findframe && findframe < frameno)
return(0);
/* allocate scanline */
scanin = (COLR *)tempbuffer(xmax*sizeof(COLR));
if (scanin == NULL) {
perror(progname);
exit(1);
}
/* skip frame? */
if (findframe > frameno) {
for (y = ymax; y--; )
if (freadcolrs(scanin, xmax, stdin) < 0) {
fprintf(stderr,
"%s: error reading input picture\n",
progname);
exit(1);
}
return(1);
}
/* open output file/command */
if (ospec == NULL) {
strcpy(oname, "<stdout>");
fp = stdout;
} else {
sprintf(oname, ospec, frameno);
if (oname[0] == '!') {
if ((fp = popen(oname+1, "w")) == NULL) {
fprintf(stderr, "%s: cannot start \"%s\"\n",
progname, oname);
exit(1);
}
} else {
if (!force && access(oname, 0) >= 0) {
fprintf(stderr,
"%s: output file \"%s\" exists\n",
progname, oname);
exit(1);
}
if ((fp = fopen(oname, "w")) == NULL) {
fprintf(stderr, "%s: ", progname);
perror(oname);
exit(1);
}
}
}
SET_FILE_BINARY(fp);
dumpheader(fp); /* put out header */
fputs(progname, fp);
if (bradj)
fprintf(fp, " -e %+d", bradj);
if (!doflat)
fputs(" -r", fp);
fputc('\n', fp);
if (bradj)
fputexpos(pow(2.0, (double)bradj), fp);
fputc('\n', fp);
fputresolu(order, xmax, ymax, fp);
/* transfer picture */
for (y = ymax; y--; ) {
if (freadcolrs(scanin, xmax, stdin) < 0) {
fprintf(stderr, "%s: error reading input picture\n",
progname);
exit(1);
}
if (bradj)
shiftcolrs(scanin, xmax, bradj);
if (doflat)
putbinary((char *)scanin, sizeof(COLR), xmax, fp);
else
fwritecolrs(scanin, xmax, fp);
if (ferror(fp)) {
fprintf(stderr, "%s: error writing output to \"%s\"\n",
progname, oname);
exit(1);
}
}
/* clean up */
if (oname[0] == '!')
pclose(fp);
else if (ospec != NULL)
fclose(fp);
return(1);
}
