![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Qsnap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / qsnap|
Return to Qsnap.c CVS log | Up to [Research Unix] / researchv10dc / cmd / qsnap |
1.1 root 1: #include <stdio.h>
2: #include <sys/types.h>
3: #include <sys/stat.h>
4: #include "defines.h"
5: #include "piclib.h"
6:
7: #define XTIMES Times
8: #define YTIMES Times
9: #define Min(a,b) ((a)>(b)?(b):(a))
10: #define Max(a,b) ((a)<(b)?(b):(a))
11:
12: int Xmax, Ymax, Xmin, Ymin;
13: int Dither=0, Times=3, Bright=0;
14: int Film = 0;
15: int Filter = GREEN;
16: int Reso = 0;
17: int redonly = 0;
18: int settimes= 0;
19: int setbright=0;
20: int xoffset = 0;
21: int yoffset = 0;
22:
23: unsigned char nq[9];
24: char *malloc();
25: unsigned char *rgb;
26: int lsize;
27: int multiple=1; /* number of exposures */
28: int fad=1, dodub=0;
29:
30: Usage(str)
31: char *str;
32: { fprintf(stderr, "qsnap: %s\n", str);
33: fprintf(stderr, "usage: qsnap -bdfmnrxFLRXY [N ...] file\n");
34: fprintf(stderr, "b brightness [0-8], defaults to 0 (2k) or 2 (4k)\n");
35: fprintf(stderr, "d dither image +- N [2-255]\n");
36: fprintf(stderr, "f filmtype [0-2], defaults to 0 (custom,lin,pola)\n");
37: fprintf(stderr, "m enlargement [1-N], defaults to 3(2k) or 6(4k)\n");
38: fprintf(stderr, "n TMAX-100 b&w corrected exposure\n");
39: fprintf(stderr, "r expose red only (for multiple red overlays)\n");
40: fprintf(stderr, "x N exposures (not with -L)\n");
41: fprintf(stderr, "F bwfilter [0-3], defaults to 2 (n,r,g,b)\n");
42: fprintf(stderr, "L raw file, no header, bw, line by line (no m,d,x)\n");
43: fprintf(stderr, "R N set resolution to N [N=2 or N=4]\n");
44: fprintf(stderr, "X add x-offset N (eg 480/m, for 35mm camera)\n");
45: fprintf(stderr, "Y add y-offset N\n");
46: exit(1);
47: }
48:
49: main(argc, argv)
50: char **argv;
51: {
52: int i=1, base=2; /* base of option arguments */
53: int linebyline = 0;
54: char c;
55:
56: if (argc > 1 && argv[1][0] == '-')
57: { base++;
58: while ((c = argv[1][i++]) != '\0')
59: switch (c) {
60: /* TMAX-100 */ case 'n': dodub = 1; break;
61: /* N exps */ case 'x': if (argc >= base)
62: { sscanf(argv[base-1], "%d", &multiple);
63: base++;
64: fad = 0;
65: break;
66: } else
67: Usage("missing argument for `a' flag");
68: /* bright */ case 'b': if (argc >= base)
69: { sscanf(argv[base-1], "%d", &Bright);
70: base++;
71: Bright = Bright%9;
72: setbright = 1;
73: break;
74: } else
75: Usage("missing argument for `b' flag");
76: /* dither */ case 'd': if (argc >= base)
77: { sscanf(argv[base-1], "%d", &Dither);
78: base++;
79: if (Dither < 0) Dither = -Dither;
80: break;
81: } else
82: Usage("missing argument for `d' flag");
83:
84: /* filmtype */ case 'f': if (argc >= base)
85: { sscanf(argv[base-1], "%d", &Film);
86: Film = Film%8;
87: base++;
88: if (Film == 6)
89: Usage("unknown film type");
90: break;
91: } else
92: Usage("missing argument for `f' flag");
93: /* multiply */ case 'm': if (argc >= base)
94: { sscanf(argv[base-1], "%d", &Times);
95: base++;
96: settimes = 1;
97: break;
98: } else
99: Usage("missing argument for `m' flag");
100: /* filter */ case 'F': if (argc >= base)
101: { sscanf(argv[base-1], "%d", &Filter);
102: Filter = Filter%4;
103: base++;
104: break;
105: } else
106: Usage("missing argument for `F' flag");
107: case 'L': if (argc >= base)
108: { sscanf(argv[base-1], "%d", &lsize);
109: linebyline = 1;
110: base++;
111: break;
112: } else
113: Usage("missing argument for `L' flag");
114: case 'R': if (argc >= base)
115: { sscanf(argv[base-1], "%d", &Reso);
116: base++;
117: break;
118: } else
119: Usage("missing argument for `R' flag");
120: case 'X': if (argc >= base)
121: { sscanf(argv[base-1], "%d", &xoffset);
122: base++;
123: break;
124: } else
125: Usage("missing argument for `X' flag");
126: case 'Y': if (argc >= base)
127: { sscanf(argv[base-1], "%d", &yoffset);
128: base++;
129: break;
130: } else
131: Usage("missing argument for `Y' flag");
132: case 'r': redonly = 1; break;
133: default : Usage("unknown option");
134: }
135: }
136: if (dodub == 1 && (setbright || Film))
137: { fprintf(stderr, "warning: -b and -f flags have ");
138: fprintf(stderr, "no effect when combined with -n\n");
139: }
140: if (base != argc) Usage("bad arglist");
141:
142: qreset();
143: getbright(nq);
144: if (Reso == 2 || Reso == 4)
145: setreso(Reso);
146: qpause();
147: Reso = resolution();
148: Xmax = 1024*Reso;
149: Ymax = 768*Reso;
150: Xmin = -512*Reso;
151: Ymin = 384*Reso;
152: if (linebyline && lsize > Xmax)
153: { fprintf(stderr, "image too wide: %d, max is %d\n", lsize, Xmax);
154: exit(1);
155: }
156: if (dodub && nq[2] != 81)
157: { fprintf(stderr, "option -n requires that you first set\n");
158: fprintf(stderr, "\t$ qbright 36 58 81 103 126 148 171 193\n");
159: exit(1);
160: }
161: if (Reso == 4)
162: { if (!settimes) Times = 6;
163: if (!setbright) Bright = 2;
164: }
165:
166: qpause();
167: nocalibs();
168: handshake(1); fflush(stdout);
169: if (dodub)
170: { qpause();
171: customluts(TMAX_100);
172: Bright = 2;
173: } else
174: filmtype(Film);
175: qpause();
176: advance(fad);
177: qpause();
178: if (fad==0)
179: shutter(1);
180: fflush(stdout);
181: Again:
182: qpause();
183: brightness(Bright, Bright, Bright, Bright);
184: printf("brightness %d (%d)\n", Bright, nq[Bright]); fflush(stdout);
185: if (linebyline)
186: znap(argv[base-1]);
187: else
188: snap(argv[base-1]);
189: if (fad==0)
190: shutter(0);
191: exit(0);
192: }
193:
194: znap(name)
195: char *name;
196: {
197: register i;
198: int fd, h, w;
199: unsigned char obuf[8192];
200:
201: w = lsize;
202: h = (lsize>683*Reso)?(683*Reso):lsize;
203: /* the maximum for 35mm; for 4x5 it is 768*Reso */
204:
205: if ((fd = open(name, 0)) < 0)
206: { fprintf(stderr, "cannot open %s\n", name);
207: exit(1);
208: }
209: printf("file: %s\n", name);
210: window(Xmin+xoffset, Ymin-yoffset, w, h);
211: singlepass(Filter);
212: fflush(stdout);
213: for (i = 0; i < h; i++)
214: { read(fd, obuf, w);
215: qwrite(obuf, w);
216: }
217: close(fd);
218: fprintf(stderr, "done\n");
219: }
220:
221: snap(name)
222: char *name;
223: {
224: int fd, h, w;
225: struct pfile image;
226:
227: if((fd = openf(name, &image)) == -1 || !readf(fd, &image))
228: { fprintf(stderr, "bad image %s\n", name);
229: exit(1);
230: }
231: w = image.r.corner.x - image.r.origin.x;
232: if (w*XTIMES > Xmax)
233: { fprintf(stderr, "image too wide: %d, max %d\n", w*XTIMES, Xmax);
234: exit(1);
235: }
236: h = image.r.corner.y - image.r.origin.y;
237: h = Min(Ymax/YTIMES, h);
238: while (multiple-- > 0)
239: { printf("file: %s\n", name);
240: window(Xmin+xoffset, Ymin-yoffset, w*XTIMES, h*YTIMES);
241: fflush(stdout);
242: if (image.nchan == 1)
243: { singlepass(Filter);
244: onechannel(image.pixred, h, w);
245: } else
246: { threepass();
247: fprintf(stderr, "red\n"); onechannel(image.pixred, h, w);
248: if (redonly) goto done;
249: fprintf(stderr, "grn\n"); onechannel(image.pixgrn, h, w);
250: fprintf(stderr, "blu\n"); onechannel(image.pixblu, h, w);
251: }
252: sleep(10);
253: if (multiple > 0)
254: printf("x pass %d\n", multiple);
255: }
256: close(fd);
257: done: fprintf(stderr, "done\n");
258: }
259:
260: onechannel(from, h, w)
261: unsigned char *from;
262: {
263: fflush(stdout);
264: if (Dither)
265: { prerand();
266: onedither(from, h, w);
267: } else
268: straight(from, h, w);
269: }
270:
271: straight(from, h, w)
272: unsigned char *from;
273: {
274: register i, j, k;
275: register unsigned char *p, *q;
276: unsigned char obuf[8192];
277: int chunk = w*XTIMES;
278:
279: for (i = 0, p = from; i < h; i++)
280: { q = obuf;
281: for (j = 0; j < w; j++, p++)
282: for (k = 0; k < XTIMES; k++)
283: *q++ = *p;
284: for (k = 0; k < YTIMES; k++)
285: { qwrite(obuf, chunk);
286: if (chunk > 2048) qwait(200);
287: } }
288: }
289:
290: short Nrand[5000];
291:
292: prerand()
293: { register int i, D1=Dither, D2=Dither/2;
294:
295: for (i = 0; i < 5000; i++)
296: Nrand[i] = (short) (nrand(D1) - D2);
297: }
298:
299: onedither(from, h, w)
300: unsigned char *from;
301: {
302: register int c, m, kk=0;
303: register unsigned char *op, *q;
304: unsigned char *p, obuf[8192];
305: int i, j, k;
306: int chunk = w*XTIMES;
307:
308: for (i = 0, p = from; i < h; i++, p = op)
309: for (k = 0; k < YTIMES; k++)
310: { q = obuf;
311: op = p;
312: j = w;
313: do{
314: m = XTIMES;
315: do{
316: c = *op + Nrand[kk];
317: if (++kk >= 5000) kk = 0;
318: if(c<0)
319: c=0;
320: if(c>255)
321: c=255;
322: *q++ = c;
323: }while(--m);
324: op++;
325: }while(--j);
326: qwrite(obuf, chunk);
327: }
328: }
329:
330: qwait(n)
331: { int i;
332: for (i = 0; i < n; i++) ;
333: }
334:
335: dimension(fd)
336: { struct stat bam;
337: int N;
338: extern float fsqrt();
339:
340: if (fstat(fd, &bam)==0)
341: { N = bam.st_size;
342: N = (int) fsqrt((double)N+1.0);
343: return N;
344: }
345: return 0;
346: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.