66 |
|
static void set_io(void); |
67 |
|
static void pixtoval(void); |
68 |
|
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); |
69 |
|
|
70 |
|
|
71 |
|
static double |
381 |
|
} else if (original && isexpos(line)) { |
382 |
|
d = 1.0/exposval(line); |
383 |
|
scalecolor(exposure, d); |
387 |
– |
fprintf(stderr, "scaled exposure by %f, now at %f\n", d, bright(exposure)); |
384 |
|
doexposure++; |
385 |
|
} else if (original && iscolcor(line)) { |
386 |
|
colcorval(ctmp, line); |
521 |
|
} |
522 |
|
|
523 |
|
|
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 |
– |
|
524 |
|
static int |
525 |
|
getcascii( /* get an ascii color value from stream(s) */ |
526 |
|
COLOR col |
582 |
|
return(-1); |
583 |
|
} |
584 |
|
if (swapbytes) |
585 |
< |
swap32((uint32 *)vf, 3); |
585 |
> |
swap32((char *)vf, 3); |
586 |
|
setcolor(col, vf[rord[RED]], vf[rord[GRN]], vf[rord[BLU]]); |
587 |
|
return(0); |
588 |
|
} |
649 |
|
return(-1); |
650 |
|
} |
651 |
|
if (swapbytes) |
652 |
< |
swap16(vw, 3); |
652 |
> |
swap16((char *)vw, 3); |
653 |
|
setcolor(col, (vw[rord[RED]]+.5)/65536., |
654 |
|
(vw[rord[GRN]]+.5)/65536., (vw[rord[BLU]]+.5)/65536.); |
655 |
|
return(0); |
696 |
|
if (fread((char *)&vf, sizeof(float), 1, fin) != 1) |
697 |
|
return(-1); |
698 |
|
if (swapbytes) |
699 |
< |
swap32((uint32 *)&vf, 1); |
699 |
> |
swap32((char *)&vf, 1); |
700 |
|
setcolor(col, vf, vf, vf); |
701 |
|
return(0); |
702 |
|
} |
745 |
|
if (fread((char *)&vw, sizeof(uint16), 1, fin) != 1) |
746 |
|
return(-1); |
747 |
|
if (swapbytes) |
748 |
< |
swap16(&vw, 1); |
748 |
> |
swap16((char *)&vw, 1); |
749 |
|
d = (vw+.5)/65536.; |
750 |
|
setcolor(col, d, d, d); |
751 |
|
return(0); |
777 |
|
vf[1] = colval(col,ord[1]); |
778 |
|
vf[2] = colval(col,ord[2]); |
779 |
|
if (swapbytes) |
780 |
< |
swap32((uint32 *)vf, 3); |
780 |
> |
swap32((char *)vf, 3); |
781 |
|
fwrite((char *)vf, sizeof(float), 3, stdout); |
782 |
|
|
783 |
|
return(ferror(stdout) ? -1 : 0); |
851 |
|
i = colval(col,ord[2])*65536.; |
852 |
|
vw[2] = min(i,65535); |
853 |
|
if (swapbytes) |
854 |
< |
swap16(vw, 3); |
854 |
> |
swap16((char *)vw, 3); |
855 |
|
fwrite((char *)vw, sizeof(uint16), 3, stdout); |
856 |
|
|
857 |
|
return(ferror(stdout) ? -1 : 0); |
878 |
|
|
879 |
|
vf = (*mybright)(col); |
880 |
|
if (swapbytes) |
881 |
< |
swap32((uint32 *)&vf, 1); |
881 |
> |
swap32((char *)&vf, 1); |
882 |
|
fwrite((char *)&vf, sizeof(float), 1, stdout); |
883 |
|
|
884 |
|
return(ferror(stdout) ? -1 : 0); |
939 |
|
i = (*mybright)(col)*65536.; |
940 |
|
vw = min(i,65535); |
941 |
|
if (swapbytes) |
942 |
< |
swap16(&vw, 1); |
942 |
> |
swap16((char *)&vw, 1); |
943 |
|
fwrite((char *)&vw, sizeof(uint16), 1, stdout); |
944 |
|
|
945 |
|
return(ferror(stdout) ? -1 : 0); |
966 |
|
|
967 |
|
vf = colval(col,putprim); |
968 |
|
if (swapbytes) |
969 |
< |
swap32((uint32 *)&vf, 1); |
969 |
> |
swap32((char *)&vf, 1); |
970 |
|
fwrite((char *)&vf, sizeof(float), 1, stdout); |
971 |
|
|
972 |
|
return(ferror(stdout) ? -1 : 0); |
1027 |
|
i = colval(col,putprim)*65536.; |
1028 |
|
vw = min(i,65535); |
1029 |
|
if (swapbytes) |
1030 |
< |
swap16(&vw, 1); |
1030 |
> |
swap16((char *)&vw, 1); |
1031 |
|
fwrite((char *)&vw, sizeof(uint16), 1, stdout); |
1032 |
|
|
1033 |
|
return(ferror(stdout) ? -1 : 0); |