![[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] / researchv10no / cmd / qsnap|
Return to qsnap.c CVS log | Up to [Research Unix] / researchv10no / cmd / qsnap |
1.1 root 1: #include <fb.h>
2: #include <stdio.h>
3: #include <sys/types.h>
4: #include <sys/stat.h>
5: #include "defines.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 Dither=0, BW=1, Times=3, Bright=0;
13: int Film = 0;
14: int Filter = GREEN;
15: int Reso;
16: int redonly = 0;
17: int mustrot = 0;
18: int settimes= 0;
19: int setbright=0;
20: int skip = 0;
21:
22: unsigned char nq[9];
23: char *malloc();
24: unsigned char *rgb;
25:
26: Usage(str)
27: char *str;
28: { fprintf(stderr, "qsnap: %s\n", str);
29: fprintf(stderr, "usage: qsnap -bcdfmnrRF [N ...] file\n");
30: fprintf(stderr, "b brightness [0-8,9], defaults to 0 (2k) or 2 (4k)\n");
31: fprintf(stderr, "c td format n-channel color image\n");
32: fprintf(stderr, "d dither image +- N [2-255]\n");
33: fprintf(stderr, "f filmtype [0-2], defaults to 0 (custom,lin,pola)\n");
34: fprintf(stderr, "m enlargement [1- ], defaults to 3(2k) or 6(4k)\n");
35: fprintf(stderr, "n headerless square b&w image (default)\n");
36: fprintf(stderr, "r expose red only, when combined with 'c'\n");
37: fprintf(stderr, "F bwfilter [0-3], defaults to 2 (n,r,g,b)\n");
38: fprintf(stderr, "R rotate image 90o clockwise\n");
39: fprintf(stderr, "s skip the first N pictures\n");
40: exit(1);
41: }
42:
43: main(argc, argv)
44: char **argv;
45: {
46: int i=1, base=2; /* base of option arguments */
47: int x, y;
48: char c;
49:
50: if (argc > 1 && argv[1][0] == '-')
51: { base++;
52: while ((c = argv[1][i++]) != '\0')
53: switch (c) {
54: /* neutral */ case 'n': BW = 1; break;
55: /* color */ case 'c': BW = 0; break;
56: /* bright */ case 'b': if (argc >= base)
57: { sscanf(argv[base-1], "%d", &Bright);
58: base++;
59: Bright = Bright%10;
60: setbright = 1;
61: break;
62: } else
63: Usage("missing argument for `b' flag");
64: /* dither */ case 'd': if (argc >= base)
65: { sscanf(argv[base-1], "%d", &Dither);
66: base++;
67: if (Dither < 0) Dither = -Dither;
68: break;
69: } else
70: Usage("missing argument for `d' flag");
71:
72: /* filmtype */ case 'f': if (argc >= base)
73: { sscanf(argv[base-1], "%d", &Film);
74: Film = Film%8;
75: base++;
76: if (Film == 6)
77: Usage("unknown film type");
78: break;
79: } else
80: Usage("missing argument for `f' flag");
81: /* multiply */ case 'm': if (argc >= base)
82: { sscanf(argv[base-1], "%d", &Times);
83: base++;
84: settimes = 1;
85: break;
86: } else
87: Usage("missing argument for `m' flag");
88: /* filter */ case 'F': if (argc >= base)
89: { sscanf(argv[base-1], "%d", &Filter);
90: Filter = Filter%4;
91: base++;
92: break;
93: } else
94: Usage("missing argument for `F' flag");
95: case 'R': mustrot = 1; break;
96: case 'r': redonly = 1; break;
97: case 's': if (argc >= base)
98: { sscanf(argv[base-1], "%d", &skip);
99: base++;
100: break;
101: } else
102: Usage("missing argument for `s' flag");
103: default : Usage("unknown option");
104: }
105: }
106: if (base > argc)
107: Usage("bad arglist");
108: qreset();
109: nocalibs();
110: Reso = resolution();
111: if (Reso == 4)
112: { if (!settimes) Times = 6;
113: if (!setbright) Bright = 2;
114: }
115:
116: rotate(mustrot);
117: filmtype(Film);
118: if (Bright != 9)
119: { getbright(nq);
120: brightness(Bright, Bright, Bright, Bright);
121: printf("brightness %d (%d)\n", Bright, nq[Bright]);
122: }
123:
124: handshake(1);
125:
126: for (x = -512*Reso, y = 384*Reso; base <= argc; base++)
127: { if (skip-- > 0)
128: continue;
129: i = snap(argv[base-1], x, y);
130: x += i;
131: if (x+i >= 512*Reso)
132: { y -= i;
133: x = -512*Reso;
134: }
135: if (y-i < -384*Reso)
136: { fprintf(stderr, "picture %s doesn't fit\n", argv[base-1]);
137: break;
138: }
139: qreset();
140: brightness(Bright, Bright, Bright, Bright);
141: handshake(1);
142: }
143: exit(0);
144: }
145:
146: snap(name, Xmin, Ymin)
147: char *name;
148: {
149: PICFILE *f;
150: register i, fd;
151: register unsigned char *p;
152: int h, w, nchan=1;
153: int Xmax = 1024*Reso, Ymax = 768*Reso;
154:
155: if (BW)
156: { if ((fd = open(name, 0)) == -1)
157: { perror(name);
158: exit(1);
159: }
160: w = dimension(fd);
161: if (w*XTIMES > Xmax)
162: { fprintf(stderr, "width is too large\n");
163: fprintf(stderr, "you have: %dx%d=%d\n",w,XTIMES,w*XTIMES);
164: exit(1);
165: }
166: h = Min(Ymax/YTIMES, w);
167: printf("%s: %dx%d\n", name, w, h);
168: if (!(rgb = (unsigned char *) malloc(w*h* sizeof(unsigned char))))
169: { fprintf(stderr, "sorry, not enough memory\n");
170: exit(1);
171: }
172: read(fd, (char *)rgb, w*h);
173: close(fd);
174: } else
175: { if ((f = openpicr(name)) == NULL)
176: { perror(name);
177: exit(1);
178: }
179: w = f->r.co.x-f->r.or.x;
180: h = f->r.co.y-f->r.or.y;
181: nchan = f->nchan;
182: if (w*XTIMES > Xmax)
183: { fprintf(stderr, "width too large\n");
184: fprintf(stderr, "you have: %dx%d=%d\n",w,XTIMES,w*XTIMES);
185: exit(1);
186: }
187: h = Min(Ymax/YTIMES, h);
188: printf("%s: %dx%d\n", name, w, h);
189: if (!(rgb = (unsigned char *)
190: malloc(w*h*nchan* sizeof(unsigned char))))
191: { fprintf(stderr, "sorry, not enough memory\n");
192: exit(1);
193: }
194: for (p = rgb, i = 0; i < h; i++)
195: { readpic(f, p);
196: p += w*nchan;
197: }
198: closepic(f);
199: }
200: window(Xmin, Ymin, w*XTIMES, h*YTIMES);
201:
202: if (BW)
203: { singlepass(Filter);
204: onechannel(rgb, h, w, 1);
205: } else
206: { threepass();
207: printf("red\n"); onechannel(rgb , h, w, nchan);
208: if (!redonly) {
209: printf("grn\n"); onechannel(rgb+1, h, w, nchan);
210: printf("blu\n"); onechannel(rgb+2, h, w, nchan);
211: }
212: }
213: printf("done\n");
214: return w*XTIMES;
215: }
216:
217: onechannel(from, h, w, n)
218: unsigned char *from;
219: {
220: if (Dither)
221: { prerand();
222: onedither(from, h, w, n);
223: } else
224: straight(from, h, w, n);
225: }
226:
227: straight(from, h, w, n)
228: unsigned char *from;
229: {
230: register i, j, k;
231: register unsigned char *p, *q;
232: unsigned char obuf[8192];
233: int chunk = w*XTIMES;
234:
235: for (i = 0, p = from; i < h; i++)
236: { q = obuf;
237: for (j = 0; j < w; j++, p += n)
238: for (k = 0; k < XTIMES; k++)
239: *q++ = *p;
240: for (k = 0; k < YTIMES; k++)
241: { qwrite(obuf, chunk);
242: if (chunk > 2048) qwait(200);
243: } }
244: }
245:
246: short Nrand[5000];
247:
248: prerand()
249: { register int i, D1=Dither, D2=Dither/2;
250:
251: for (i = 0; i < 5000; i++)
252: Nrand[i] = (short) (nrand(D1) - D2);
253: }
254:
255: /*onedither(from, h, w, n)
256: unsigned char *from;
257: {
258: register short c, m, kk;
259: register unsigned char *op, *q;
260: register int D1 = Dither;
261: unsigned char *p, obuf[8192];
262: int i, j, k;
263: int chunk = w*XTIMES;
264:
265: for (i = 0, p = from; i < h; i++, p = op)
266: for (k = 0; k < YTIMES; k++)
267: { q = obuf;
268: op = p;
269: for (j = 0; j < w; j++, op += n)
270: for (m = 0; m < XTIMES; m++)
271: { c = (short) *op + Nrand[kk];
272: if (++kk >= 5000) kk = 0;
273: if(c<0)
274: c=0;
275: if(c>255)
276: c=255;
277: *q++ = (unsigned char) c;
278: }
279: qwrite(obuf, chunk);
280: }
281: }*/
282: onedither(from, h, w, n)
283: unsigned char *from;
284: {
285: register int c, m, kk=0;
286: register unsigned char *op, *q;
287: register int D1 = Dither;
288: unsigned char *p, obuf[8192];
289: int i, j, k;
290: int chunk = w*XTIMES;
291:
292: if (w <= 0 || XTIMES <= 0) abort();
293: for (i = 0, p = from; i < h; i++, p = op)
294: for (k = 0; k < YTIMES; k++)
295: { q = obuf;
296: op = p;
297: j = w;
298: do{
299: m = XTIMES;
300: do{
301: c = *op + Nrand[kk];
302: if (++kk >= 5000) kk = 0;
303: if(c<0)
304: c=0;
305: if(c>255)
306: c=255;
307: *q++ = c;
308: }while(--m);
309: op += n;
310: }while(--j);
311: qwrite(obuf, chunk);
312: }
313: }
314:
315: qwait(n)
316: { int i;
317: for (i=0; i < n; i++) ;
318: }
319:
320: dimension(fd)
321: { struct stat bam;
322: int N;
323: extern float fsqrt();
324:
325: if (fstat(fd, &bam)==0)
326: { N = bam.st_size;
327: N = (int) fsqrt((double)N+1.0);
328: return N;
329: }
330: return 0;
331: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.