![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to files.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / pico|
Return to files.c CVS log | Up to [Research Unix] / researchv10no / cmd / pico |
1.1 root 1: #include <stdio.h>
2: #include <sys/types.h>
3: #include <sys/stat.h>
4: #include "pico.h"
5:
6: extern struct SRC src[MANY];
7: extern short CURSCRATCH, CUROLD;
8: extern int nsrc, DEF_LL, DEF_NL;
9: extern char frameb, usedold, metheus;
10:
11: prepare(infile)
12: char *infile;
13: {
14: struct SRC *into = &src[nsrc];
15: int from;
16:
17: into->ex = into->ll = DEF_LL;
18: into->ey = into->nl = DEF_NL;
19: into->nchan = DEF_CH;
20: into->sx = into->sy = 0;
21:
22: if ((from = whatarray(infile)) != -1)
23: { fprintf(stderr, "sorry: base name clash of %s with %s\n",
24: infile, src[from].fname);
25: return 0;
26: }
27: strcpy(into->fname, infile);
28: if ((from = eopen(infile)) > 0 && readheader(into, from))
29: { into->fd = from;
30: into->used = 0;
31: into->pixred = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
32: if (into->nchan >= 3)
33: { into->pixgrn = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
34: into->pixblu = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
35: } else
36: { into->pixgrn = into->pixblu = into->pixred;
37: }
38: into->incore = 1;
39: nsrc++;
40: return nsrc-1;
41: } else
42: { into->fname[0] = '\0';
43: into->fd = -1;
44: into->incore = into->used = 0;
45: return 0;
46: }
47: }
48:
49: interpret(infile)
50: char *infile;
51: {
52: struct SRC *into = &src[nsrc];
53: int from, hh;
54:
55: into->ex = into->ll = DEF_LL;
56: into->ey = into->nl = DEF_NL;
57: into->nchan = DEF_CH;
58: into->sx = into->sy = 0;
59:
60: if ((from = eopen(infile)) > 0 && (hh = rawheader(into, from)))
61: { fprintf(stderr, "%s: ", &infile[findbase(infile)]);
62: if (hh == 2)
63: { hh = less(from);
64: fprintf(stderr, "headerless file, ");
65: fprintf(stderr, "ll %d nl %d, ", into->ll, into->nl);
66: fprintf(stderr, "(%d = %dx512 bytes)\n", hh, hh/512);
67: } else
68: { fprintf(stderr, "%s ", (into->nchan == 1)?"b&w ":"color");
69: tpfile(into->type);
70: fprintf(stderr, "ll %d nl %d ", into->ll, into->nl);
71: wsize(into->sx, into->sy, into->ex, into->ey);
72: }
73: close(from);
74: }
75: into->fd = -1;
76: into->incore = into->used = 0;
77: }
78:
79: tpfile(n)
80: {
81: switch (n) {
82: case PICO: fprintf(stderr, "pico-format "); break;
83: case DUMP: fprintf(stderr, "dump-format "); break;
84: case RUNCODE: fprintf(stderr, "runcode-format "); break;
85: }
86: }
87:
88: less(fd)
89: { struct stat bam;
90: if (fstat(fd, &bam)==0)
91: return bam.st_size;
92: return 0;
93: }
94:
95: nopix(into)
96: struct SRC *into;
97: {
98: into->pixred = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
99: /*
100: into->pixgrn = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
101: into->pixblu = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
102: */
103: into->pixgrn = (unsigned char *) 0;
104: into->pixblu = (unsigned char *) 0;
105: into->ex = into->ll = DEF_LL;
106: into->ey = into->nl = DEF_NL;
107: into->nchan = DEF_CH;
108: into->sx = into->sy = 0;
109: into->ox = into->oy = 0;
110: strcpy(into->fname, "_workspace_");
111: into->incore = 1;
112: }
113:
114: checkpix(into)
115: struct SRC *into;
116: {
117: if (!into->pixgrn)
118: into->pixgrn = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
119: if (!into->pixblu)
120: into->pixblu = (unsigned char *) Emalloc(DEF_LL*DEF_NL);
121: }
122:
123: discard(s)
124: char *s;
125: { int nr;
126:
127: if ((nr = ungetpix(s)) < 2)
128: return 0;
129:
130: close(src[nr].fd);
131: src[nr].fd = -1;
132: src[nr].sx = src[nr].sy = src[nr].nchan = 0;
133: src[nr].ex = src[nr].ey = src[nr].ll = 0;
134: strcpy(src[nr].fname, " empty");
135: src[nr].used = 0;
136:
137: return nr;
138: }
139:
140: ungetpix(s)
141: char *s;
142: { int nr;
143:
144: if ((nr = whatarray(s)) < 2)
145: { fprintf(stderr, "unknown file %s\n", s);
146: return 0;
147: }
148:
149: if (src[nr].incore == 0)
150: return nr;
151:
152: free(src[nr].pixred);
153: if (src[nr].nchan >= 3)
154: { free(src[nr].pixgrn);
155: free(src[nr].pixblu);
156: }
157: src[nr].incore = 0;
158: lseek(src[nr].fd, src[nr].sop, 0);
159:
160: return nr;
161: }
162:
163: newscreen(infile)
164: char *infile;
165: {
166: if ((Old->fd = eopen(infile)) > 0 && readheader(Old, Old->fd))
167: { getpix(Old, infile);
168: putscreen(CUROLD);
169: setscratch(Old, Scratch);
170: return 1;
171: } /* else reset */
172: Old->ex = Old->ll = DEF_LL;
173: Old->ey = Old->nl = DEF_NL;
174: Old->nchan = DEF_CH;
175: Old->sx = Old->sy = 0;
176: return 0;
177: }
178:
179: readheader(into, from)
180: struct SRC *into;
181: {
182: int i, ret = rawheader(into, from);
183: int a = into->sx, b = into->sy;
184: int c = into->ex, d = into->ey;
185: int n = into->nchan;
186:
187: if (a > c) i = a, a = c, c = i; /* flip */
188: if (b > d) i = b, b = d, d = i;
189: if (a < 0) c -= a, a = 0; /* normalize */
190: if (b < 0) d -= b, b = 0;
191: into->ll = c-a; into->nl = d-b; /* scan ll,nl */
192:
193: a = min(DEF_LL, a); c = min(DEF_LL, c); /* clip */
194: b = min(DEF_NL, b); d = min(DEF_NL, d);
195:
196: into->sx = a; into->sy = b;
197: into->ex = c; into->ey = d;
198: into->ox = 0; into->oy = 0;
199:
200: if (ret == 0) return 0;
201:
202: if (a >= c || b >= d)
203: { fprintf(stderr, "pico: file window is outside screen area\n");
204: return 0;
205: }
206: if (n < 1 || n > 4)
207: { fprintf(stderr, "pico: bad nr of channels (%d)\n", n);
208: return 0;
209: }
210:
211: return ret;
212: }
213:
214: rawheader(into, from)
215: struct SRC *into;
216: { char line[512];
217: int i, j, a, b, c, d, N, sawtype=0;
218: extern double sqrt();
219:
220: into->type = PICO; /* default */
221: for (j = 0;;)
222: { for (i = 0; i < 127; i++, j++)
223: { read(from, &line[i], 1);
224: if (line[i] == '\n')
225: { line[i] = '\0';
226: break;
227: } }
228: if (i == 0) /* saw end of header */
229: { if (sawtype)
230: { into->sop = j;
231: return 1;
232: } else
233: i = 127;
234: }
235: if (i == 127) /* no header */
236: { into->nchan = 1; /* assume b&w, square image */
237: N = (int) sqrt((double)less(from)+1.0);
238: into->ex = into->ey = N;
239: into->ll = into->nl = N;
240: lseek(from, 0L, 0);
241: into->sop = 0;
242: return 2;
243: }
244: if (sscanf(line, "WINDOW=%d %d %d %d", &a, &b, &c, &d) == 4)
245: { into->sx = a; into->sy = b;
246: into->ex = c; into->ey = d;
247: into->ll = c-a; into->nl = d-b;
248: } else if (sscanf(line, "NCHAN=%d", &a) == 1)
249: into->nchan = a;
250: else if (strcmp(line, "TYPE=dump") == 0)
251: { into->type = DUMP; sawtype = 1;
252: } else if (strcmp(line, "TYPE=runcode") == 0)
253: { into->type = RUNCODE; sawtype = 1;
254: } else if (strcmp(line, "TYPE=pico") == 0)
255: { into->type = PICO; sawtype = 1;
256: } else if (strncmp(line, "TYPE", 4) == 0)
257: { fprintf(stderr, "pico: unknown format: %s..\n", line);
258: return 0;
259: }
260: }
261: }
262:
263: putheader(where, n, a, b, c, d)
264: { char line[128];
265:
266: sprintf(line, "TYPE=pico\nWINDOW=%d %d %d %d\nNCHAN=%d\n\n", a,b,c,d,n);
267: write(where, line, strlen(line));
268: }
269:
270: putdpix(which, how)
271: char *which;
272: {
273: int fd, a, b, c, d;
274:
275: a = Old->sx; b = Old->sy;
276: c = Old->ex; d = Old->ey;
277:
278: checkit(); /* make sure we have screen incore */
279: if ((fd = creat(which, 0666)) <= 0)
280: yyerror("cannot create file %s", which);
281:
282: if (!how)
283: putwindow(fd, Old->pixred, a, b, c-a, d-b);
284: else
285: { if (Old->nchan != 1 || c-a != d-b)
286: putheader(fd, min(3, Old->nchan), a, b, c, d);
287: putfile(fd, a, b, c-a, d-b);
288: }
289: close(fd);
290: }
291:
292: putfile(where, x, y, w, d)
293: {
294: putwindow(where, Old->pixred, x, y, w, d);
295: if (Old->nchan >= 3)
296: { putwindow(where, Old->pixgrn, x, y, w, d);
297: putwindow(where, Old->pixblu, x, y, w, d);
298: }
299: close(where);
300: }
301:
302: checkit()
303: { register int i;
304:
305: if (usedold && src[CUROLD].incore != 2 && (frameb || metheus))
306: fprintf(stderr, "warning: picture on screen wasn't read\n");
307:
308: for (i = 2; i < nsrc; i++)
309: if (src[i].used && src[i].incore != 2)
310: { src[i].used = 0;
311: getpix(&src[i], src[i].fname);
312: }
313: }
314:
315: setscratch(from, to)
316: struct SRC *from, *to;
317: {
318: register unsigned char *qr = from->pixred, *pr = to->pixred;
319: register unsigned char *qg = from->pixgrn, *pg = to->pixgrn;
320: register unsigned char *qb = from->pixblu, *pb = to->pixblu;
321: memcpy(pr, qr, DEF_NL*DEF_LL);
322: if (pg && qg) memcpy(pg, qg, DEF_NL*DEF_LL);
323: if (pb && qb) memcpy(pb, qb, DEF_NL*DEF_LL);
324: }
325:
326: getter(n)
327: {
328: if (n <= 0)
329: return;
330: if (n > 1)
331: { if (src[n].incore != 2)
332: getpix(&src[n], src[n].fname);
333: setscratch(&src[n], Old);
334: }
335: putscreen(CUROLD);
336: if (n > 1)
337: setscratch(Old, Scratch);
338: RESIDENT;
339: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.