ViewVC Help

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

root/Development/ray/src/px/pvalue.c

Comparing ray/src/px/pvalue.c (file contents):
Revision 2.27 by greg, Fri Oct 1 07:45:30 2004 UTC vs.
Revision 2.33 by greg, Thu Aug 18 00:52:48 2016 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 384 | Line 403 | checkhead(                             /* deal with line from header */
403		} else if (original && isexpos(line)) {
404		d = 1.0/exposval(line);
405		scalecolor(exposure, d);
387	–	fprintf(stderr, "scaled exposure by %f, now at %f\n", d, bright(exposure));
406		doexposure++;
407		} else if (original && iscolcor(line)) {
408		colcorval(ctmp, line);
#	Line 525 | Line 543 | int  code;
543		}
544
545
528	–	static void
529	–	swap16(         /* swap n 16-bit words */
530	–	register uint16  *wp,
531	–	int  n
532	–	)
533	–	{
534	–	while (n-- > 0) {
535	–	*wp = *wp << 8 | ((*wp >> 8) & 0xff);
536	–	wp++;
537	–	}
538	–	}
539	–
540	–
541	–	static void
542	–	swap32(         /* swap n 32-bit words */
543	–	register uint32  *wp,
544	–	int  n
545	–	)
546	–	{
547	–	while (n-- > 0) {
548	–	*wp = *wp << 24 | ((*wp >> 24) & 0xff) |
549	–	(*wp & 0xff00) << 8 | (*wp & 0xff0000) >> 8;
550	–	wp++;
551	–	}
552	–	}
553	–
554	–
555	–	static void
556	–	swap64(         /* swap n 64-bit words */
557	–	register char  *wp,
558	–	int  n
559	–	)
560	–	{
561	–	register int    t;
562	–
563	–	while (n-- > 0) {
564	–	t = wp[0]; wp[0] = wp[7]; wp[7] = t;
565	–	t = wp[1]; wp[1] = wp[6]; wp[6] = t;
566	–	t = wp[2]; wp[2] = wp[5]; wp[5] = t;
567	–	t = wp[3]; wp[3] = wp[4]; wp[4] = t;
568	–	wp += 8;
569	–	}
570	–	}
571	–
572	–
546		static int
547		getcascii(              /* get an ascii color value from stream(s) */
548		COLOR  col
#	Line 599 | 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 622 | 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 664 | 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 689 | 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 726 | 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 742 | 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 772 | 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 791 | 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 826 | 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 845 | 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 871 | 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 879 | 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 900 | 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 927 | 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 944 | 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 967 | 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 988 | 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 1015 | 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 1032 | 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 1055 | 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 1076 | 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 1181 | 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 (old)
>	Changed lines (new)