ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/RpictSimulManager.cpp
(Generate patch)

Comparing ray/src/rt/RpictSimulManager.cpp (file contents):
Revision 2.4 by greg, Mon Aug 19 16:41:40 2024 UTC vs.
Revision 2.6 by greg, Wed Aug 21 23:52:24 2024 UTC

# Line 645 | Line 645 | RpictSimulManager::RenderBelow(int ytop, const int vst
645          return true;
646   }
647  
648 < /*
649 < * Render and write a frame to the named file
650 < * Include any header lines set prior to call
651 < * Picture file must not already exist
652 < * Write pixels to stdout if !pfname
653 < * Write depth to a command if dfname[0]=='!'
654 < */
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;
659 <        FILE *  pfp = NULL;
660 <        FILE *  dfp = NULL;
661 <
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 668 | 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 684 | 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 784 | 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 811 | 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 853 | Line 883 | head_check(char *s, void *p)
883          return 0;
884   }
885  
886 < // Resume partially finished rendering
857 < // 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] == '!')
862 <                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) {
876 <                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          }
879 –        if (!fgetsresolu(&res, pfp) || res.rt != PIXSTANDARD) {
880 –                sprintf(errmsg, "missing/bad resolution for '%s'", pfname);
881 –                error(USER, errmsg);
882 –                fclose(pfp);
883 –                return RDTnone;
884 –        }
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 912 | 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);
921 –                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 950 | Line 978 | RpictSimulManager::ResumeFrame(const char *pfname, con
978                          prims = NULL;
979                          dt = RDTnewCT(dt, RDTscolor);
980                  }
953 –                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 (read(fileno(pdfp[1]), buf, len+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 +        lseek(fileno(pdfp[1]), 0, SEEK_SET);
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);
1019 <                if (dflen != sizeof(float)*GetWidth()*doneScans) {
1020 <                        fclose(dfp);
1021 <                        dfp = fopen(dfname, "r+");
1022 <                        if (!dfp) return RDTnone;       // WTH?
1023 <                        SET_FILE_BINARY(dfp);
1024 <                }
1025 <                if (dflen < sizeof(float)*GetWidth()*doneScans) {
1026 <                        HeaderInfo      dinfo;
1027 <                        if (getheader(dfp, head_check, &dinfo) < 0)
1028 <                                sprintf(errmsg, "bad header in encoded depth file '%s'",
1029 <                                                dfname);
1030 <                        else if (strcmp(dinfo.fmt, DEPTH16FMT))
1031 <                                sprintf(errmsg, "wrong format (%s) for depth file '%s'",
1032 <                                                dinfo.fmt, dfname);
1033 <                        else if (!SetReferenceDepth(dinfo.depth_unit))
1034 <                                sprintf(errmsg, "bad/missing reference depth (%s) in '%s'",
1035 <                                                dinfo.depth_unit, dfname);
1036 <                        else if (!fscnresolu(hvdim, hvdim+1, dfp) ||
1037 <                                        (hvdim[0] != GetWidth()) | (hvdim[1] != GetHeight()))
1038 <                                sprintf(errmsg, "bad/mismatched resolution in '%s'",
1039 <                                                dfname);
1040 <                        else
1041 <                                errmsg[0] = '\0';
1042 <
1043 <                        if (errmsg[0]) {
1044 <                                error(USER, errmsg);
1045 <                                fclose(dfp);
1046 <                                fclose(pfp);
1047 <                                return RDTnone;
1048 <                        }
1049 <                        const long      dStart = ftell(dfp);
1050 <                        if (dflen-dStart < 2*GetWidth()*doneScans) {
1051 <                                sprintf(errmsg, "missing %ld depths in '%s'",
1052 <                                        (long)GetWidth()*doneScans - (dflen-dStart)/2,
1053 <                                        dfname);
1054 <                                error(WARNING, errmsg);
1055 <                        }
1056 <                        fseek(dfp, dStart + 2*GetWidth()*doneScans, SEEK_SET);
1057 <                        dt = RDTnewDT(dt, RDTdshort);
1058 <                } else {
1059 <                        if (dflen > sizeof(float)*GetWidth()*doneScans)
1060 <                                fseek(dfp, sizeof(float)*GetWidth()*doneScans, SEEK_SET);
1061 <                        dt = RDTnewDT(dt, RDTdfloat);
1062 <                }
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 1068 | 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
> Changed lines