ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
(Generate patch)

Comparing ray/src/px/pvalue.c (file contents):
Revision 2.28 by greg, Fri Oct 1 07:46:26 2004 UTC vs.
Revision 2.34 by greg, Thu Aug 2 18:33:46 2018 UTC

# Line 36 | Line 36 | int  original = 0;             /* convert to original values? */
36   int  wrongformat = 0;           /* wrong input format? */
37   double  gamcor = 1.0;           /* gamma correction */
38  
39 + RGBPRIMP  outprims = stdprims;  /* output primaries for reverse conversion */
40 + RGBPRIMS  myprims;
41 +
42   int  ord[3] = {RED, GRN, BLU};  /* RGB ordering */
43   int  rord[4];                   /* reverse ordering */
44  
# Line 66 | Line 69 | static putfunc_t putpascii, putpint, putpdouble, putpf
69   static void set_io(void);
70   static void pixtoval(void);
71   static void valtopix(void);
69 – static void swap16(uint16  *wp, int  n);
70 – static void swap32(uint32  *wp, int  n);
71 – static void swap64(char  *wp, int  n);
72  
73  
74   static double
# Line 149 | Line 149 | main(
149                          case 'b':               /* brightness values */
150                                  putprim = argv[i][0] == '-' ? BRIGHT : ALL;
151                                  break;
152 <                        case 'p':               /* put primary */
152 >                        case 'p':               /* primary controls */
153                                  switch (argv[i][2]) {
154 +                                /* these two options affect -r conversion */
155 +                                case '\0':
156 +                                        myprims[RED][CIEX] = atof(argv[++i]);
157 +                                        myprims[RED][CIEY] = atof(argv[++i]);
158 +                                        myprims[GRN][CIEX] = atof(argv[++i]);
159 +                                        myprims[GRN][CIEY] = atof(argv[++i]);
160 +                                        myprims[BLU][CIEX] = atof(argv[++i]);
161 +                                        myprims[BLU][CIEY] = atof(argv[++i]);
162 +                                        myprims[WHT][CIEX] = atof(argv[++i]);
163 +                                        myprims[WHT][CIEY] = atof(argv[++i]);
164 +                                        outprims = myprims;
165 +                                        break;
166 +                                case 'x': case 'X': outprims = NULL; break;
167 +                                /* the following options affect +r only */
168                                  case 'r': case 'R': putprim = RED; break;
169                                  case 'g': case 'G': putprim = GRN; break;
170                                  case 'b': case 'B': putprim = BLU; break;
# Line 282 | Line 296 | unkopt:
296          }
297  
298          if (reverse) {
299 < #ifdef _WIN32
299 > #if defined(_WIN32) || defined(_WIN64)
300                  SET_FILE_BINARY(stdout);
301                  if (format != 'a' && format != 'i')
302                          SET_FILE_BINARY(fin);
# Line 325 | Line 339 | unkopt:
339                  printargs(i, argv, stdout);
340                  if (expval < .99 || expval > 1.01)
341                          fputexpos(expval, stdout);
342 <                fputformat(COLRFMT, stdout);
342 >                if (outprims != NULL) {
343 >                        if (outprims != stdprims)
344 >                                fputprims(outprims, stdout);
345 >                        fputformat(COLRFMT, stdout);
346 >                } else                          /* XYZ data */
347 >                        fputformat(CIEFMT, stdout);
348                  putchar('\n');
349                  fputsresolu(&picres, stdout);   /* always put resolution */
350                  valtopix();
351          } else {
352 < #ifdef _WIN32
352 > #if defined(_WIN32) || defined(_WIN64)
353                  SET_FILE_BINARY(fin);
354                  if (format != 'a' && format != 'i')
355                          SET_FILE_BINARY(stdout);
# Line 370 | Line 389 | checkhead(                             /* deal with line from header */
389          void    *p
390   )
391   {
392 <        char    fmt[32];
392 >        char    fmt[MAXFMTLEN];
393          double  d;
394          COLOR   ctmp;
395  
# Line 524 | Line 543 | int  code;
543   }
544  
545  
527 – static void
528 – swap16(         /* swap n 16-bit words */
529 –        register uint16  *wp,
530 –        int  n
531 – )
532 – {
533 –        while (n-- > 0) {
534 –                *wp = *wp << 8 | ((*wp >> 8) & 0xff);
535 –                wp++;
536 –        }
537 – }
538 –
539 –
540 – static void
541 – swap32(         /* swap n 32-bit words */
542 –        register uint32  *wp,
543 –        int  n
544 – )
545 – {
546 –        while (n-- > 0) {
547 –                *wp = *wp << 24 | ((*wp >> 24) & 0xff) |
548 –                        (*wp & 0xff00) << 8 | (*wp & 0xff0000) >> 8;
549 –                wp++;
550 –        }
551 – }
552 –
553 –
554 – static void
555 – swap64(         /* swap n 64-bit words */
556 –        register char  *wp,
557 –        int  n
558 – )
559 – {
560 –        register int    t;
561 –
562 –        while (n-- > 0) {
563 –                t = wp[0]; wp[0] = wp[7]; wp[7] = t;
564 –                t = wp[1]; wp[1] = wp[6]; wp[6] = t;
565 –                t = wp[2]; wp[2] = wp[5]; wp[5] = t;
566 –                t = wp[3]; wp[3] = wp[4]; wp[4] = t;
567 –                wp += 8;
568 –        }
569 – }
570 –
571 –
546   static int
547   getcascii(              /* get an ascii color value from stream(s) */
548          COLOR  col
# Line 598 | Line 572 | getcdouble(            /* get a double color value from stream(s
572          double  vd[3];
573  
574          if (fin2 == NULL) {
575 <                if (fread((char *)vd, sizeof(double), 3, fin) != 3)
575 >                if (getbinary(vd, sizeof(double), 3, fin) != 3)
576                          return(-1);
577          } else {
578 <                if (fread((char *)vd, sizeof(double), 1, fin) != 1 ||
579 <                        fread((char *)(vd+1), sizeof(double), 1, fin2) != 1 ||
580 <                        fread((char *)(vd+2), sizeof(double), 1, fin3) != 1)
578 >                if (getbinary(vd, sizeof(double), 1, fin) != 1 ||
579 >                        getbinary(vd+1, sizeof(double), 1, fin2) != 1 ||
580 >                        getbinary(vd+2, sizeof(double), 1, fin3) != 1)
581                          return(-1);
582          }
583          if (swapbytes)
# Line 621 | Line 595 | getcfloat(             /* get a float color value from stream(s)
595          float  vf[3];
596  
597          if (fin2 == NULL) {
598 <                if (fread((char *)vf, sizeof(float), 3, fin) != 3)
598 >                if (getbinary(vf, sizeof(float), 3, fin) != 3)
599                          return(-1);
600          } else {
601 <                if (fread((char *)vf, sizeof(float), 1, fin) != 1 ||
602 <                        fread((char *)(vf+1), sizeof(float), 1, fin2) != 1 ||
603 <                        fread((char *)(vf+2), sizeof(float), 1, fin3) != 1)
601 >                if (getbinary(vf, sizeof(float), 1, fin) != 1 ||
602 >                        getbinary(vf+1, sizeof(float), 1, fin2) != 1 ||
603 >                        getbinary(vf+2, sizeof(float), 1, fin3) != 1)
604                          return(-1);
605          }
606          if (swapbytes)
607 <                swap32((uint32 *)vf, 3);
607 >                swap32((char *)vf, 3);
608          setcolor(col, vf[rord[RED]], vf[rord[GRN]], vf[rord[BLU]]);
609          return(0);
610   }
# Line 663 | Line 637 | getcbyte(              /* get a byte color value from stream(s) */
637          COLOR  col
638   )
639   {
640 <        BYTE  vb[3];
640 >        uby8  vb[3];
641  
642          if (fin2 == NULL) {
643 <                if (fread((char *)vb, sizeof(BYTE), 3, fin) != 3)
643 >                if (getbinary(vb, sizeof(uby8), 3, fin) != 3)
644                          return(-1);
645          } else {
646 <                if (fread((char *)vb, sizeof(BYTE), 1, fin) != 1 ||
647 <                        fread((char *)(vb+1), sizeof(BYTE), 1, fin2) != 1 ||
648 <                        fread((char *)(vb+2), sizeof(BYTE), 1, fin3) != 1)
646 >                if (getbinary(vb, sizeof(uby8), 1, fin) != 1 ||
647 >                        getbinary(vb+1, sizeof(uby8), 1, fin2) != 1 ||
648 >                        getbinary(vb+2, sizeof(uby8), 1, fin3) != 1)
649                          return(-1);
650          }
651          setcolor(col, (vb[rord[RED]]+.5)/256.,
# Line 688 | Line 662 | getcword(              /* get a 16-bit color value from stream(s)
662          uint16  vw[3];
663  
664          if (fin2 == NULL) {
665 <                if (fread((char *)vw, sizeof(uint16), 3, fin) != 3)
665 >                if (getbinary(vw, sizeof(uint16), 3, fin) != 3)
666                          return(-1);
667          } else {
668 <                if (fread((char *)vw, sizeof(uint16), 1, fin) != 1 ||
669 <                        fread((char *)(vw+1), sizeof(uint16), 1, fin2) != 1 ||
670 <                        fread((char *)(vw+2), sizeof(uint16), 1, fin3) != 1)
668 >                if (getbinary(vw, sizeof(uint16), 1, fin) != 1 ||
669 >                        getbinary(vw+1, sizeof(uint16), 1, fin2) != 1 ||
670 >                        getbinary(vw+2, sizeof(uint16), 1, fin3) != 1)
671                          return(-1);
672          }
673          if (swapbytes)
674 <                swap16(vw, 3);
674 >                swap16((char *)vw, 3);
675          setcolor(col, (vw[rord[RED]]+.5)/65536.,
676                          (vw[rord[GRN]]+.5)/65536., (vw[rord[BLU]]+.5)/65536.);
677          return(0);
# Line 725 | Line 699 | getbdouble(            /* get a double brightness value from fin
699   {
700          double  vd;
701  
702 <        if (fread((char *)&vd, sizeof(double), 1, fin) != 1)
702 >        if (getbinary(&vd, sizeof(double), 1, fin) != 1)
703                  return(-1);
704          if (swapbytes)
705                  swap64((char *)&vd, 1);
# Line 741 | Line 715 | getbfloat(             /* get a float brightness value from fin *
715   {
716          float  vf;
717  
718 <        if (fread((char *)&vf, sizeof(float), 1, fin) != 1)
718 >        if (getbinary(&vf, sizeof(float), 1, fin) != 1)
719                  return(-1);
720          if (swapbytes)
721 <                swap32((uint32 *)&vf, 1);
721 >                swap32((char *)&vf, 1);
722          setcolor(col, vf, vf, vf);
723          return(0);
724   }
# Line 771 | Line 745 | getbbyte(              /* get a byte brightness value from fin */
745          COLOR  col
746   )
747   {
748 <        BYTE  vb;
748 >        uby8  vb;
749          double  d;
750  
751 <        if (fread((char *)&vb, sizeof(BYTE), 1, fin) != 1)
751 >        if (getbinary(&vb, sizeof(uby8), 1, fin) != 1)
752                  return(-1);
753          d = (vb+.5)/256.;
754          setcolor(col, d, d, d);
# Line 790 | Line 764 | getbword(              /* get a 16-bit brightness value from fin *
764          uint16  vw;
765          double  d;
766  
767 <        if (fread((char *)&vw, sizeof(uint16), 1, fin) != 1)
767 >        if (getbinary(&vw, sizeof(uint16), 1, fin) != 1)
768                  return(-1);
769          if (swapbytes)
770 <                swap16(&vw, 1);
770 >                swap16((char *)&vw, 1);
771          d = (vw+.5)/65536.;
772          setcolor(col, d, d, d);
773          return(0);
# Line 825 | Line 799 | putcfloat(                     /* put a float color to stdout */
799          vf[1] = colval(col,ord[1]);
800          vf[2] = colval(col,ord[2]);
801          if (swapbytes)
802 <                swap32((uint32 *)vf, 3);
803 <        fwrite((char *)vf, sizeof(float), 3, stdout);
802 >                swap32((char *)vf, 3);
803 >        putbinary(vf, sizeof(float), 3, stdout);
804  
805          return(ferror(stdout) ? -1 : 0);
806   }
# Line 844 | Line 818 | putcdouble(                    /* put a double color to stdout */
818          vd[2] = colval(col,ord[2]);
819          if (swapbytes)
820                  swap64((char *)vd, 3);
821 <        fwrite((char *)vd, sizeof(double), 3, stdout);
821 >        putbinary(vd, sizeof(double), 3, stdout);
822  
823          return(ferror(stdout) ? -1 : 0);
824   }
# Line 870 | Line 844 | putcbyte(                      /* put a byte color to stdout */
844   )
845   {
846          long  i;
847 <        BYTE  vb[3];
847 >        uby8  vb[3];
848  
849          i = colval(col,ord[0])*256.;
850          vb[0] = min(i,255);
# Line 878 | Line 852 | putcbyte(                      /* put a byte color to stdout */
852          vb[1] = min(i,255);
853          i = colval(col,ord[2])*256.;
854          vb[2] = min(i,255);
855 <        fwrite((char *)vb, sizeof(BYTE), 3, stdout);
855 >        putbinary(vb, sizeof(uby8), 3, stdout);
856  
857          return(ferror(stdout) ? -1 : 0);
858   }
# Line 899 | Line 873 | putcword(                      /* put a 16-bit color to stdout */
873          i = colval(col,ord[2])*65536.;
874          vw[2] = min(i,65535);
875          if (swapbytes)
876 <                swap16(vw, 3);
877 <        fwrite((char *)vw, sizeof(uint16), 3, stdout);
876 >                swap16((char *)vw, 3);
877 >        putbinary(vw, sizeof(uint16), 3, stdout);
878  
879          return(ferror(stdout) ? -1 : 0);
880   }
# Line 926 | Line 900 | putbfloat(                     /* put a float brightness to stdout */
900  
901          vf = (*mybright)(col);
902          if (swapbytes)
903 <                swap32((uint32 *)&vf, 1);
904 <        fwrite((char *)&vf, sizeof(float), 1, stdout);
903 >                swap32((char *)&vf, 1);
904 >        putbinary(&vf, sizeof(float), 1, stdout);
905  
906          return(ferror(stdout) ? -1 : 0);
907   }
# Line 943 | Line 917 | putbdouble(                    /* put a double brightness to stdout */
917          vd = (*mybright)(col);
918          if (swapbytes)
919                  swap64((char *)&vd, 1);
920 <        fwrite((char *)&vd, sizeof(double), 1, stdout);
920 >        putbinary(&vd, sizeof(double), 1, stdout);
921  
922          return(ferror(stdout) ? -1 : 0);
923   }
# Line 966 | Line 940 | putbbyte(                      /* put a byte brightness to stdout */
940   )
941   {
942          register int  i;
943 <        BYTE  vb;
943 >        uby8  vb;
944  
945          i = (*mybright)(col)*256.;
946          vb = min(i,255);
947 <        fwrite((char *)&vb, sizeof(BYTE), 1, stdout);
947 >        putbinary(&vb, sizeof(uby8), 1, stdout);
948  
949          return(ferror(stdout) ? -1 : 0);
950   }
# Line 987 | Line 961 | putbword(                      /* put a 16-bit brightness to stdout */
961          i = (*mybright)(col)*65536.;
962          vw = min(i,65535);
963          if (swapbytes)
964 <                swap16(&vw, 1);
965 <        fwrite((char *)&vw, sizeof(uint16), 1, stdout);
964 >                swap16((char *)&vw, 1);
965 >        putbinary(&vw, sizeof(uint16), 1, stdout);
966  
967          return(ferror(stdout) ? -1 : 0);
968   }
# Line 1014 | Line 988 | putpfloat(                     /* put a float primary to stdout */
988  
989          vf = colval(col,putprim);
990          if (swapbytes)
991 <                swap32((uint32 *)&vf, 1);
992 <        fwrite((char *)&vf, sizeof(float), 1, stdout);
991 >                swap32((char *)&vf, 1);
992 >        putbinary(&vf, sizeof(float), 1, stdout);
993  
994          return(ferror(stdout) ? -1 : 0);
995   }
# Line 1031 | Line 1005 | putpdouble(                    /* put a double primary to stdout */
1005          vd = colval(col,putprim);
1006          if (swapbytes)
1007                  swap64((char *)&vd, 1);
1008 <        fwrite((char *)&vd, sizeof(double), 1, stdout);
1008 >        putbinary(&vd, sizeof(double), 1, stdout);
1009  
1010          return(ferror(stdout) ? -1 : 0);
1011   }
# Line 1054 | Line 1028 | putpbyte(                      /* put a byte primary to stdout */
1028   )
1029   {
1030          long  i;
1031 <        BYTE  vb;
1031 >        uby8  vb;
1032  
1033          i = colval(col,putprim)*256.;
1034          vb = min(i,255);
1035 <        fwrite((char *)&vb, sizeof(BYTE), 1, stdout);
1035 >        putbinary(&vb, sizeof(uby8), 1, stdout);
1036  
1037          return(ferror(stdout) ? -1 : 0);
1038   }
# Line 1075 | Line 1049 | putpword(                      /* put a 16-bit primary to stdout */
1049          i = colval(col,putprim)*65536.;
1050          vw = min(i,65535);
1051          if (swapbytes)
1052 <                swap16(&vw, 1);
1053 <        fwrite((char *)&vw, sizeof(uint16), 1, stdout);
1052 >                swap16((char *)&vw, 1);
1053 >        putbinary(&vw, sizeof(uint16), 1, stdout);
1054  
1055          return(ferror(stdout) ? -1 : 0);
1056   }
# Line 1180 | Line 1154 | set_io(void)                   /* set put and get functions */
1154                                  if (fin2 == NULL)
1155                                          goto namerr;
1156                                  if (fseek(fin2,
1157 <                                (long)sizeof(BYTE)*picres.xr*picres.yr, 1))
1157 >                                (long)sizeof(uby8)*picres.xr*picres.yr, 1))
1158                                          goto seekerr;
1159                                  if (fseek(fin3,
1160 <                                (long)sizeof(BYTE)*2*picres.xr*picres.yr, 1))
1160 >                                (long)sizeof(uby8)*2*picres.xr*picres.yr, 1))
1161                                          goto seekerr;
1162                          }
1163                  }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines