![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Q2snap.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 Q2snap.c CVS log | Up to [Research Unix] / researchv10no / 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 "/graphics/piclib/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 Dither=0, 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:
21: unsigned char nq[9];
22: char *malloc();
23: unsigned char *rgb;
24:
25: Usage(str)
26: char *str;
27: { fprintf(stderr, "qsnap: %s\n", str);
28: fprintf(stderr, "usage: qsnap -bdfmrRFL [N ...] file\n");
29: fprintf(stderr, "b brightness [0-8,9], defaults to 0 (2k) or 2 (4k)\n");
30: fprintf(stderr, "d dither image +- N [2-255]\n");
31: fprintf(stderr, "f filmtype [0-2], defaults to 0 (custom,lin,pola)\n");
32: fprintf(stderr, "m enlargement [1- ], defaults to 3(2k) or 6(4k)\n");
33: fprintf(stderr, "r expose red only (for multiple red overlays)\n");
34: fprintf(stderr, "F bwfilter [0-3], defaults to 2 (n,r,g,b)\n");
35: fprintf(stderr, "R rotate image 90o clockwise\n");
36: fprintf(stderr, "L straight (no m,d), headerless 1 chan, line by line\n");
37: exit(1);
38: }
39:
40: main(argc, argv)
41: char **argv;
42: {
43: int i=1, base=2; /* base of option arguments */
44: int linebyline = 0;
45: char c;
46:
47: if (argc > 1 && argv[1][0] == '-')
48: { base++;
49: while ((c = argv[1][i++]) != '\0')
50: switch (c) {
51: /* bright */ case 'b': if (argc >= base)
52: { sscanf(argv[base-1], "%d", &Bright);
53: base++;
54: Bright = Bright%10;
55: setbright = 1;
56: break;
57: } else
58: Usage("missing argument for `b' flag");
59: /* dither */ case 'd': if (argc >= base)
60: { sscanf(argv[base-1], "%d", &Dither);
61: base++;
62: if (Dither < 0) Dither = -Dither;
63: break;
64: } else
65: Usage("missing argument for `d' flag");
66:
67: /* filmtype */ case 'f': if (argc >= base)
68: { sscanf(argv[base-1], "%d", &Film);
69: Film = Film%8;
70: base++;
71: if (Film == 6)
72: Usage("unknown film type");
73: break;
74: } else
75: Usage("missing argument for `f' flag");
76: /* multiply */ case 'm': if (argc >= base)
77: { sscanf(argv[base-1], "%d", &Times);
78: base++;
79: settimes = 1;
80: break;
81: } else
82: Usage("missing argument for `m' flag");
83: /* filter */ case 'F': if (argc >= base)
84: { sscanf(argv[base-1], "%d", &Filter);
85: Filter = Filter%4;
86: base++;
87: break;
88: } else
89: Usage("missing argument for `F' flag");
90: case 'R': mustrot = 1; break;
91: case 'L': linebyline = 1; break;
92: case 'r': redonly = 1; break;
93: default : Usage("unknown option");
94: }
95: }
96: if (base != argc) Usage("bad arglist");
97: qreset();
98: nocalibs();
99: Reso = resolution();
100: if (Reso == 4)
101: { if (!settimes) Times = 6;
102: if (!setbright) Bright = 2;
103: }
104:
105: rotate(mustrot);
106: filmtype(Film);
107: if (Bright != 9)
108: { getbright(nq);
109: brightness(Bright, Bright, Bright, Bright);
110: printf("brightness %d (%d)\n", Bright, nq[Bright]);
111: }
112: handshake(0);
113: linedelay(1);
114:
115: if (linebyline)
116: znap(argv[base-1]);
117: else
118: snap(argv[base-1]);
119: exit(0);
120: }
121:
122: znap(name)
123: char *name;
124: {
125: register i;
126: int fd, h, w;
127: unsigned char obuf[8192];
128: int Xmax = 1024*Reso, Ymax = 768*Reso;
129: int Xmin = -512*Reso, Ymin = 384*Reso;
130:
131: if ((fd = open(name, 0)) < 0)
132: { fprintf(stderr, "cannot open %s\n", name);
133: return;
134: }
135: w = dimension(fd);
136: if (w > Xmax) { fprintf(stderr, "image too wide (%d)\n", w); exit(1); }
137: h = Min(Ymax, w);
138:
139: printf("%s: %dx%d\n", name, w, h);
140: window(Xmin+500, Ymin, w, h);
141: singlepass(Filter);
142: for (i = 0; i < h; i++)
143: { read(fd, obuf, w);
144: qwrite(obuf, w);
145: }
146: printf("done\n");
147: }
148:
149: snap(name)
150: char *name;
151: {
152: int fd, h, w;
153: int Xmax = 1024*Reso, Ymax = 768*Reso;
154: int Xmin = -512*Reso, Ymin = 384*Reso;
155: struct pfile image;
156:
157: if((fd = openf(name, &image)) == -1 || !readf(fd, &image))
158: { fprintf(stderr, "bad image %s\n", name);
159: return;
160: }
161: w = image.r.corner.x - image.r.origin.x;
162: if (w*XTIMES > Xmax)
163: { fprintf(stderr, "width is too large\n");
164: fprintf(stderr, "you have: %dx%d=%d\n",w,XTIMES,w*XTIMES);
165: exit(1);
166: }
167: h = image.r.corner.y - image.r.origin.y;
168: h = Min(Ymax/YTIMES, h);
169: printf("%s: %dx%d\n", name, w, h);
170: window(Xmin, Ymin, w*XTIMES, h*YTIMES);
171:
172: if (image.nchan == 1)
173: { singlepass(Filter);
174: onechannel(image.pixred, h, w);
175: } else
176: { threepass();
177: printf("red\n"); onechannel(image.pixred, h, w);
178: if (redonly) goto done;
179: printf("grn\n"); onechannel(image.pixgrn, h, w);
180: printf("blu\n"); onechannel(image.pixblu, h, w);
181: }
182: done: printf("done\n");
183: }
184:
185: onechannel(from, h, w)
186: unsigned char *from;
187: {
188: if (Dither)
189: { prerand();
190: onedither(from, h, w);
191: } else
192: straight(from, h, w);
193: }
194:
195: straight(from, h, w)
196: unsigned char *from;
197: {
198: register i, j, k;
199: register unsigned char *p, *q;
200: unsigned char obuf[8192];
201: int chunk = w*XTIMES;
202:
203: for (i = 0, p = from; i < h; i++)
204: { q = obuf;
205: for (j = 0; j < w; j++, p++)
206: for (k = 0; k < XTIMES; k++)
207: *q++ = *p;
208: for (k = 0; k < YTIMES; k++)
209: { qwrite(obuf, chunk);
210: if (chunk > 2048) qwait(200);
211: } }
212: }
213:
214: short Nrand[5000];
215:
216: prerand()
217: { register int i, D1=Dither, D2=Dither/2;
218:
219: for (i = 0; i < 5000; i++)
220: Nrand[i] = (short) (nrand(D1) - D2);
221: }
222:
223: onedither(from, h, w)
224: unsigned char *from;
225: {
226: register int c, m, kk=0;
227: register unsigned char *op, *q;
228: unsigned char *p, obuf[8192];
229: int i, j, k;
230: int chunk = w*XTIMES;
231:
232: for (i = 0, p = from; i < h; i++, p = op)
233: for (k = 0; k < YTIMES; k++)
234: { q = obuf;
235: op = p;
236: j = w;
237: do{
238: m = XTIMES;
239: do{
240: c = *op + Nrand[kk];
241: if (++kk >= 5000) kk = 0;
242: if(c<0)
243: c=0;
244: if(c>255)
245: c=255;
246: *q++ = c;
247: }while(--m);
248: op++;
249: }while(--j);
250: qwrite(obuf, chunk);
251: }
252: }
253:
254: qwait(n)
255: { int i;
256: for (i = 0; i < n; i++) ;
257: }
258:
259: dimension(fd)
260: { struct stat bam;
261: int N;
262: extern float fsqrt();
263:
264: if (fstat(fd, &bam)==0)
265: { N = bam.st_size;
266: N = (int) fsqrt((double)N+1.0);
267: return N;
268: }
269: return 0;
270: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.