ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/RpictSimulManager.cpp

Comparing ray/src/rt/RpictSimulManager.cpp (file contents):
Revision 2.2 by greg, Sun Aug 18 00:37:13 2024 UTC vs.
Revision 2.7 by greg, Thu Aug 22 00:44:02 2024 UTC

#	Line 359 | Line 359 | RpictSimulManager::RenderRect()
359		int             sp2 = ceil(log2((TWidth()>THeight() ? TWidth() : THeight()) - 1.));
360		int             layer = 0;
361		int             x, y;
362	<	fprintf(stderr, "Rendering %dx%d tile with psample=%d, maxdiff=%.3f ...\n",
363	<	TWidth(), THeight(), psample, maxdiff);
362	>	// fprintf(stderr, "Rendering %dx%d tile with psample=%d, maxdiff=%.3f ...\n",
363	>	// TWidth(), THeight(), psample, maxdiff);
364		while (sp2 > 0) {
365		ABitMap2        sampMap(TWidth(), THeight());
366		int             noff[4][2];
#	Line 394 | Line 394 | TWidth(), THeight(), psample, maxdiff);
394		if (!ComputePixel(x, y))
395		return false;
396		doneSamples |= sampMap; // samples now done or at least queued
397	<	fprintf(stderr, "Sampled %ld pixels at (sp2,layer)=(%d,%d)\n",
398	<	(long)sampMap.SumTotal(), sp2, layer);
399	<	fprintf(stderr, "\t%ld pixels (%.3f%%) completed (+%ld in process)\n",
400	<	(long)doneMap.SumTotal(), 100.*doneMap.SumTotal()/doneMap.Width()/doneMap.Height(),
401	<	(long)(doneSamples.SumTotal()-doneMap.SumTotal()));
397	>	// fprintf(stderr, "Sampled %ld pixels at (sp2,layer)=(%d,%d)\n",
398	>	// (long)sampMap.SumTotal(), sp2, layer);
399	>	// fprintf(stderr, "\t%ld pixels (%.3f%%) completed (+%ld in process)\n",
400	>	// (long)doneMap.SumTotal(), 100.*doneMap.SumTotal()/doneMap.Width()/doneMap.Height(),
401	>	// (long)(doneSamples.SumTotal()-doneMap.SumTotal()));
402		sp2 -= layer++ & 1;     // next denser sampling
403		}
404		if (FlushQueue() < 0)           // make sure we got everyone
#	Line 471 | Line 471 | RpictSimulManager::RenderTile(COLRV *bp, int ystride,
471		return SetTile(tile) && RenderRect();
472		}
473
474	+	// Back to float color with 16-bit depth
475	+	bool
476	+	RpictSimulManager::RenderTile(COLORV *rp, int ystride, short *dp, const int *tile)
477	+	{
478	+	if (!rp | (GetWidth() <= 0) | (GetHeight() <= 0) | !vw.type)
479	+	return false;
480	+	if (!ystride)                   // contiguous rows?
481	+	ystride = TWidth();
482	+	pacc.Init(rp, ystride, dp);
483	+	if (prims == xyzprims)
484	+	pacc.SetColorSpace(RDTxyz);
485	+	else if (prims)
486	+	pacc.SetColorSpace(RDTrgb, prims);
487	+
488	+	return SetTile(tile) && RenderRect();
489	+	}
490	+
491		// Allocate a new render bar
492		void
493		RpictSimulManager::NewBar(int ht)
#	Line 501 | Line 518 | RpictSimulManager::NewBar(int ht)
518
519		// Shift render bar area the specified amount down the frame
520		bool
521	<	RpictSimulManager::LowerBar(int v)
521	>	RpictSimulManager::LowerBar(int v, int ytop)
522		{
506	–	if (v <= 0) return !v;
523		if (!barPix | !barDepth | (v > THeight()) | !tvw.type)
524		return false;
525	+	if (v <= 0) return !v;
526	+	if ((ytop -= v) <= 0)
527	+	return true;
528		tvw.voff -= double(v)/THeight();
529		ptvw.voff -= double(v)/THeight();
530		if (v == THeight()) {
#	Line 518 | Line 537 | RpictSimulManager::LowerBar(int v)
537		sizeof(COLORV)*NC*TWidth()*(THeight()-v));
538		memmove(barDepth, barDepth + TWidth()*v,
539		sizeof(float)*TWidth()*(THeight()-v));
540	+	if (ytop < THeight()) {                 // mark what we won't do as finished
541	+	doneMap.ClearRect(0, 0, TWidth(), THeight()-ytop, true);
542	+	memset(barPix, 0, sizeof(COLORV)*NC*TWidth()*(THeight()-ytop));
543	+	memset(barDepth, 0, sizeof(float)*TWidth()*(THeight()-ytop));
544	+	}
545		return true;
546		}
547
#	Line 559 | Line 583 | RpictSimulManager::RenderBelow(int ytop, const int vst
583		}
584		int             lastOut = ytop;         // render down frame
585		while (ytop > 0) {
586	<	fprintf(stderr, "At y=%d, source drawing %s...\n", ytop, parr ? "ON" : "OFF");
563	<	if (ytop < THeight())           // mark what we won't do as finished
564	<	doneMap.ClearRect(0, 0, TWidth(), THeight()-ytop, true);
586	>	// fprintf(stderr, "At y=%d, source drawing %s...\n", ytop, parr ? "ON" : "OFF");
587		if (prCB)
588		(*prCB)(100.*(GetHeight()-ytop)/GetHeight());
589		if (!RenderRect())              // render this bar
#	Line 612 | Line 634 | fprintf(stderr, "At y=%d, source drawing %s...\n", yto
634		if (fflush(pfp) == EOF || (dfp && fflush(dfp) == EOF))
635		error(SYSTEM, "output write error");
636		// advance down the frame
637	<	if (lastOut > 0 && !LowerBar(vstep))
637	>	if (lastOut > 0 && !LowerBar(vstep, ytop))
638		return false;
639		ytop -= vstep;
640		}
#	Line 623 | Line 645 | fprintf(stderr, "At y=%d, source drawing %s...\n", yto
645		return true;
646		}
647
648	<	/*
627	<	* Render and write a frame to the named file
628	<	* Include any header lines set prior to call
629	<	* Picture file must not already exist
630	<	* Write pixels to stdout if !pfname
631	<	* Write depth to a command if dfname[0]=='!'
632	<	*/
648	>	// Open new output picture file (and optional depth file)
649		RenderDataType
650	<	RpictSimulManager::RenderFrame(const char *pfname, RenderDataType dt, const char *dfname)
650	>	RpictSimulManager::NewOutput(FILE *pdfp[2], const char *pfname,
651	>	RenderDataType dt, const char *dfname)
652		{
653	<	int     fd = 1;
637	<	FILE *  pfp = NULL;
638	<	FILE *  dfp = NULL;
639	<
653	>	pdfp[0] = pdfp[1] = NULL;
654		if (!RDTcolorT(dt))
655	<	error(INTERNAL, "botched color output type in RenderFrame()");
655	>	error(INTERNAL, "botched color output type in NewOutput()");
656		if (NCSAMP == 3) {
657		if (RDTcolorT(dt) == RDTscolr)
658		dt = RDTnewCT(dt, prims==xyzprims ? RDTxyze : RDTrgbe);
#	Line 646 | Line 660 | RpictSimulManager::RenderFrame(const char *pfname, Ren
660		dt = RDTnewCT(dt, prims==xyzprims ? RDTxyz : RDTrgb);
661		}
662		if (!RDTdepthT(dt) ^ !dfname)
663	<	error(INTERNAL, "depth output requires file name and type in RenderFrame()");
663	>	error(INTERNAL, "depth output requires file name and type in NewOutput()");
664	>	int     fd = 1;
665		if (pfname) {                           // open picture output file
666		if (pfname[0] == '!') {
667		error(INTERNAL, "writing picture to a command not supported");
#	Line 662 | Line 677 | RpictSimulManager::RenderFrame(const char *pfname, Ren
677		return RDTnone;                 // expected in parallel sequence
678		}
679		if (fd == 1)
680	<	pfp = stdout;
681	<	else if (!(pfp = fdopen(fd, "w")))
680	>	pdfp[0] = stdout;
681	>	else if (!(pdfp[0] = fdopen(fd, "w")))
682		error(SYSTEM, "failure calling fdopen()");
683	<	SET_FILE_BINARY(pfp);                   // write picture header
684	<	if ((pfp != stdout) | (frameNo <= 1)) {
685	<	newheader("RADIANCE", pfp);
686	<	fputs(GetHeader(), pfp);
683	>	SET_FILE_BINARY(pdfp[0]);               // write picture header
684	>	if ((pdfp[0] != stdout) | (frameNo <= 1)) {
685	>	newheader("RADIANCE", pdfp[0]);
686	>	fputs(GetHeader(), pdfp[0]);
687		}
688	<	fputs(VIEWSTR, pfp); fprintview(&vw, pfp); fputc('\n', pfp);
688	>	fputs(VIEWSTR, pdfp[0]); fprintview(&vw, pdfp[0]); fputc('\n', pdfp[0]);
689		if (frameNo > 0)
690	<	fprintf(pfp, "FRAME=%d\n", frameNo);
690	>	fprintf(pdfp[0], "FRAME=%d\n", frameNo);
691		double  pasp = viewaspect(&vw) * GetWidth() / GetHeight();
692		if ((0.99 > pasp) | (pasp > 1.01))
693	<	fputaspect(pasp, pfp);
694	<	fputnow(pfp);
693	>	fputaspect(pasp, pdfp[0]);
694	>	fputnow(pdfp[0]);
695		switch (RDTcolorT(dt)) {                // set primaries and picture format
696		case RDTrgbe:
697		if (!prims | (prims == xyzprims)) prims = stdprims;
698	<	fputprims(prims, pfp);
699	<	fputformat(COLRFMT, pfp);
698	>	fputprims(prims, pdfp[0]);
699	>	fputformat(COLRFMT, pdfp[0]);
700		break;
701		case RDTxyze:
702		prims = xyzprims;
703	<	fputformat(CIEFMT, pfp);
703	>	fputformat(CIEFMT, pdfp[0]);
704		break;
705		case RDTscolr:
706		prims = NULL;
707	<	fputwlsplit(WLPART, pfp);
708	<	fputncomp(NCSAMP, pfp);
709	<	fputformat(SPECFMT, pfp);
707	>	fputwlsplit(WLPART, pdfp[0]);
708	>	fputncomp(NCSAMP, pdfp[0]);
709	>	fputformat(SPECFMT, pdfp[0]);
710		break;
711		case RDTrgb:
712		if (!prims | (prims == xyzprims)) prims = stdprims;
713	<	fputprims(prims, pfp);
714	<	fputncomp(3, pfp);
715	<	fputendian(pfp);
716	<	fputformat("float", pfp);
713	>	fputprims(prims, pdfp[0]);
714	>	fputncomp(3, pdfp[0]);
715	>	fputendian(pdfp[0]);
716	>	fputformat("float", pdfp[0]);
717		break;
718		case RDTxyz:
719		prims = xyzprims;
720	<	fputprims(prims, pfp);
721	<	fputncomp(3, pfp);
722	<	fputendian(pfp);
723	<	fputformat("float", pfp);
720	>	fputprims(prims, pdfp[0]);
721	>	fputncomp(3, pdfp[0]);
722	>	fputendian(pdfp[0]);
723	>	fputformat("float", pdfp[0]);
724		break;
725		case RDTscolor:
726		prims = NULL;
727	<	fputwlsplit(WLPART, pfp);
728	<	fputncomp(NCSAMP, pfp);
729	<	fputendian(pfp);
730	<	fputformat("float", pfp);
727	>	fputwlsplit(WLPART, pdfp[0]);
728	>	fputncomp(NCSAMP, pdfp[0]);
729	>	fputendian(pdfp[0]);
730	>	fputformat("float", pdfp[0]);
731		break;
732		default:;
733		}
734	<	fputc('\n', pfp);                       // end picture header
735	<	fprtresolu(GetWidth(), GetHeight(), pfp);
736	<	if (dfname) {
734	>	fputc('\n', pdfp[0]);                   // flush picture header + resolution
735	>	if (fflush(pdfp[0]) == EOF) {
736	>	sprintf(errmsg, "cannot write header to picture '%s'", pfname);
737	>	error(SYSTEM, errmsg);
738	>	fclose(pdfp[0]);
739	>	pdfp[0] = NULL;
740	>	return RDTnone;
741	>	}
742	>	if (dfname) {                           // open depth output
743		if (dfname[0] == '!')
744	<	dfp = popen(dfname+1, "w");
744	>	pdfp[1] = popen(dfname+1, "w");
745		else
746	<	dfp = fopen(dfname, "w");
747	<	if (!dfp) {
746	>	pdfp[1] = fopen(dfname, "w");
747	>	if (!pdfp[1]) {
748		sprintf(errmsg, "cannot open depth output '%s'", dfname);
749		error(SYSTEM, errmsg);
750	+	fclose(pdfp[0]);
751	+	pdfp[0] = NULL;
752		return RDTnone;
753		}
754	<	SET_FILE_BINARY(dfp);
754	>	SET_FILE_BINARY(pdfp[1]);
755		}
756		if (RDTdepthT(dt) == RDTdshort) {       // write header for 16-bit depth?
757	<	newheader("RADIANCE", dfp);
758	<	fputs(GetHeader(), dfp);
759	<	fputs(VIEWSTR, dfp); fprintview(&vw, dfp); fputc('\n', dfp);
760	<	fputs(DEPTHSTR, dfp); fputs(dunit, dfp); fputc('\n', dfp);
761	<	fputformat(DEPTH16FMT, dfp);
762	<	fputc('\n', dfp);               // end-of-info
763	<	fprtresolu(GetWidth(), GetHeight(), dfp);
757	>	newheader("RADIANCE", pdfp[1]);
758	>	fputs(GetHeader(), pdfp[1]);
759	>	fputs(VIEWSTR, pdfp[1]); fprintview(&vw, pdfp[1]); fputc('\n', pdfp[1]);
760	>	fputs(DEPTHSTR, pdfp[1]); fputs(dunit, pdfp[1]); fputc('\n', pdfp[1]);
761	>	fputformat(DEPTH16FMT, pdfp[1]);
762	>	fputc('\n', pdfp[1]);           // end-of-info
763	>	if (fflush(pdfp[1]) == EOF) {
764	>	sprintf(errmsg, "cannot write header to '%s'", dfname);
765	>	error(SYSTEM, errmsg);
766	>	fclose(pdfp[0]); fclose(pdfp[1]);
767	>	pdfp[0] = pdfp[1] = NULL;
768	>	return RDTnone;
769	>	}
770		}
771	+	return dt;                              // ready to roll
772	+	}
773	+
774	+	/*
775	+	* Render and write a frame to the named file
776	+	* Include any header lines set prior to call
777	+	* Picture file must not exist
778	+	* Write pixels to stdout if !pfname
779	+	* Write depth to a command if dfname[0]=='!'
780	+	*/
781	+	RenderDataType
782	+	RpictSimulManager::RenderFrame(const char *pfname, RenderDataType dt, const char *dfname)
783	+	{
784	+	FILE    *pdfp[2];
785	+	// prepare output file(s)
786	+	dt = NewOutput(pdfp, pfname, dt, dfname);
787	+	if (dt == RDTnone)
788	+	return RDTnone;
789	+	// add resolution string(s)
790	+	fprtresolu(GetWidth(), GetHeight(), pdfp[0]);
791	+	if (RDTdepthT(dt) == RDTdshort)
792	+	fprtresolu(GetWidth(), GetHeight(), pdfp[1]);
793	+
794		const int       bheight = (psample > 1) ? int(2*psample+.99) : 4;
795		const int       vstep =  bheight >> (psample > 1);
796
797		NewBar(bheight);                        // render frame if we can
798	<	if (!RenderBelow(GetHeight(), vstep, pfp, dt, dfp)) {
799	<	fclose(pfp);
800	<	if (dfp) (dfname[0] == '!') ? pclose(dfp) : fclose(dfp);
798	>	if (!RenderBelow(GetHeight(), vstep, pdfp[0], dt, pdfp[1])) {
799	>	fclose(pdfp[0]);
800	>	if (pdfp[1]) (dfname[0] == '!') ? pclose(pdfp[1]) : fclose(pdfp[1]);
801		Cleanup();
802		return RDTnone;
803		}
804		NewBar();                               // clean up and return
805	<	if (pfp != stdout)
806	<	fclose(pfp);
807	<	if (dfp) {
805	>	if (pdfp[0] != stdout)
806	>	fclose(pdfp[0]);
807	>	if (pdfp[1]) {
808		if (dfname[0] == '!') {
809	<	int     status = pclose(dfp);
809	>	int     status = pclose(pdfp[1]);
810		if (status) {
811		sprintf(errmsg, "depth output (%s) error status: %d",
812		dfname, status);
#	Line 762 | Line 814 | RpictSimulManager::RenderFrame(const char *pfname, Ren
814		return RDTnone;
815		}
816		} else
817	<	fclose(dfp);
817	>	fclose(pdfp[1]);
818		}
819		return dt;
820		}
821
822		// passed struct for header line callback
823	<	struct HeaderInfo {
823	>	static struct HeaderInfo {
824		char            fmt[MAXFMTLEN];
825		char            depth_unit[32];
826		int             ncomp;
#	Line 789 | Line 841 | struct HeaderInfo {
841		gotview = false;
842		endianMatch = true;
843		}
844	<	};
844	>	}       hinfo;          // XXX single copy to hold custom primitives
845
846		// helper function checks header line and records req. info.
847		static int
#	Line 831 | Line 883 | head_check(char *s, void *p)
883		return 0;
884		}
885
886	<	// Resume partially finished rendering
835	<	// Picture file must exist
886	>	// Reopen output file(s), leaving pointers at end of (each) header
887		RenderDataType
888	<	RpictSimulManager::ResumeFrame(const char *pfname, const char *dfname)
888	>	RpictSimulManager::ReopenOutput(FILE *pdfp[2], const char *pfname, const char *dfname)
889		{
890	<	if (!pfname || pfname[0] == '!')
840	<	return RDTnone;
890	>	extern const char       HDRSTR[];
891
892	+	if (!pfname || pfname[0] == '!') {
893	+	pdfp[0] = pdfp[1] = NULL;
894	+	return RDTnone;
895	+	}
896		RenderDataType  dt = RDTnone;
897	<	FILE *          dfp = NULL;
898	<	FILE *          pfp = fopen(pfname, "r+");
899	<	if (!pfp) {
897	>	pdfp[1] = NULL;
898	>	pdfp[0] = fopen(pfname, "r+");
899	>	if (!pdfp[0]) {
900		sprintf(errmsg, "cannot reopen output picture '%s'", pfname);
901		error(SYSTEM, errmsg);
902		return RDTnone;
903		}
904	<	SET_FILE_BINARY(pfp);
905	<	HeaderInfo      hinfo;          // read header information & dimensions
906	<	RESOLU          res;
907	<	if (getheader(pfp, head_check, &hinfo) < 0) {
854	<	fclose(pfp);
904	>	SET_FILE_BINARY(pdfp[0]);       // read header information
905	>	if (getheader(pdfp[0], head_check, &hinfo) < 0) {
906	>	fclose(pdfp[0]);
907	>	pdfp[0] = NULL;
908		return RDTnone;
909		}
857	–	if (!fgetsresolu(&res, pfp) || res.rt != PIXSTANDARD) {
858	–	sprintf(errmsg, "missing/bad resolution for '%s'", pfname);
859	–	error(USER, errmsg);
860	–	fclose(pfp);
861	–	return RDTnone;
862	–	}
910		if (!hinfo.gotview) {
911		sprintf(errmsg, "missing view for '%s'", pfname);
912		error(USER, errmsg);
913	<	fclose(pfp);
913	>	fclose(pdfp[0]);
914	>	pdfp[0] = NULL;
915		return RDTnone;
916		}
917		if (hinfo.ncomp < 3) {
918		sprintf(errmsg, "bad # components (%d) in '%s'", hinfo.ncomp, pfname);
919		error(USER, errmsg);
920	<	fclose(pfp);
920	>	fclose(pdfp[0]);
921	>	pdfp[0] = NULL;
922		return RDTnone;
923		}
924	<	int     bytesPer = 0;           // complicated part to set rendering/output space
924	>	// set rendering/output space
925		if (!strcmp(hinfo.fmt, COLRFMT)) {
926	<	prims = hinfo.prims;
926	>	prims = hinfo.prims;    // XXX static array
927		int     n = 8*hinfo.gotprims;
928		while (n--)
929		if (!FABSEQ(hinfo.prims[0][n], stdprims[0][n]))
#	Line 890 | Line 939 | RpictSimulManager::ResumeFrame(const char *pfname, con
939		sprintf(errmsg, "incompatible sample count (%d) in '%s'",
940		hinfo.ncomp, pfname);
941		error(USER, errmsg);
942	<	fclose(pfp);
942	>	fclose(pdfp[0]);
943	>	pdfp[0] = NULL;
944		return RDTnone;
945		}
946	<	NCSAMP = hinfo.ncomp;   // overrides global setting
946	>	NCSAMP = hinfo.ncomp;           // overrides global setting
947		prims = NULL;
948		dt = RDTnewCT(dt, RDTscolr);
899	–	bytesPer = hinfo.ncomp + 1;     // XXX assumes no compression
949		} else if (!strcmp(hinfo.fmt, "float")) {
950		if (!hinfo.endianMatch) {
951		sprintf(errmsg, "incompatible byte ordering in '%s'", pfname);
952		error(USER, errmsg);
953	<	fclose(pfp);
953	>	fclose(pdfp[0]);
954	>	pdfp[0] = NULL;
955		return RDTnone;
956		}
957		if (hinfo.ncomp == 3) {
958	<	prims = hinfo.prims;            // custom primaries?
958	>	prims = hinfo.prims;    // custom primaries?
959		int     n = 8*hinfo.gotprims;
960		while (n--)
961		if (!FABSEQ(hinfo.prims[0][n], stdprims[0][n]))
962		break;
963	<	if (n < 0)                      // standard primaries?
963	>	if (n < 0)              // standard primaries?
964		prims = stdprims;
965		else if (hinfo.gotprims) {      // or check if XYZ
966		for (n = 8; n--; )
#	Line 928 | Line 978 | RpictSimulManager::ResumeFrame(const char *pfname, con
978		prims = NULL;
979		dt = RDTnewCT(dt, RDTscolor);
980		}
931	–	bytesPer = sizeof(float)*hinfo.ncomp;
981		} else {
982		sprintf(errmsg, "unknown format (%s) for '%s'", hinfo.fmt, pfname);
983		error(USER, errmsg);
984	<	fclose(pfp);
984	>	fclose(pdfp[0]);
985	>	pdfp[0] = NULL;
986		return RDTnone;
987		}
988	+	if (!dfname)                            // no depth file?
989	+	return dt;
990	+
991	+	if (dfname[0] == '!') {
992	+	error(USER, "depth data cannot be reloaded from command");
993	+	fclose(pdfp[0]);
994	+	pdfp[0] = NULL;
995	+	return RDTnone;
996	+	}
997	+	pdfp[1] = fopen(dfname, "r+");
998	+	if (!pdfp[1]) {
999	+	sprintf(errmsg, "cannot reopen depth file '%s'", dfname);
1000	+	error(SYSTEM, errmsg);
1001	+	fclose(pdfp[0]);
1002	+	pdfp[0] = NULL;
1003	+	return RDTnone;
1004	+	}
1005	+	SET_FILE_BINARY(pdfp[1]);
1006	+	int     n, len = strlen(HDRSTR);
1007	+	char    buf[32];                // sniff for 16-bit header
1008	+	if (getbinary(buf, 1, len+1, pdfp[1]) < len+1) {
1009	+	sprintf(errmsg, "empty depth file '%s'", dfname);
1010	+	error(SYSTEM, errmsg);
1011	+	fclose(pdfp[0]); fclose(pdfp[1]);
1012	+	pdfp[0] = pdfp[1] = NULL;
1013	+	return RDTnone;
1014	+	}
1015	+	for (n = 0; n < len; n++)
1016	+	if (buf[n] != HDRSTR[n])
1017	+	break;          // not a Radiance header
1018	+	rewind(pdfp[1]);
1019	+	if ((n < len) | !isprint(buf[len]))
1020	+	return RDTnewDT(dt, RDTdfloat);
1021	+
1022	+	HeaderInfo      dinfo;          // thinking it's 16-bit encoded
1023	+	if (getheader(pdfp[1], head_check, &dinfo) < 0)
1024	+	sprintf(errmsg, "bad header in encoded depth file '%s'",
1025	+	dfname);
1026	+	else if (strcmp(dinfo.fmt, DEPTH16FMT))
1027	+	sprintf(errmsg, "wrong format (%s) for depth file '%s'",
1028	+	dinfo.fmt, dfname);
1029	+	else if (!SetReferenceDepth(dinfo.depth_unit))
1030	+	sprintf(errmsg, "bad/missing reference depth (%s) in '%s'",
1031	+	dinfo.depth_unit, dfname);
1032	+	else
1033	+	errmsg[0] = '\0';
1034	+
1035	+	if (errmsg[0]) {
1036	+	error(USER, errmsg);
1037	+	fclose(pdfp[1]); fclose(pdfp[0]);
1038	+	pdfp[0] = pdfp[1] = NULL;
1039	+	return RDTnone;
1040	+	}
1041	+	return RDTnewDT(dt, RDTdshort);
1042	+	}
1043	+
1044	+	// Resume partially finished rendering
1045	+	// Picture file must exist
1046	+	RenderDataType
1047	+	RpictSimulManager::ResumeFrame(const char *pfname, const char *dfname)
1048	+	{
1049	+	FILE            *pdfp[2];
1050	+
1051	+	RenderDataType  dt = ReopenOutput(pdfp, pfname, dfname);
1052	+	if (dt == RDTnone)
1053	+	return RDTnone;
1054	+
1055	+	int     bytesPer = 0;           // figure out how far we got...
1056	+	switch (RDTcolorT(dt)) {
1057	+	case RDTrgbe:
1058	+	case RDTxyze:
1059	+	break;
1060	+	case RDTscolr:
1061	+	bytesPer = hinfo.ncomp + 1;     // XXX assumes no compression
1062	+	break;
1063	+	case RDTrgb:
1064	+	case RDTxyz:
1065	+	bytesPer = sizeof(float)*3;
1066	+	break;
1067	+	case RDTscolor:
1068	+	bytesPer = sizeof(float)*hinfo.ncomp;
1069	+	break;
1070	+	default:
1071	+	sprintf(errmsg, "unknown format (%s) for '%s'", hinfo.fmt, pfname);
1072	+	error(USER, errmsg);
1073	+	fclose(pdfp[0]);
1074	+	if (pdfp[1]) fclose(pdfp[1]);
1075	+	return RDTnone;
1076	+	}
1077	+	RESOLU  res;
1078	+	if (!fgetsresolu(&res, pdfp[0]) || res.rt != PIXSTANDARD) {
1079	+	sprintf(errmsg, "missing/bad resolution for '%s'", pfname);
1080	+	error(USER, errmsg);
1081	+	fclose(pdfp[0]);
1082	+	if (pdfp[1]) fclose(pdfp[1]);
1083	+	return RDTnone;
1084	+	}
1085		vw.type = 0;                            // set up new (unreferenced) frame
1086		frameNo = 0;
1087		int     hvdim[2] = {res.xr, res.yr};
1088		double  noAdj = 0;
1089		if (!NewFrame(hinfo.vw, hvdim, &noAdj) ||
1090		(hvdim[0] != res.xr) | (hvdim[1] != res.yr)) {
1091	<	fclose(pfp);
1091	>	error(CONSISTENCY, "unexpected resolution change in ResumeFrame()");
1092	>	fclose(pdfp[0]);
1093	>	if (pdfp[1]) fclose(pdfp[1]);
1094		return RDTnone;
1095		}
1096	<	long    dataStart = ftell(pfp);         // picture starting point
1096	>	long    dataStart = ftell(pdfp[0]);     // picture starting point
1097		if (dataStart < 0) {
1098		sprintf(errmsg, "cannot seek on '%s'", pfname);
1099		error(SYSTEM, errmsg);
1100	<	fclose(pfp);
1100	>	fclose(pdfp[0]);
1101	>	if (pdfp[1]) fclose(pdfp[1]);
1102		return RDTnone;
1103		}
1104		long    doneScans = 0;
1105		if (bytesPer) {                         // fixed-width records?
1106	<	fseek(pfp, 0, SEEK_END);
1107	<	long    dataEnd = ftell(pfp);
1106	>	fseek(pdfp[0], 0, SEEK_END);
1107	>	long    dataEnd = ftell(pdfp[0]);
1108		doneScans = (dataEnd - dataStart)/(bytesPer*GetWidth());
1109		if (dataEnd-dataStart > bytesPer*GetWidth()*doneScans)
1110	<	fseek(pfp, dataStart + bytesPer*GetWidth()*doneScans, SEEK_SET);
1110	>	fseek(pdfp[0], dataStart + bytesPer*GetWidth()*doneScans, SEEK_SET);
1111		} else {                                // else get compressed scanlines
1112		COLR *  scan = (COLR *)tempbuffer(sizeof(COLR)*GetWidth());
1113	<	while (freadcolrs(scan, GetWidth(), pfp) >= 0)
1113	>	while (freadcolrs(scan, GetWidth(), pdfp[0]) >= 0)
1114		++doneScans;
1115	<	if (!feof(pfp)) {
1115	>	if (!feof(pdfp[0])) {
1116		sprintf(errmsg, "error reading compressed scanline from '%s'", pfname);
1117		error(USER, errmsg);
1118	<	fclose(pfp);
1118	>	fclose(pdfp[0]);
1119	>	if (pdfp[1]) fclose(pdfp[1]);
1120		return RDTnone;
1121		}
1122		}
1123		if (doneScans >= GetHeight()) {         // nothing left to do?
1124		sprintf(errmsg, "output file '%s' is already complete", pfname);
1125		error(WARNING, errmsg);
1126	<	fclose(pfp);
1126	>	fclose(pdfp[0]);
1127	>	if (pdfp[1]) fclose(pdfp[1]);
1128		return dt;
1129		}
1130		if (!doneScans) {
1131		sprintf(errmsg, "restarting empty frame '%s'", pfname);
1132		error(WARNING, errmsg);
1133		}
1134	<	if (dfname) {                           // append depth file, too?
1135	<	if (dfname[0] == '!') {
1136	<	error(USER, "depth data cannot be reloaded from command");
1137	<	fclose(pfp);
1134	>	long    toSkip = 0;
1135	>	switch (RDTdepthT(dt)) {                // append depth file, too?
1136	>	case RDTdfloat:
1137	>	toSkip = sizeof(float)*GetWidth()*doneScans;
1138	>	break;
1139	>	case RDTdshort:
1140	>	if (!fgetsresolu(&res, pdfp[1]) || (res.rt != PIXSTANDARD) |
1141	>	(res.xr != GetWidth()) | (res.yr != GetHeight())) {
1142	>	sprintf(errmsg, "missing/bad resolution for '%s'", dfname);
1143	>	error(USER, errmsg);
1144	>	fclose(pdfp[0]); fclose(pdfp[0]);
1145		return RDTnone;
1146		}
1147	<	dfp = fopen(dfname, "a");
1148	<	if (!dfp) {
1149	<	sprintf(errmsg, "cannot reopen depth file '%s'", dfname);
1150	<	error(SYSTEM, errmsg);
1151	<	fclose(pfp);
1152	<	return RDTnone;
1153	<	}
1154	<	SET_FILE_BINARY(dfp);
1155	<	const long      dflen = ftell(dfp);
997	<	if (dflen != sizeof(float)*GetWidth()*doneScans) {
998	<	fclose(dfp);
999	<	dfp = fopen(dfname, "r+");
1000	<	if (!dfp) return RDTnone;       // WTH?
1001	<	SET_FILE_BINARY(dfp);
1002	<	}
1003	<	if (dflen < sizeof(float)*GetWidth()*doneScans) {
1004	<	HeaderInfo      dinfo;
1005	<	if (getheader(dfp, head_check, &dinfo) < 0)
1006	<	sprintf(errmsg, "bad header in encoded depth file '%s'",
1007	<	dfname);
1008	<	else if (strcmp(dinfo.fmt, DEPTH16FMT))
1009	<	sprintf(errmsg, "wrong format (%s) for depth file '%s'",
1010	<	dinfo.fmt, dfname);
1011	<	else if (!SetReferenceDepth(dinfo.depth_unit))
1012	<	sprintf(errmsg, "bad/missing reference depth (%s) in '%s'",
1013	<	dinfo.depth_unit, dfname);
1014	<	else if (!fscnresolu(hvdim, hvdim+1, dfp) ||
1015	<	(hvdim[0] != GetWidth()) | (hvdim[1] != GetHeight()))
1016	<	sprintf(errmsg, "bad/mismatched resolution in '%s'",
1017	<	dfname);
1018	<	else
1019	<	errmsg[0] = '\0';
1020	<
1021	<	if (errmsg[0]) {
1022	<	error(USER, errmsg);
1023	<	fclose(dfp);
1024	<	fclose(pfp);
1025	<	return RDTnone;
1026	<	}
1027	<	const long      dStart = ftell(dfp);
1028	<	if (dflen-dStart < 2*GetWidth()*doneScans) {
1029	<	sprintf(errmsg, "missing %ld depths in '%s'",
1030	<	(long)GetWidth()*doneScans - (dflen-dStart)/2,
1031	<	dfname);
1032	<	error(WARNING, errmsg);
1033	<	}
1034	<	fseek(dfp, dStart + 2*GetWidth()*doneScans, SEEK_SET);
1035	<	dt = RDTnewDT(dt, RDTdshort);
1036	<	} else {
1037	<	if (dflen > sizeof(float)*GetWidth()*doneScans)
1038	<	fseek(dfp, sizeof(float)*GetWidth()*doneScans, SEEK_SET);
1039	<	dt = RDTnewDT(dt, RDTdfloat);
1040	<	}
1147	>	toSkip = 2L*GetWidth()*doneScans;
1148	>	break;
1149	>	default:;
1150	>	}                                       // fseek() needed for output
1151	>	if (pdfp[1] && fseek(pdfp[1], toSkip, SEEK_CUR) < 0) {
1152	>	sprintf(errmsg, "cannot seek on depth file '%s'", dfname);
1153	>	error(SYSTEM, errmsg);
1154	>	fclose(pdfp[0]); fclose(pdfp[1]);
1155	>	return RDTnone;
1156		}
1157		int     bheight = (psample > 1) ? int(2*psample+.99) : 4;
1158		if (bheight > GetHeight()-doneScans)
#	Line 1046 | Line 1161 | RpictSimulManager::ResumeFrame(const char *pfname, con
1161		vstep += !vstep;
1162
1163		NewBar(bheight);                        // render remainder if we can
1164	<	if (!RenderBelow(GetHeight()-doneScans, vstep, pfp, dt, dfp)) {
1165	<	fclose(pfp);
1166	<	if (dfp) fclose(dfp);
1164	>	if (!RenderBelow(GetHeight()-doneScans, vstep, pdfp[0], dt, pdfp[1])) {
1165	>	fclose(pdfp[0]);
1166	>	if (pdfp[1]) fclose(pdfp[1]);
1167		Cleanup();
1168		return RDTnone;
1169		}
1170		NewBar();                               // close up and return success
1171	<	fclose(pfp);
1172	<	if (dfp) fclose(dfp);
1171	>	fclose(pdfp[0]);
1172	>	if (pdfp[1]) fclose(pdfp[1]);
1173		return dt;
1174		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)