![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bcp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / bcp|
Return to bcp.c CVS log | Up to [Research Unix] / researchv10no / cmd / bcp |
1.1 root 1: /* Copyright (c) 1989, 1990 AT&T --- All Rights Reserved. */
2: /* THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T. */
3: /* The copyright notice does not imply actual or intended publication. */
4: /* AUTHORS: */
5: /* H. S. Baird - ATT-BL MH - first versions */
6: /* T. J. ThompsonT - ATT-BL HO - extensions */
7:
8: /* bcp.c - translate among binary image file formats, optionally trimming,
9: shifting, scaling, and rotating the image on the fly. Scaling is by
10: arbitrary real factors, separately in X & Y. Rotation is still crude and
11: slow.
12: USAGE:
13: bcp [options...] [I [O]]
14: I/O:
15: If O is omitted, all output is concatenated to stdout.
16: If I is also omitted, all input is read from stdin.
17: If I is a filename, it is the sole input; but, if it is a directory name,
18: then every leaf of its file tree is processed in turn; and, in this case,
19: if O also is specified, it is forced to become the root directory
20: of an isomorphic tree of output files (this use of Unix file trees
21: may be defeated using compile-time option FILE_TREE).
22:
23: [PROPOSED: An input file may be a catenation of pages. These may vary
24: in TYPE and other parameters. They will all be translated to the same
25: output type, and catenated to one file, each with a complete translated
26: header. Generally, a complete picfile header must be repeated at the
27: top of each page: exceptions include TYPE=cdf, which packs pages in its
28: own peculiar way.]
29:
30: OPTIONS:
31: NOTE: lengths, distances, and pixel indices are assumed to be in
32: units of pixels (scanner units), unless one of "icpPs" is appended,
33: meaning inches, cm, points, picas, or (explicitly) scanner pixels.
34: This applies to option: -w (seems buggy).
35:
36: -B[io] read/write bitfile(9.5) format (doesn't use TYPE= header).
37: [doesn't run-length encode yet: may be bulky.]
38: -M write TYPE=bitmap format.
39: -P write Postscript format (only on Suns; by Tim Thompson, ATT-BL HO)
40: -Rx[,y] force output resolutions to x,y (overrides -xX[,Y]) (pixels/inch).
41: Requires a RES=X Y line in the header.
42: -R= Force the output resolution to be equal to the greater of
43: the input resolutions.
44: -S write Sun rasterfile format (only on Suns; by Tim Thompson,
45: ATT-BL HO)
46: -Tt when reading TYPE=dump, binarize the image by thresholding each
47: pixel value as follows: (pixel<t)? black: white. (default: -T128)
48: -Ww shrink-wrap output around black artwork, surrounding it with equal
49: margins of width w (pixels), then translate so that the left-top
50: corner of the margin box is at 0,0 (works only with TYPE=document-
51: image input). (w must be >= 0)
52: -Zx[,y] set input resolution to RES=x y (overriding existing RES, if any)
53: -b write binary format (TYPE=binary)
54: -d? trace to stderr:
55: -dR comment on any change in resolution
56: -dc point out oddities in cdf files which are, by default,
57: silently corrected
58: -dh file headers (a good first debugging step)
59: -dm margins
60: -dr runs (exhaustive, voluminous)
61: -ds status and summary statistics (brief)
62: -g31 write CCITT FAX Group 3 1-dim encoding
63: -31 ditto
64: -g32 write CCITT FAX Group 3 2-dim encoding (see also -k option)
65: -32 ditto
66: -g4 write CCITT FAX Group 4 encoding (the default output format)
67: -4 ditto
68: -kK set the 'k' for g32 encoding on output (default: -k4)
69: -oX,Y offset the result by X,Y (merely shift the bounding box)
70: -p write TYPE=dump NCHAN=1 format; input binary pixels
71: are mapped to grey as follows: (pixel==white)? 255: 0.
72: -r write rle format (this is Pavlidis' obsolescent OCR format)
73: -t[lrbN] top of the page is really at the left/right/bottom;
74: after all other transformations are carried out, the image
75: will be rotated to bring the real top of page to the top.
76: By arbitrary convention, the top-left corner of the rotated
77: image will be equal to the top-left corner of the image
78: resulting from all the other transformations.
79: [UNFINISHED, UNDER DEVELOPMENT: -tr & -tb; -tN, where N is a
80: numeric string, is interpreted as a counterclockwise rotation by
81: N degrees: for now, only handle +/-20 degrees. The present code
82: for -tN is slow and subject to aliasing.]
83: -v reverse video: swap black and white
84: -wL,T,R,B specify window to select:
85: (L,T) is the left-top (origin) and (R,B) the OPEN right-bottom
86: corner (i.e. the corner coordinates are not included.) A '%'
87: argument defaults to the input window parameter.
88: [NOTE: since non-zero L,T windows are still not everywhere well
89: supported (by pcp, met, etc), it might be best to shift the
90: new L,T to 0,0 on output -- but this is not done now.]
91: -xX[,Y] expansion factor(s), horizontally and vertically;
92: if only one is specified, they are assumed equal
93: (default: -x1.0,1.0) May be overridden by -Rx[,y].
94: Requires a RES=X Y line in the header.
95: DESCRIPTION
96: This translates among these formats of binary images:
97: ccitt-g31, ccitt-g32, ccitt-g4, picture (TYPE=dump NCHAN=1), binary, rle,
98: bitfile(9.5), cdf, Sun rasterfile (TYPE=bitmap), and Postscript. All require
99: a TYPE= header in picfile format (see below), except bitfile(9.5) (as a result,
100: to read these, must use special option: -Bi). Most require WINDOW=ox oy cx cy
101: and RES=x y header lines also.
102: Optionally, the image may be modified on the fly by the following
103: operations performed in this order:
104: trimming - a subset of the input image is selected (-w option)
105: shifting - the origin is shifted (-o)
106: scaling - real scaling factors are applied, in X & Y separately (-x, -R)
107: rotation - by 90, 180, 270 degrees - UNDER DEVELOPMENT (-t option)
108: reverse-video - swap black and white (-v option)
109: Note that scaling changes the effective digitizing resolution by arbitrary
110: real factors (expansion or contraction), in X and Y separately. Presently,
111: this is accomplished naively by replication or deletion of pixels. If it is
112: ever desired to apply more interesting image-processing techniques (such as
113: smoothing and resampling), the required changes may be safely confined to
114: functions transform_rlels() (in bcp.c) & transform_rlel() (in rlelib.c).
115: Accepts TYPE=document-image (or TYPE=dim), flattening its hierarchy,
116: and writes it out as a single page image.
117: PICFILE FORMAT (briefly summarized; see picture(5))
118: Each picture file comprises an ASCII header followed by binary data.
119: The header is terminated by two newlines (an empty line). A typical header is:
120: TYPE=ccitt-g4
121: WINDOW=0 0 640 480
122: RES=300 300
123: (note the final empty line)
124: TYPE must come first. The other lines may come in any order. WINDOW gives
125: the x,y coordinates of the upper left corner (inclusive) and lower right
126: corners (exclusive). Typically, an image of WxH pixels will be described
127: by WINDOW=0 0 W H. RES=X Y gives the digitizing resolution horizontally and
128: vertically, in integral pixels/inch. Supported TYPEs include:
129:
130: dump A two-dimensional array of pixel structures. NCHAN=1 is required:
131: one byte per pixel. On input, the grey pixel values are thresholded
132: to binary (see option -T). On output, black is 0 and white is 255.
133:
134: bitmap One bit/pixel, packed into bytes high-order bit first. Black is `1'.
135: Each horizontal row is padded to a 16-bit boundary with `0'.
136: (This is identical to Sun rasterfile format, except for the ASCII
137: header.)
138:
139: ccitt-g4 CCITT FAX Group 4 compressed image. Similarly, ccitt-g31 means
140: Group 3/1-D and ccitt-g32 means Group 3/2-D.
141:
142: (Obsolescent 112 formats:
143: rle A run-length coding, better for binary images (see rle.h).
144: binary 1 bit/pixel, packed into bytes low-order bit first. Black is `1'.
145: Each horizontal row is padded to a full byte with `0'.)
146:
147: NOTE: bitfile(9.5) doesn't use an ASCII header.
148:
149: (Odd formats in use outside 112, sometimes very heavily:
150: cdf supported on input only, and only the first page of several.
151: tiff not yet supported.)
152:
153: IMPLEMENTATION STATUS
154: CCITT FAX ``uncompressed'' (or, ``transparent'') mode is not implemented,
155: either while encoding or decoding.
156: Cdf is an input-only option; Sun rasterfile and Postscript are output-only options.
157: Postscript output is useful only for very small images.
158: Rotations are only partially implemented, and are slow.
159:
160: KNOWN BUGS (30 May 89)
161: WINDOW=OX OY CX CY where OX or OY are non-zero is not handled correctly
162: for every combination of file types.
163: Unit gets passed wrongly to vto_scoor().
164: Rle can't be both inout and output (design flaw: they share a buffer).
165: Beware off-by-one errors (top or bottom line omitted); has not been
166: carefully checked for all file type combinations.
167:
168: AUTHORS
169: Dec 1988 - Henry S. Baird (AT&T Bell Labs MH) - first working draft
170: Mar 1989 - Tim Thompson (BL HO) - extensions for SunOS, bug fixes, etc
171: */
172:
173: #include <stdio.h>
174: #include <string.h>
175: #include <ctype.h>
176: #include "CPU.h"
177: #define MAIN 1
178: #include "stdocr.h"
179: #include "rle.h"
180: #include "pic.h"
181: #include "Text.h"
182: /* Ugly stubs just to prevent Text.h dragging in many other *.h & *.o files */
183: Bfeats *alloc_bfeats(){}; free_bfeats(){}; Bfeats *dup_bfeats(){};
184: fwrb_bfeats(){}; frdb_bfeats(){}; fix_lag(){}; char *classid_toa(){};
185: #include "Bitmap.h"
186: #include "CCITT.h"
187: #include "bitio.h"
188: #if FILE_TREE
189: #include "Path.h"
190: #endif
191: #define CMDNAME "bcp"
192: #include "abort.h"
193:
194: double atof(),sin(),cos();
195: char *strchr();
196:
197: /* Runtime options values */
198: static struct {
199: boolean from_bitfile; /* -Bi */
200: boolean to_bitfile; /* -Bo */
201: boolean to_bitmap; /* -M */
202: boolean to_g31; /* -g31 or -31 */
203: boolean to_g32; /* -g32 or -32 */
204: boolean to_g4; /* -g4 or -4 */
205: boolean to_rle; /* -r */
206: boolean to_bin; /* -b */
207: boolean to_pic; /* -p */
208: boolean to_post; /* -P */
209: boolean to_rast; /* -S */
210: boolean omit_hdr; /* -O */
211: Sp out_res; /* -R (-1 = unspecified; -2 = force-equal) */
212: Scoor shrinkwrap; /* -W (-1 = unspecified) */
213: Sp in_res; /* -Z (SHRT_MIN,SHRT_MIN = unspecified) */
214: int g32_k; /* -k */
215: int metheus; /* -m */
216: Sp offset; /* -o */
217: boolean dbg_any;
218: boolean dbg_R; /* -dR */
219: boolean dbg_c; /* -dc */
220: boolean dbg_h; /* -dh */
221: boolean dbg_m; /* -dm */
222: boolean dbg_r; /* -dr */
223: boolean dbg_s; /* -ds */
224: boolean show; /* -s */
225: char top; /* -tT takes on values: 't', 'l', 'r', 'b', 'a' */
226: float top_angle; /* -t angular value (set if top=='a') (Radians) */
227: int thresh; /* -Tt */
228: boolean reverse; /* -v */
229: char *optarg_l; /* -w?,,, */
230: char *optarg_t; /* -w,?,, */
231: char *optarg_r; /* -w,,?, */
232: char *optarg_b; /* -w,,,? */
233: Bbx trim; /* output margins resulting from -w */
234: Pp expand; /* -x */
235: char *in_fn;
236: char *out_fn;
237: } _O = {
238: F, F, F, F, F, T, F, F, F, F, F,
239: F, {-1,-1}, -1, {SHRT_MIN,SHRT_MIN}, 4, -1, Init_Zero_Sp,
240: F, F, F, F, F, F, F, F,
241: 't',0.0,
242: 128,
243: F,
244: NULL, NULL, NULL, NULL,
245: Init_Max_Bbx,
246: {1.0,1.0},
247: NULL, NULL };
248:
249: parse_args(arc,arv)
250: int arc; char **arv;
251: { /* getopt support */
252: int optch;
253: extern int optind;
254: extern char *optarg;
255:
256: char *metheus_ev,metheus_digit;
257: char *fs;
258:
259: /* default metheus number */
260: if((metheus_ev=(char *)getenv("FB"))!=NULL) {
261: metheus_digit = metheus_ev[(int)strlen(metheus_ev)-1];
262: if((int)isdigit(metheus_digit)) {
263: _O.metheus = (metheus_digit - '0');
264: };
265: };
266:
267: while((optch=getopt(arc,arv,"B:MOPR:ST:W:Z:3:4bd:g:k:m:o:prst:vw:x:"))!=EOF)
268: switch(optch) {
269: case 'B':
270: switch(*optarg) {
271: case 'o':
272: _O.to_bitfile = T;
273: _O.to_g4 = F;
274: break;
275: case 'i':
276: _O.from_bitfile = T;
277: break;
278: default:
279: abort("option -B%s is illegal",optarg);
280: break;
281: };
282: break;
283: case 'M': _O.to_bitmap = T; _O.to_g4 = F; break;
284: case 'O': _O.omit_hdr = T; break;
285: case 'P':
286: #if CPU==SUN
287: _O.to_post = T; _O.to_g4 = F;
288: #else
289: abort("-P option available only on Suns");
290: #endif
291: break;
292: case 'R':
293: if(*optarg=='=') {
294: _O.out_res.x = _O.out_res.y = -2;
295: fs=NULL;
296: }
297: else if((fs=strtok(optarg,","))!=NULL) {
298: if(strcmp(fs,"%")!=0) {
299: _O.out_res.x = atoi(fs);
300: };
301: };
302: if(fs!=NULL&&(fs=strtok((char *)0,","))!=NULL) {
303: if(strcmp(fs,"%")!=0) {
304: _O.out_res.y = atoi(fs);
305: };
306: }
307: else _O.out_res.y = _O.out_res.x;
308: break;
309: case 'S':
310: #if CPU==SUN
311: _O.to_rast = T; _O.to_g4 = F;
312: #else
313: abort("-S option available only on Suns");
314: #endif
315: break;
316: case 'T': _O.thresh=atoi(optarg); break;
317: case 'W': _O.shrinkwrap=atoi(optarg);
318: if(_O.shrinkwrap<0) {
319: err("-W%d must be >=0; force to -W0",
320: _O.shrinkwrap);
321: _O.shrinkwrap=0;
322: };
323: break;
324: case 'Z':
325: if((fs=strtok(optarg,","))!=NULL) {
326: if(strcmp(fs,"%")!=0) {
327: _O.in_res.x = atoi(fs);
328: };
329: };
330: if(fs!=NULL&&(fs=strtok((char *)0,","))!=NULL) {
331: if(strcmp(fs,"%")!=0) {
332: _O.in_res.y = atoi(fs);
333: };
334: }
335: else _O.in_res.y = _O.in_res.x;
336: break;
337: case '3':
338: switch (*optarg) {
339: case '1':
340: _O.to_g31=T;
341: _O.to_g4=F;
342: break;
343: case '2':
344: _O.to_g32=T;
345: _O.to_g4=F;
346: break;
347: default:
348: abort("bad option: -g3%s",optarg);
349: break;
350: };
351: break;
352: case '4': _O.to_g4=T; break;
353: case 'b':
354: _O.to_bin=T;
355: _O.to_g4=F;
356: break;
357: case 'd':
358: _O.dbg_any=T;
359: switch(*optarg) {
360: case 'R': _O.dbg_R = T; break;
361: case 'c': _O.dbg_c = T; break;
362: case 'h': _O.dbg_h = T; break;
363: case 'm': _O.dbg_m = T; break;
364: case 'r': _O.dbg_r = T; break;
365: case 's': _O.dbg_s = T; break;
366: };
367: break;
368: case 'g':
369: switch (optarg[0]) {
370: case '3':
371: switch (optarg[1]) {
372: case '1':
373: _O.to_g31=T;
374: _O.to_g4=F;
375: break;
376: case '2':
377: _O.to_g32=T;
378: _O.to_g4=F;
379: break;
380: default:
381: abort("bad option: -g%s",optarg);
382: break;
383: };
384: break;
385: case '4': _O.to_g4=T; break;
386: default:
387: abort("bad option: -g%s",optarg);
388: break;
389: };
390: break;
391: case 'k': _O.g32_k = atoi(optarg); break;
392: case 'm': _O.metheus = atoi(optarg); break;
393: case 'o':
394: if((fs=strtok(optarg,","))!=NULL) {
395: if(strcmp(fs,"%")!=0)
396: _O.offset.x = atoi(fs);
397: };
398: if(fs!=NULL&&(fs=strtok((char *)0,","))!=NULL) {
399: if(strcmp(fs,"%")!=0)
400: _O.offset.y = atoi(fs);
401: };
402: break;
403: case 'p':
404: _O.to_pic=T;
405: _O.to_g4=F;
406: break;
407: case 'r':
408: _O.to_rle = T;
409: _O.to_g4 = F;
410: break;
411: case 's': _O.show = T; break;
412: case 't': _O.top = *optarg;
413: if(strchr("0123456789.+-",_O.top)!=NULL) {
414: _O.top = 'a'; /* angular value */
415: _O.top_angle = atof(optarg)*DtoR;
416: };
417: break;
418: case 'v': _O.reverse = T; break;
419: case 'w':
420: if( (fs=strtok(optarg,","))!=NULL
421: && strlen(fs)>0 && strcmp(fs,"%")!=0 )
422: _O.optarg_l = strdup(fs);
423: if( fs!=NULL && (fs=strtok((char *)0,","))!=NULL
424: && strlen(fs)>0 && strcmp(fs,"%")!=0 )
425: _O.optarg_t = strdup(fs);
426: if( fs!=NULL && (fs=strtok((char *)0,","))!=NULL
427: && strlen(fs)>0 && strcmp(fs,"%")!=0 )
428: _O.optarg_r = strdup(fs);
429: if( fs!=NULL && (fs=strtok((char *)0,","))!=NULL
430: && strlen(fs)>0 && strcmp(fs,"%")!=0 )
431: _O.optarg_b = strdup(fs);
432: break;
433: case 'x':
434: if((fs=strtok(optarg,","))!=NULL) {
435: if(strcmp(fs,"%")!=0) {
436: if(*fs=='/')
437: _O.expand.x = 1.0/atof(fs+1);
438: else _O.expand.x = atof(fs);
439: if(_O.expand.x<=0.0)
440: _O.expand.x=1.0;
441: };
442: };
443: if(fs!=NULL&&(fs=strtok((char *)0,","))!=NULL) {
444: if(strcmp(fs,"%")!=0) {
445: if(*fs=='/')
446: _O.expand.y = 1.0/atof(fs+1);
447: else _O.expand.y = atof(fs);
448: if(_O.expand.y<=0.0)
449: _O.expand.y=1.0;
450: };
451: }
452: else _O.expand.y = _O.expand.x;
453: break;
454: default: break;
455: };
456: switch(arc-optind) {
457: case 2:
458: _O.out_fn = strdup(arv[optind+1]);
459: case 1:
460: _O.in_fn = strdup(arv[optind]);
461: case 0:
462: break;
463: default:
464: abort("<= two filenames expected");
465: break;
466: };
467: if(_O.show&&_O.metheus==-1) {
468: err("FB=/dev/omM not specified, using /dev/om0");
469: _O.metheus = 0;
470: };
471: }
472:
473: unimplemented()
474: { abort("unimplemented");
475: }
476:
477: typedef struct Copy_arg {
478: boolean bop; /* beginning of page */
479: PIC_hdr *ph;
480: int wid; /* bbx_wid(&(ph->bx)) (for speed) */
481: BITFILE *bf;
482: DST_table *tbl; /* for CCITT input */
483: int k; /* CCITT Group 3 2-D k */
484: int thresh; /* for input pic files */
485: RLE_Lines rles; /* for TYPE=document-image or TYPE=dim */
486: } Copy_arg;
487: #define Init_Copy_arg {T,NULL,INT_MIN,NULL,NULL,4,128,Init_RLE_Lines}
488: #if MAIN
489: Copy_arg empty_Copy_arg = Init_Copy_arg;
490: #else
491: extern Copy_arg empty_Copy_arg;
492: #endif
493:
494: /* SOURCES: return the next RLE_Line from the given file type, with run indices
495: shifted to lie within [ a->ph->bx.a.x, a->ph->bx.b.x ].
496: **** BUGS: not all handle non-zero a->ph->bx.a.x yet.
497: */
498:
499: /* Handles non-zero a->ph->bx.a.x. */
500: RLE_Line *cdf_mrlc_source(a)
501: Copy_arg *a;
502: #define dbg_cdf (0)
503: { static RLE_Line rl;
504: int n; /* no. pixels decoded */
505: int col; /* color: 0=white, 1=black */
506: int byte; /* input byte */
507: int nb; /* no. bytes read for this line */
508: int ni; /* nibble index: 0=1st (low-order), 1=2nd(high-order) */
509: int nib; /* current nibble */
510: int mult; /* multiplier for current nibble */
511: int run; /* no. pixels in current run */
512: RLE_Run *rp;
513: #define toggle_color() {if(col) col=0; else col=1;}
514: /* get next byte into `byte' */
515: #define getbyte() { \
516: if((byte=getc(a->ph->fp))==EOF) goto eof; nb++; \
517: if(dbg_cdf) err("byte0x%x",byte); \
518: }
519: /* get next nibble into `nib' */
520: #define getnib() { \
521: if(ni) { getbyte(); ni=0; nib=byte&0x0F; } \
522: else { ni=1; nib=(byte>>4); } \
523: if(dbg_cdf) err("nib0x%x byte0x%x ni%d",nib,byte,ni); \
524: }
525: /* get next run into `run' */
526: #define getrun() { \
527: run=0; mult=1; \
528: do {getnib(); run += mult * (nib&0x07); mult *= 8;} while(nib&0x08); \
529: if(dbg_cdf) err("run%d %c",run,((col)? 'B': 'W')); \
530: }
531: a->bop = F;
532: n=0; col=0; ni=1; nb=0; rp=rl.r;
533: do { getrun();
534: if(col) {/* black run */
535: if(run>0) { /* ... of >0 length */
536: rp->xs = a->ph->bx.a.x + n+1;
537: rp->xe = a->ph->bx.a.x + (n+=run);
538: if((rp-rl.r)>0 && ((rp-1)->xe >= rp->xs-1) ) {
539: if(_O.dbg_c) err("cdf_mrlc_source: abutting black runs [%d,%d] & [%d,%d] - merged",
540: (rp-1)->xs,(rp-1)->xe,
541: rp->xs,rp->xe );
542: /* merge with prior black run */
543: (rp-1)->xe = rp->xe;
544: }
545: else rp++;
546: }
547: else { /* zero-length black run */
548: if( _O.dbg_c && (rp-rl.r)>0 )
549: err("cdf_mrlc_source: zero-length black run [%d,%d] in middle of line - ignored",
550: n,n);
551: };
552: }
553: else { /* white run */
554: n+=run;
555: };
556: toggle_color();
557: }
558: while(n<a->wid);
559: /* read 2 EOL nibbles */
560: getnib(); getnib();
561: rl.runs = rp - rl.r;
562: rl.len = a->wid;
563: if(rl.runs>0 && rl.r[rl.runs-1].xe>=a->wid) {
564: if(_O.dbg_c)
565: err("cdf_mrlc_source: run [%d,%d] in line of length %d - truncated",
566: rl.r[rl.runs-1].xs,rl.r[rl.runs-1].xe,a->wid);
567: rl.r[rl.runs-1].xe = a->wid-1;
568: if(rl.r[rl.runs-1].xs>rl.r[rl.runs-1].xe) {
569: rl.runs--;
570: };
571: };
572: rl.y = a->ph->cy++;
573: if(_O.dbg_r) nerr_RLE_Line("cdf_source: ",&rl);
574: return(&rl);
575:
576: eof: if(dbg_cdf)
577: err("cdf_mrlc_source: unexpected EOF, input line %d",a->ph->cy);
578: return(NULL);
579: }
580:
581: int no_runs_of_page(p)
582: Page *p;
583: { int runs;
584: runs = 0;
585: runs += no_runs_of_blocks(&p->bks);
586: runs += no_runs_of_txtlns(&p->ls);
587: runs += no_runs_of_words(&p->ws);
588: runs += no_runs_of_chars(&p->cs);
589: runs += no_runs_of_blobs(&p->bs);
590: return(runs);
591: }
592:
593: int runs_of_page(p,ra,max)
594: Page *p;
595: RLE_Yrun *ra;
596: int max;
597: { int runs;
598: runs = 0;
599: runs += runs_of_blocks(&p->bks,ra,max);
600: runs += runs_of_txtlns(&p->ls,ra+runs,max-runs);
601: runs += runs_of_words(&p->ws,ra+runs,max-runs);
602: runs += runs_of_chars(&p->cs,ra+runs,max-runs);
603: runs += runs_of_blobs(&p->bs,ra+runs,max-runs);
604: return(runs);
605: }
606:
607: int no_runs_of_blocks(p)
608: Blocks *p;
609: { int runs;
610: Block *pp,**ppp;
611: runs = 0;
612: if(p->mny>0) for(pp= *(ppp=p->bpa); pp!=NULL; pp= *(++ppp))
613: runs += no_runs_of_block(pp);
614: return(runs);
615: }
616:
617: int runs_of_blocks(p,ra,max)
618: Blocks *p;
619: RLE_Yrun *ra;
620: int max;
621: { int runs;
622: Block *pp,**ppp;
623: runs = 0;
624: if(p->mny>0) for(pp= *(ppp=p->bpa); pp!=NULL; pp= *(++ppp))
625: runs += runs_of_block(pp,ra+runs,max-runs);
626: return(runs);
627: }
628:
629: int no_runs_of_block(p)
630: Block *p;
631: { int runs;
632: runs = 0;
633: runs += no_runs_of_txtlns(&p->ls);
634: runs += no_runs_of_words(&p->ws);
635: runs += no_runs_of_chars(&p->cs);
636: runs += no_runs_of_blobs(&p->bs);
637: return(runs);
638: }
639:
640: int runs_of_block(p,ra,max)
641: Block *p;
642: RLE_Yrun *ra;
643: int max;
644: { int runs;
645: runs = 0;
646: runs += runs_of_txtlns(&p->ls,ra+runs,max-runs);
647: runs += runs_of_words(&p->ws,ra+runs,max-runs);
648: runs += runs_of_chars(&p->cs,ra+runs,max-runs);
649: runs += runs_of_blobs(&p->bs,ra+runs,max-runs);
650: return(runs);
651: }
652:
653: int no_runs_of_txtlns(p)
654: Txtlns *p;
655: { int runs;
656: Txtln *pp,**ppp;
657: runs = 0;
658: if(p->mny>0) for(pp= *(ppp=p->lpa); pp!=NULL; pp= *(++ppp))
659: runs += no_runs_of_txtln(pp);
660: return(runs);
661: }
662:
663: int runs_of_txtlns(p,ra,max)
664: Txtlns *p;
665: RLE_Yrun *ra;
666: int max;
667: { int runs;
668: Txtln *pp,**ppp;
669: runs = 0;
670: if(p->mny>0) for(pp= *(ppp=p->lpa); pp!=NULL; pp= *(++ppp))
671: runs += runs_of_txtln(pp,ra+runs,max-runs);
672: return(runs);
673: }
674:
675: int no_runs_of_txtln(p)
676: Txtln *p;
677: { int runs;
678: runs = 0;
679: runs += no_runs_of_words(&p->ws);
680: runs += no_runs_of_chars(&p->cs);
681: runs += no_runs_of_blobs(&p->bs);
682: return(runs);
683: }
684:
685: int runs_of_txtln(p,ra,max)
686: Txtln *p;
687: RLE_Yrun *ra;
688: int max;
689: { int runs;
690: runs = 0;
691: runs += runs_of_words(&p->ws,ra+runs,max-runs);
692: runs += runs_of_chars(&p->cs,ra+runs,max-runs);
693: runs += runs_of_blobs(&p->bs,ra+runs,max-runs);
694: return(runs);
695: }
696:
697: int no_runs_of_words(p)
698: Words *p;
699: { int runs;
700: Word *pp,**ppp;
701: runs = 0;
702: if(p->mny>0) for(pp= *(ppp=p->wpa); pp!=NULL; pp= *(++ppp))
703: runs += no_runs_of_word(pp);
704: return(runs);
705: }
706:
707: int runs_of_words(p,ra,max)
708: Words *p;
709: RLE_Yrun *ra;
710: int max;
711: { int runs;
712: Word *pp,**ppp;
713: runs = 0;
714: if(p->mny>0) for(pp= *(ppp=p->wpa); pp!=NULL; pp= *(++ppp))
715: runs += runs_of_word(pp,ra+runs,max-runs);
716: return(runs);
717: }
718:
719: int no_runs_of_word(p)
720: Word *p;
721: { int runs;
722: runs = 0;
723: runs += no_runs_of_chars(&p->cs);
724: runs += no_runs_of_blobs(&p->bs);
725: return(runs);
726: }
727:
728: int runs_of_word(p,ra,max)
729: Word *p;
730: RLE_Yrun *ra;
731: int max;
732: { int runs;
733: runs = 0;
734: runs += runs_of_chars(&p->cs,ra+runs,max-runs);
735: runs += runs_of_blobs(&p->bs,ra+runs,max-runs);
736: return(runs);
737: }
738:
739: int no_runs_of_chars(p)
740: Chars *p;
741: { int runs;
742: Char *pp,**ppp;
743: runs = 0;
744: if(p->mny>0) for(pp= *(ppp=p->cpa); pp!=NULL; pp= *(++ppp))
745: runs += no_runs_of_char(pp);
746: return(runs);
747: }
748:
749: int runs_of_chars(p,ra,max)
750: Chars *p;
751: RLE_Yrun *ra;
752: int max;
753: { int runs;
754: Char *pp,**ppp;
755: runs = 0;
756: if(p->mny>0) for(pp= *(ppp=p->cpa); pp!=NULL; pp= *(++ppp))
757: runs += runs_of_char(pp,ra+runs,max-runs);
758: return(runs);
759: }
760:
761: int no_runs_of_blobs(p)
762: Blobs *p;
763: { int runs;
764: Blob *pp,**ppp;
765: runs = 0;
766: if(p->mny>0) for(pp= *(ppp=p->bpa); pp!=NULL; pp= *(++ppp))
767: runs += pp->runs;
768: return(runs);
769: }
770:
771: int runs_of_blobs(p,ra,max)
772: Blobs *p;
773: RLE_Yrun *ra;
774: int max;
775: { int runs;
776: Blob *pp,**ppp;
777: runs = 0;
778: if(p->mny>0) for(pp= *(ppp=p->bpa); pp!=NULL; pp= *(++ppp))
779: runs += runs_of_blob(pp,ra+runs,max-runs);
780: return(runs);
781: }
782:
783: /* ascending lexicographic order on y,xs */
784: int local_rn_asc(r1,r2)
785: RLE_Yrun *r1,*r2;
786: { if(r1->y < r2->y) return(-1);
787: else if(r1->y==r2->y) {
788: if(r1->xs < r2->xs) return(-1);
789: else if (r1->xs == r2->xs) return(0);
790: else return(1);
791: }
792: else return(1);
793: }
794:
795: RLE_Lines *rle_lines_of_page(pgp)
796: Page *pgp;
797: { static RLE_Lines rls;
798: int no_runs,cy,ri;
799: RLE_Yrun *ra,*cr;
800: RLE_Run *lr;
801: RLE_Line *cl;
802: /* count runs */
803: no_runs = no_runs_of_page(pgp);
804: if(_O.dbg_r) err("no_runs %d",no_runs);
805: /* allocate runs array */
806: if((ra=(RLE_Yrun *)malloc(no_runs*sizeof(RLE_Yrun)))==NULL)
807: abort("rle_lines_of_page: can't malloc ra[%d]",no_runs);
808: runs_of_page(pgp,ra,no_runs);
809: /* sort runs ascending on (y,xs) */
810: qsort(ra,no_runs,sizeof(RLE_Yrun),local_rn_asc);
811: /* count RLE_lines.mny */
812: rls.mny = 0; cy=INT_MIN;
813: for(ri=0,cr=ra; ri<no_runs; ri++,cr++)
814: if(cr->y!=cy) {
815: rls.mny++;
816: cy = cr->y;
817: };
818: /* allocate RLE_lines */
819: if((rls.rla=(RLE_Line *)malloc(rls.mny*sizeof(RLE_Line)))==NULL)
820: abort("rle_lines_of_page: can't malloc rls.rla[%d]",rls.mny);
821: /* fill in RLE_lines */
822: cy=INT_MIN; cl=rls.rla-1;
823: for(ri=0,cr=ra; ri<no_runs; ri++,cr++) {
824: if(cr->y!=cy) {
825: cl++;
826: cl->y = cy = cr->y;
827: cl->runs = 0;
828: lr = cl->r;
829: };
830: lr->xs = cr->xs; lr->xe = cr->xe; lr++; cl->runs++;
831: };
832: free(ra);
833: return(&rls);
834: }
835:
836: Bbx *bbx_of_rle_lines(rlsp)
837: RLE_Lines *rlsp;
838: { static Bbx res;
839: Bbx r;
840: int li,ri;
841: RLE_Line *lp;
842: RLE_Run *rp;
843: res = empty_Bbx;
844: for(li=0,lp=rlsp->rla; li<rlsp->mny; li++,lp++) {
845: r.a.y = r.b.y = lp->y;
846: for(ri=0,rp=lp->r; ri<lp->runs; ri++,rp++) {
847: r.a.x = rp->xs;
848: r.b.x = rp->xe;
849: merge_bbx(&r,&res);
850: };
851: };
852: return(&res);
853: }
854:
855: translate_rle_lines(r,p)
856: RLE_Lines *r;
857: Sp p;
858: { int li,ri;
859: RLE_Line *lp;
860: RLE_Run *rp;
861: for(li=0,lp=r->rla; li<r->mny; li++,lp++) {
862: lp->y += p.y;
863: for(ri=0,rp=lp->r; ri<lp->runs; ri++,rp++) {
864: rp->xs += p.x;
865: rp->xe += p.x;
866: };
867: };
868: }
869:
870: RLE_Line *binary_source(a)
871: Copy_arg *a;
872: { static RLE_Line rl;
873: unsigned char *inline;
874: a->bop = F;
875: if(PIC_rline(a->ph,&inline)==1) {
876: rl.runs =
877: rlbr(inline,0,a->ph->bx.b.x-a->ph->bx.a.x,a->ph->bx.a.x,rl.r);
878: rl.y = a->ph->cy;
879: rl.len = a->wid;
880: if(_O.dbg_r) nerr_RLE_Line("binary_source: ",&rl);
881: return(&rl);
882: }
883: else { if(_O.dbg_r) nerr_RLE_Line("binary_source: ",NULL);
884: return(NULL);
885: };
886: }
887:
888: RLE_Line *bitmap_source(a)
889: Copy_arg *a;
890: { static RLE_Line rl;
891: unsigned char *inline;
892: register unsigned char *cp,*ep,*rb;
893: a->bop = F;
894: if(PIC_rline(a->ph,&inline)==1) {
895: /* reverse bit order in each byte */
896: rb=bm_consts.Rbits;
897: ep=(cp=inline)+a->ph->bpl;
898: while(cp<ep) { *cp = rb[*cp]; cp++; };
899: rl.runs =
900: rlbr(inline,0,a->ph->bx.b.x-a->ph->bx.a.x,a->ph->bx.a.x,rl.r);
901: rl.y = a->ph->cy;
902: rl.len = a->wid;
903: if(_O.dbg_r) nerr_RLE_Line("bitmap_source: ",&rl);
904: return(&rl);
905: }
906: else { if(_O.dbg_r) nerr_RLE_Line("binary_source: ",NULL);
907: return(NULL);
908: };
909: }
910:
911: RLE_Line *bitfile_source(a)
912: Copy_arg *a;
913: #define dbg_Bi (F)
914: { static RLE_Line rl;
915: unsigned char *cp,*ep,*pp;
916: int ch,ci;
917: a->bop = F;
918: /* copy current line to prior */
919: memcpy(a->ph->pline,a->ph->line,a->ph->bpl);
920: /* read one binary raster line */
921: ep=(cp=a->ph->line)+a->ph->bpl;
922: while(cp<ep) {
923: if((ch=getc(a->ph->fp))!=EOF) {
924: if(ch<127) {
925: if(dbg_Bi) err("cb: %o",ch);
926: if((fread(cp,1,2*ch,a->ph->fp))==2*ch) {
927: cp += 2*ch;
928: }
929: else return(NULL);
930: }
931: else { ch &= 0x7F;
932: if(dbg_Bi) err("cb: 0200+%o",ch);
933: if((fread(cp,1,2,a->ph->fp))==2) {
934: cp += 2;
935: for(ci=0;ci<ch-1;ci++,cp+=2) {
936: *cp = *(cp-2);
937: *(cp+1) = *(cp-1);
938: };
939: }
940: else return(NULL);
941: };
942: }
943: else return(NULL);
944: };
945: /* reverse bit-order, & xor with prior line */
946: for(ep=(cp=a->ph->line)+a->ph->bpl,pp=a->ph->pline; cp<ep; cp++,pp++) {
947: *cp = bm_consts.Rbits[*cp] ^ *pp;
948: if(dbg_Bi) err("db: %o = ?? ^ %o",*cp,*pp);
949: };
950: rl.runs =
951: rlbr(a->ph->line,0,a->ph->bx.b.x-a->ph->bx.a.x,a->ph->bx.a.x,rl.r);
952: rl.y = ++a->ph->cy;
953: rl.len = a->wid;
954: if(_O.dbg_r) nerr_RLE_Line("bitfile_source: ",&rl);
955: return(&rl);
956: }
957:
958: RLE_Line *dim_source(a)
959: Copy_arg *a;
960: { static RLE_Line *rlp,*rlq,rl;
961: if(a->bop) {
962: a->ph->cy = a->ph->bx.a.y-1;
963: rlq=(rlp=a->rles.rla)+a->rles.mny;
964: };
965: if(_O.dbg_r) {
966: err("dim_source: a->bop %d a->ph->cy %d",a->bop,a->ph->cy);
967: nerr_RLE_Line("*rlp",rlp);
968: };
969: a->bop = F;
970: a->ph->cy++;
971: if(rlp<rlq) {
972: if(a->ph->cy < rlp->y) {
973: rl.y = a->ph->cy;
974: rl.runs = 0;
975: rl.len = a->wid;
976: if(_O.dbg_r) nerr_RLE_Line("dim_source: ",&rl);
977: return(&rl);
978: }
979: else if(a->ph->cy == rlp->y) {
980: rlp->len = a->wid;
981: rlp++;
982: if(_O.dbg_r) nerr_RLE_Line("dim_source: ",rlp-1);
983: return(rlp-1);
984: }
985: else { while(rlp<rlq && a->ph->cy>rlp->y) rlp++;
986: if(rlp>=rlq) {
987: if(_O.dbg_r) nerr_RLE_Line("dim_source: NULL");
988: return(NULL);
989: }
990: else { rlp->len = a->wid;
991: rlp++;
992: if(_O.dbg_r) nerr_RLE_Line("dim_source: ",rlp-1);
993: return(rlp-1);
994: };
995: };
996: }
997: else { if(_O.dbg_r) nerr_RLE_Line("dim_source: NULL");
998: return(NULL);
999: };
1000: }
1001:
1002: RLE_Line *rle_source(a)
1003: Copy_arg *a;
1004: { static RLE_Line *rl;
1005: a->bop = F;
1006: if((rl=RLE_get_Line(a->ph->bx.a.x,a->ph->bx.b.x))!=NULL) {
1007: a->ph->cy = rl->y;
1008: rl->len = a->wid;
1009: if(_O.dbg_r) nerr_RLE_Line("rle_source: ",rl);
1010: return(rl);
1011: }
1012: else { if(_O.dbg_r) nerr_RLE_Line("rle_source: ",NULL);
1013: return(NULL);
1014: };
1015: }
1016:
1017: /* Read next line of runs from pic file, with runs shifted to lie in the range
1018: [ a->ph->bx.a.x, a->ph->bx.b.x ]. */
1019: RLE_Line *pic_source(a)
1020: Copy_arg *a;
1021: { static RLE_Line rl;
1022: unsigned char *inline;
1023: a->bop = F;
1024: if(PIC_rline(a->ph,&inline)==1) {
1025: rl.runs = trcr(inline,
1026: 0,a->ph->bx.b.x-a->ph->bx.a.x,a->ph->bx.a.x,
1027: a->thresh,rl.r);
1028: rl.y = a->ph->cy;
1029: rl.len = a->wid;
1030: if(_O.dbg_r) nerr_RLE_Line("pic_source: ",&rl);
1031: return(&rl);
1032: }
1033: else { if(_O.dbg_r) nerr_RLE_Line("pic_source: ",NULL);
1034: return(NULL);
1035: };
1036: }
1037:
1038: /* Read next line of runs from g31 file, with runs shifted to lie in the range
1039: [ a->ph->bx.a.x, a->ph->bx.b.x ]. */
1040: RLE_Line *g31_source(a)
1041: Copy_arg *a;
1042: { static RLE_Line *rlp,rl;
1043: RLE_Run *rp,*ep,*np;
1044: if((rlp=g31_to_rlel(a->tbl,a->bf,a->bop))!=NULL) {
1045: a->bop = F;
1046: rlp->y = ++a->ph->cy;
1047: rlp->len = a->wid;
1048: if(a->ph->bx.a.x!=0) {
1049: /* must shift run indices */
1050: rl.y = rlp->y;
1051: rl.len = rlp->len;
1052: if((rl.runs=rlp->runs)>0) {
1053: for(ep=(rp=rlp->r)+rlp->runs,np=rl.r; rp<ep; rp++,np++ ) {
1054: np->xs = rp->xs + a->ph->bx.a.x;
1055: np->xe = rp->xe + a->ph->bx.a.x;
1056: };
1057: };
1058: if(_O.dbg_r) nerr_RLE_Line("g31_source: ",&rl);
1059: return(&rl);
1060: }
1061: else { if(_O.dbg_r) nerr_RLE_Line("g31_source: ",rlp);
1062: return(rlp);
1063: };
1064: }
1065: else { if(_O.dbg_r) nerr_RLE_Line("g31_source: ",NULL);
1066: return(NULL);
1067: };
1068: }
1069:
1070: /* Read next line of runs from g32 file, with runs shifted to lie in the range
1071: [ a->ph->bx.a.x, a->ph->bx.b.x ]. */
1072: RLE_Line *g32_source(a)
1073: Copy_arg *a;
1074: { static RLE_Line *rlp,rl;
1075: RLE_Run *rp,*ep,*np;
1076: if((rlp=g32_to_rlel(a->tbl,a->bf,a->bop))!=NULL) {
1077: a->bop = F;
1078: rlp->y = ++a->ph->cy;
1079: rlp->len = a->wid;
1080: if(a->ph->bx.a.x!=0) {
1081: /* must shift run indices */
1082: if(_O.dbg_r) err("g32_source: shift +%d",a->ph->bx.a.x);
1083: rl.y = rlp->y;
1084: rl.len = rlp->len;
1085: if((rl.runs=rlp->runs)>0) {
1086: for(ep=(rp=rlp->r)+rlp->runs,np=rl.r; rp<ep; rp++,np++ ) {
1087: np->xs = rp->xs + a->ph->bx.a.x;
1088: np->xe = rp->xe + a->ph->bx.a.x;
1089: };
1090: };
1091: if(_O.dbg_r) nerr_RLE_Line("g32_source: ",&rl);
1092: return(&rl);
1093: }
1094: else { if(_O.dbg_r) nerr_RLE_Line("g32_source: ",rlp);
1095: return(rlp);
1096: };
1097: }
1098: else { if(_O.dbg_r) nerr_RLE_Line("g32_source: ",NULL);
1099: return(NULL);
1100: };
1101: }
1102:
1103: /* Read next line of runs from g4 file, after shifting runs to lie in the range
1104: [ a->ph->bx.a.x, a->ph->bx.b.x ]. */
1105: RLE_Line *g4_source(a)
1106: Copy_arg *a;
1107: { static RLE_Line *rlp,rl;
1108: RLE_Run *rp,*ep,*np;
1109: if((rlp=g4_to_rlel(a->tbl,a->bf,a->bop,a->wid))!=NULL) {
1110: a->bop = F;
1111: rlp->y = ++a->ph->cy;
1112: rlp->len = a->wid;
1113: if(a->ph->bx.a.x!=0) { /* shift runs */
1114: rl.y = rlp->y;
1115: rl.len = rlp->len;
1116: if((rl.runs=rlp->runs)>0) {
1117: for(ep=(rp=rlp->r)+rlp->runs,np=rl.r; rp<ep; rp++,np++ ) {
1118: np->xs = rp->xs + a->ph->bx.a.x;
1119: np->xe = rp->xe + a->ph->bx.a.x;
1120: };
1121: };
1122: if(_O.dbg_r) nerr_RLE_Line("g4_source: ",&rl);
1123: return(&rl);
1124: }
1125: else { if(_O.dbg_r) nerr_RLE_Line("g4_source: ",rlp);
1126: return(rlp);
1127: };
1128: }
1129: else { a->bop = F;
1130: if(_O.dbg_r) nerr_RLE_Line("g4_source: ",NULL);
1131: return(NULL);
1132: };
1133: }
1134:
1135: binary_sink(rl,a)
1136: RLE_Line *rl;
1137: Copy_arg *a;
1138: { int stat;
1139: if(_O.dbg_r) nerr_RLE_Line("binary_sink: ",rl);
1140: if(a->bop) { PIC_put_hdr(a->ph); a->bop=F; }
1141: if(rl!=NULL) {
1142: memset(a->ph->line,'\0',a->ph->bpl);
1143: if(rl->runs>0) {
1144: /* convert *rl to binary, using ``little-endian'' bit-order */
1145: brrl(rl->runs,rl->r,a->ph->bx.a.x,a->ph->bx.b.x,0,a->ph->line);
1146: };
1147: if((stat=PIC_wline(a->ph,a->ph->line))!=1)
1148: abort("binary_sink: can't write: stat %d",stat);
1149: };
1150: return(1);
1151: }
1152:
1153: bitmap_sink(rl,a)
1154: RLE_Line *rl;
1155: Copy_arg *a;
1156: { int stat;
1157: if(_O.dbg_r) nerr_RLE_Line("bitmap_sink: ",rl);
1158: if(a->bop) { PIC_put_hdr(a->ph); a->bop=F; }
1159: if(rl!=NULL) {
1160: memset(a->ph->line,'\0',a->ph->bpl);
1161: if(rl->runs>0) {
1162: /* convert *rl to binary, using ``big-endian'' bit-order */
1163: brrlb(rl->runs,rl->r,a->ph->bx.a.x,a->ph->bx.b.x,0,a->ph->line);
1164: };
1165: if((stat=PIC_wline(a->ph,a->ph->line))!=1)
1166: abort("bitmap_sink: can't write: stat %d",stat);
1167: };
1168: return(1);
1169: }
1170:
1171: /* Write bitfile(9.5) format */
1172: bitfile_sink(rl,a)
1173: RLE_Line *rl;
1174: Copy_arg *a;
1175: #define dbg_Bo (F)
1176: { int stat;
1177: int ci,towrite;
1178: register unsigned char uc,*cp,*pp,*ep;
1179: if(_O.dbg_r||dbg_Bo) nerr_RLE_Line("bitfile_sink: ",rl);
1180: if(a->bop) { PIC_put_hdr(a->ph); a->bop=F; }
1181: if(rl!=NULL) {
1182: /* copy current to prior */
1183: memcpy(a->ph->pline,a->ph->line,a->ph->bpl);
1184: memset(a->ph->line,'\0',a->ph->bpl);
1185: if(rl->runs>0) {
1186: /* convert *rl to binary, using ``big-endian'' bit-order */
1187: brrlb(rl->runs,rl->r,
1188: a->ph->bx.a.x,a->ph->bx.b.x,
1189: 0,a->ph->line);
1190: if(dbg_Bo) {
1191: unsigned char *cb,*eb;
1192: fprintf(stderr,"a->ph->line: ");
1193: for(eb=(cb=a->ph->line)+a->ph->bpl;cb<eb;cb++)
1194: fprintf(stderr,"%02X",*cb);
1195: fprintf(stderr,"\n");
1196: };
1197: };
1198: /* break up output into blocks of 2*126 bytes;
1199: SHOULD also try run-length coding */
1200: ci=0; while((towrite=a->ph->bpl-ci) > 0) {
1201: if(towrite >= 2*127) towrite=2*126;
1202: /* write control byte for block */
1203: uc = towrite/2;
1204: if(dbg_Bo) err("cb: %02X",uc);
1205: putc(uc,a->ph->fp);
1206: for(ep=(cp=a->ph->line+ci)+towrite,pp=a->ph->pline+ci;
1207: cp<ep; cp++,pp++) {
1208: /* write XOR byte */
1209: uc = *cp ^ *pp;
1210: if(dbg_Bo) err("db %d: %02X = c%02X ^ p%02X",cp-a->ph->line,uc,*cp,*pp);
1211: putc(uc,a->ph->fp);
1212: };
1213: ci += towrite;
1214: };
1215: }
1216: else { free(a->ph->line); a->ph->line=NULL;
1217: free(a->ph->pline); a->ph->pline=NULL;
1218: fflush(a->ph->fp);
1219: };
1220: }
1221:
1222: rle_sink(rl,a)
1223: RLE_Line *rl;
1224: Copy_arg *a;
1225: { if(_O.dbg_r) nerr_RLE_Line("rle_sink: ",rl);
1226: if(a->bop) {
1227: RIC_hdr rh;
1228: rh.bx = a->ph->bx;
1229: rh.res_x = a->ph->res_x;
1230: rh.res_y = a->ph->res_y;
1231: RLE_put_hdr(fileno(a->ph->fp),&rh,1);
1232: a->ph->cy = a->ph->bx.a.y-1;
1233: a->bop=F;
1234: };
1235: if(rl!=NULL) {
1236: if(rl->runs>0) RLE_put_Line(fileno(a->ph->fp),rl);
1237: a->ph->cy++;
1238: }
1239: else RLE_close(fileno(a->ph->fp));
1240: return(1);
1241: }
1242:
1243: /* Write next line of runs to g31 file, after shifting runs to lie in the range
1244: [ 0, a->ph->bx.b.x - a->ph->bx.a.x ]. */
1245: g31_sink(rl,a)
1246: RLE_Line *rl;
1247: Copy_arg *a;
1248: { int stat;
1249: RLE_Line crl;
1250: RLE_Run *rp,*ep,*np;
1251: if(_O.dbg_r) nerr_RLE_Line("g31_sink: ",rl);
1252: if(a->bop) {
1253: PIC_put_hdr(a->ph);
1254: /* treat FILE *a->ph->fp as a sequence of bits */
1255: if((a->bf=bopen(a->ph->fp,"w"))==NULL)
1256: abort("g31_sink: can't open bitfile");
1257: BOF_to_g31(a->bf);
1258: a->bop=F;
1259: };
1260: if(rl!=NULL) {
1261: /* check that rl->len is consistent with a->ph */
1262: if(rl->len != a->ph->bx.b.x - a->ph->bx.a.x + 1) {
1263: err("g31_sink: rl->len %d != wid(a->ph.bx) %d",
1264: rl->len, a->ph->bx.b.x - a->ph->bx.a.x + 1);
1265: rl->len = a->ph->bx.b.x - a->ph->bx.a.x + 1;
1266: };
1267: if(rl->runs>0) {
1268: if(a->ph->bx.a.x!=0) { /* shift runs */
1269: crl.y = rl->y;
1270: crl.len = rl->len;
1271: crl.runs = rl->runs;
1272: for(ep=(rp=rl->r)+rl->runs,np=crl.r;
1273: rp<ep;
1274: rp++,np++) {
1275: np->xs = rp->xs - a->ph->bx.a.x;
1276: np->xe = rp->xe - a->ph->bx.a.x;
1277: };
1278: rlel_to_g31(&crl,crl.len,a->bf);
1279: }
1280: else rlel_to_g31(rl,rl->len,a->bf);
1281: }
1282: else rlel_to_g31(NULL,rl->len,a->bf);
1283: a->ph->cy++;
1284: }
1285: else { EOF_to_g31(a->bf);
1286: bclose(a->bf);
1287: };
1288: return(1);
1289: }
1290:
1291: /* Write next line of runs to g32 file, after shifting runs to lie in the range
1292: [ 0, a->ph->bx.b.x - a->ph->bx.a.x ]. */
1293: g32_sink(rl,a)
1294: RLE_Line *rl;
1295: Copy_arg *a;
1296: { static RLE_Line prl;
1297: RLE_Line *pl;
1298: RLE_Line crl;
1299: RLE_Run *rp,*ep,*np;
1300: if(_O.dbg_r) nerr_RLE_Line("g32_sink: ",rl);
1301: if(a->bop) {
1302: PIC_put_hdr(a->ph);
1303: /* treat FILE *a->ph->fp as a sequence of bits */
1304: if((a->bf=bopen(a->ph->fp,"w"))==NULL)
1305: abort("can't open bitfile");
1306: BOF_to_g32(a->bf);
1307: a->bop=F;
1308: prl.runs = 0;
1309: };
1310: if(rl!=NULL) {
1311: /* check that rl->len is consistent with a->ph */
1312: if(rl->len != a->ph->bx.b.x - a->ph->bx.a.x + 1) {
1313: err("g32_sink: rl->len %d != wid(a->ph.bx) %d",
1314: rl->len, a->ph->bx.b.x - a->ph->bx.a.x + 1);
1315: rl->len = a->ph->bx.b.x - a->ph->bx.a.x + 1;
1316: };
1317: prl.len = rl->len;
1318: prl.y = rl->y - 1;
1319: if(((a->ph->cy+1-a->ph->bx.a.y)%a->k)==0) pl=NULL; else pl=&prl;
1320: if(rl->runs>0) {
1321: if(a->ph->bx.a.x!=0) { /* shift runs */
1322: crl.y = rl->y;
1323: crl.len = rl->len;
1324: crl.runs = rl->runs;
1325: for(ep=(rp=rl->r)+rl->runs,np=crl.r;
1326: rp<ep;
1327: rp++,np++) {
1328: np->xs = rp->xs - a->ph->bx.a.x;
1329: np->xe = rp->xe - a->ph->bx.a.x;
1330: };
1331: rlel_to_g32(pl,&crl,crl.len,a->bf);
1332: prl.y=crl.y;
1333: prl.len=crl.len;
1334: prl.runs=crl.runs;
1335: memcpy(prl.r,crl.r,2*prl.runs*sizeof(short));
1336: }
1337: else { rlel_to_g32(pl,rl,rl->len,a->bf);
1338: prl.y=rl->y;
1339: prl.len=rl->len;
1340: prl.runs=rl->runs;
1341: memcpy(prl.r,rl->r,2*prl.runs*sizeof(short));
1342: };
1343: }
1344: else { rlel_to_g32(pl,NULL,rl->len,a->bf);
1345: prl.y=rl->y;
1346: prl.len=rl->len;
1347: prl.runs=0;
1348: }
1349: a->ph->cy++;
1350: }
1351: else { EOF_to_g32(a->bf);
1352: bclose(a->bf);
1353: prl.runs = 0;
1354: };
1355: return(1);
1356: }
1357:
1358: /* Write next line of runs to g4 file, after shifting runs to lie in the range
1359: [ 0, a->ph->bx.b.x - a->ph->bx.a.x ]. */
1360: g4_sink(rl,a)
1361: RLE_Line *rl;
1362: Copy_arg *a;
1363: { static RLE_Line prl;
1364: RLE_Line crl;
1365: RLE_Run *rp,*ep,*np;
1366: if(_O.dbg_r) nerr_RLE_Line("g4_sink: ",rl);
1367: if(a->bop) {
1368: PIC_put_hdr(a->ph);
1369: /* treat FILE *a->ph->fp as a sequence of bits */
1370: if((a->bf=bopen(a->ph->fp,"w"))==NULL)
1371: abort("can't open bitfile");
1372: BOF_to_g4(a->bf);
1373: a->bop=F;
1374: prl.runs = 0;
1375: };
1376: if(rl!=NULL) {
1377: /* check that rl->len is consistent with a->ph */
1378: if(rl->len != a->ph->bx.b.x - a->ph->bx.a.x + 1) {
1379: err("g4_sink: rl->len %d != wid(a->ph.bx) %d",
1380: rl->len, a->ph->bx.b.x - a->ph->bx.a.x + 1);
1381: rl->len = a->ph->bx.b.x - a->ph->bx.a.x + 1;
1382: };
1383: if(rl->runs>0) {
1384: if(a->ph->bx.a.x!=0) { /* shift runs */
1385: crl.y = rl->y;
1386: crl.len = rl->len;
1387: crl.runs = rl->runs;
1388: for(ep=(rp=rl->r)+rl->runs,np=crl.r;
1389: rp<ep;
1390: rp++,np++) {
1391: np->xs = rp->xs - a->ph->bx.a.x;
1392: np->xe = rp->xe - a->ph->bx.a.x;
1393: };
1394: rlel_to_g4(&prl,&crl,crl.len,a->bf);
1395: prl.y=crl.y;
1396: prl.len=crl.len;
1397: prl.runs=crl.runs;
1398: memcpy(prl.r,crl.r,2*prl.runs*sizeof(short));
1399: }
1400: else { rlel_to_g4(&prl,rl,rl->len,a->bf);
1401: prl.y=rl->y;
1402: prl.len=rl->len;
1403: prl.runs=rl->runs;
1404: memcpy(prl.r,rl->r,2*prl.runs*sizeof(short));
1405: };
1406: }
1407: else { rlel_to_g4(&prl,NULL,rl->len,a->bf);
1408: prl.runs=0;
1409: }
1410: a->ph->cy++;
1411: }
1412: else { EOF_to_g4(a->bf);
1413: bclose(a->bf);
1414: prl.runs = 0;
1415: };
1416: return(1);
1417: }
1418:
1419: pic_sink(rl,a)
1420: RLE_Line *rl;
1421: Copy_arg *a;
1422: { int stat;
1423: if(_O.dbg_r) nerr_RLE_Line("pic_sink: ",rl);
1424: if(a->bop) {
1425: PIC_put_hdr(a->ph);
1426: a->bop=F;
1427: };
1428: if(rl!=NULL) {
1429: crrl(rl->runs,rl->r,0,a->ph->bx.b.x-a->ph->bx.a.x,a->ph->line);
1430: if((stat=PIC_wline(a->ph,a->ph->line))!=1)
1431: abort("pic_sink: can't write: stat %d",stat);
1432: };
1433: return(1);
1434: }
1435:
1436: #if CPU==SUN
1437: post_sink(rl,a)
1438: RLE_Line *rl;
1439: Copy_arg *a;
1440: { int stat;
1441: if(_O.dbg_r) nerr_RLE_Line("post_sink: ",rl);
1442: if (a->bop) {
1443: PIC_put_hdr(a->ph); /* needed for allocation of h->line? */
1444: POST_start(a->ph);
1445: a->bop = F;
1446: };
1447: if(rl!=NULL) {
1448: memset(a->ph->line,'\0',a->ph->bpl);
1449: if(rl->runs>0) {
1450: /* convert *rl to binary, using ``little-endian'' bit-order */
1451: brrl(rl->runs,rl->r,a->ph->bx.a.x,a->ph->bx.b.x,0,a->ph->line);
1452: };
1453: if((stat=POST_wline(a->ph,a->ph->line))!=1)
1454: abort("post_sink: can't write: stat %d",stat);
1455: }
1456: else { POST_end();
1457: };
1458: return(1);
1459: }
1460: #else
1461: post_sink() {abort("-P postscript output unimplemented");};
1462: #endif
1463:
1464: #if CPU==SUN
1465: rast_sink(rl,a)
1466: RLE_Line *rl;
1467: Copy_arg *a;
1468: { int stat;
1469: if(_O.dbg_r) nerr_RLE_Line("rast_sink: ",rl);
1470: if (a->bop) {
1471: PIC_put_hdr(a->ph); /* needed for allocation of h->line? */
1472: RAST_start(a->ph);
1473: a->bop = F;
1474: };
1475: if(rl!=NULL) {
1476: memset(a->ph->line,'\0',a->ph->bpl);
1477: if(rl->runs>0) {
1478: /* convert *rl to binary, using ``little-endian'' bit-order */
1479: brrl(rl->runs,rl->r,a->ph->bx.a.x,a->ph->bx.b.x,0,a->ph->line);
1480: };
1481: if((stat=RAST_wline(a->ph,a->ph->line))!=1)
1482: abort("rast_sink: can't write: stat %d",stat);
1483: }
1484: else { RAST_end();
1485: };
1486: return(1);
1487: }
1488: #else
1489: rast_sink() {abort("-S sunraster output unimplemented");};
1490: #endif
1491:
1492: /* Save RLE_Line *rl in buffer, as packed binary, using ``little-endian''
1493: bit-packing order, rounding each line to the nearest int for speed.
1494: If a->bop, malloc a complete, contiguous buffer holding the entire page,
1495: and initialize its contents to zeroes.
1496: On each call with rl!=NULL, convert the given line to binary & save in buffer.
1497: When called with rl==NULL but a!=NULL, signalling end-of-page, do nothing.
1498: Normally, return kludgey (unsigned int *)1, like other sink functions.
1499: When called with rl==NULL && a==NULL, return pointer to buffer.
1500: It is the responsibility of the calling code to free the buffer. */
1501: unsigned int *binary_buffer(rl,a)
1502: RLE_Line *rl;
1503: Copy_arg *a;
1504: { static unsigned int *buf = NULL;
1505: static int ipl = 0; /* ints/line */
1506: int bufsz; /* (bytes) */
1507: unsigned int *result;
1508: #define BITS_PER_INT (8*sizeof(int))
1509: if(a!=NULL && a->bop) {
1510: /* round up to int boundary */
1511: ipl = (bbx_wid(&(a->ph->bx))+BITS_PER_INT-1)/BITS_PER_INT;
1512: bufsz = sizeof(int)*ipl*bbx_hgt(&(a->ph->bx));
1513: if((buf=(unsigned int *)malloc(bufsz))==NULL)
1514: abort("binary_buffer: can't alloc int buf[%d]",bufsz/sizeof(int));
1515: memset(buf,'\0',bufsz);
1516: a->bop=F;
1517: };
1518: if(rl!=NULL) {
1519: /* convert *rl to binary, using ``little-endian'' bit-order */
1520: if(rl->runs>0) {
1521: /* *rl --> binary, with ``little-endian'' bit-order */
1522: #if BIG_ENDIAN
1523: brrlb( rl->runs, rl->r, a->ph->bx.a.x, a->ph->bx.b.x,
1524: 0, buf+(ipl*(rl->y-a->ph->bx.a.y)) );
1525: #else
1526: brrl( rl->runs, rl->r, a->ph->bx.a.x, a->ph->bx.b.x,
1527: 0, buf+(ipl*(rl->y-a->ph->bx.a.y)) );
1528: #endif
1529: };
1530: return((unsigned int *)1);
1531: }
1532: else { if(a!=NULL) return((unsigned int *)1);
1533: else { result = buf;
1534: buf = NULL; ipl = 0;
1535: return(result);
1536: };
1537: };
1538: }
1539:
1540: /* Rotate binary buffer *buf (whose shape is specified by a->ph->bx),
1541: through angle tra->rot, and write the resulting stream of RLE_Line's to
1542: sink() one at a time, along with a rotated version of *a as the 2nd argument.
1543: Only PI/2 is supported; UNDER DEVELOPMENT: other multiples of PI/2 and
1544: small arbitrary angles. */
1545: rotate_binary_buffer(buf,tra,sink,a)
1546: unsigned int *buf;
1547: Transform_rlel_arg *tra;
1548: int (*sink)(); /* takes args: (RLE_Line *), and int */
1549: Copy_arg *a;
1550: { register int ipl; /* ints/line in binary buffer */
1551: Copy_arg ra; /* rotated */
1552: RLE_Line rl;
1553: #define TINY_ANG (PI/1000)
1554: /* round up to int boundary */
1555: ipl = (bbx_wid(&(a->ph->bx))+BITS_PER_INT-1)/BITS_PER_INT;
1556: ra = *a;
1557: ra.bop=T;
1558: if((ra.ph = (PIC_hdr *)malloc(sizeof(PIC_hdr)))==NULL)
1559: abort("rotate_binary_buffer: can't malloc ra.ph");
1560: *(ra.ph) = *(a->ph);
1561: /* by arbitrary convention, rotated bx.a will coincide with input bx.a */
1562: if(tra->rot <= PI/2+TINY_ANG && tra->rot >= PI/2-TINY_ANG) {
1563: int ey,ii;
1564: register RLE_Run *rp;
1565: register unsigned int *cb,*eb,bm,obm;
1566: register short rx;
1567: ra.ph->bx.b.x = a->ph->bx.a.x + bbx_hgt(&(a->ph->bx)) - 1;
1568: ra.ph->bx.b.y = a->ph->bx.a.y + bbx_wid(&(a->ph->bx)) - 1;
1569: rl.len = ra.wid = bbx_wid(&(ra.ph->bx));
1570: rl.y = ra.ph->bx.a.y; ey=ra.ph->bx.b.y;
1571: ii=0; bm=01;
1572: do { obm=0; /* assume 0 left of margin */
1573: rp=rl.r-1;
1574: rx=ra.ph->bx.a.x;
1575: cb=(eb=buf+ii)+((rl.len-1)*ipl);
1576: do { if((*cb & bm)!=obm) {
1577: if(obm) { rp->xe=rx-1; obm=0; }
1578: else { (++rp)->xs=rx; obm=bm; };
1579: };
1580: rx++;
1581: }
1582: while( (cb -= ipl) >= eb );
1583: if(obm) rp->xe=rx-1;
1584: rl.runs = rp - rl.r + 1;
1585: sink(&rl,&ra);
1586: if((bm<<=1)==0) {ii++; bm=01;};
1587: }
1588: while((++rl.y)<=ey);
1589: }
1590: else if(tra->rot <= PI+TINY_ANG && tra->rot >= PI-TINY_ANG) {
1591: rl.len = ra.wid;
1592: abort("rotate_binary_buffer: tra->rot==%g deg unimplemented",
1593: tra->rot/DtoR);
1594: }
1595: else if(tra->rot <= 3*PI/2+TINY_ANG && tra->rot >= 3*PI/2-TINY_ANG) {
1596: ra.ph->bx.b.x = a->ph->bx.a.x + bbx_hgt(&(a->ph->bx)) - 1;
1597: ra.ph->bx.b.y = a->ph->bx.a.y + bbx_wid(&(a->ph->bx)) - 1;
1598: rl.len = ra.wid = bbx_wid(&(ra.ph->bx));
1599: abort("rotate_binary_buffer: tra->rot==%g deg unimplemented",
1600: tra->rot/DtoR);
1601: }
1602: else if(tra->rot <= 20.0*DtoR && tra->rot >= -20.0*DtoR) {
1603: /* rotation by ``small'' angle */
1604: Sp ce; /* center of image to be rotated */
1605: double rcos,rsin; /* real rotation vector (cos,sin) */
1606: double irx,iry; /* current rotated pixel location */
1607: register int sx,sy,ex,ey,rx,ry;
1608: register RLE_Run *rp;
1609: register int pel,opel;
1610: register int orx,ory;
1611: if(0) err("rotate_binary_buffer: tra->rot==%g deg under development",
1612: tra->rot/DtoR);
1613: /* conventionally, keep the same window as the input image,
1614: while rotating about its midpoint */
1615: rl.len = ra.wid = bbx_wid(&(ra.ph->bx));
1616: sx = ra.ph->bx.a.x; ex = ra.ph->bx.b.x;
1617: sy = ra.ph->bx.a.y; ey = ra.ph->bx.b.y;
1618: ce.x = sx + bbx_wid(&(ra.ph->bx))/2;
1619: ce.y = sy + bbx_hgt(&(ra.ph->bx))/2;
1620: rcos = cos(tra->rot); rsin = sin(tra->rot);
1621: for(ory=sy; ory<=ey; ory++) {
1622: opel=0; /* left of output margin: assume pel==0 */
1623: rp=rl.r-1;
1624: irx = ((rcos*(sx - ce.x) - rsin*(ory - ce.y))) + ce.x;
1625: iry = ((rsin*(sx - ce.x) + rcos*(ory - ce.y))) + ce.y;
1626: for(orx=sx; orx<=ex; orx++) {
1627: rx = (int)(irx + 0.5); ry = (int)(iry + 0.5);
1628: if(rx<sx || rx>ex || ry<sy || ry>ey)
1629: /* outside input image: assume pel==0 */
1630: pel=0;
1631: else /* look at bit within input image */ {
1632: int ix,iy,bx;
1633: iy = (ry-sy)*ipl;
1634: ix = rx/BITS_PER_INT;
1635: bx = rx%BITS_PER_INT;
1636: #if BIG_ENDIAN
1637: pel = (buf[ iy + ix ] & (01<<(BITS_PER_INT-bx-1))) ? 1 : 0;
1638: #else
1639: pel = (buf[ iy + ix ] & (01<<bx)) ? 1 : 0;
1640: #endif
1641: };
1642: if(pel!=opel) {
1643: if(opel) { rp->xe=orx-1; opel=0; }
1644: else { (++rp)->xs=orx; opel=pel; };
1645: };
1646: /* step one pel to the right in output image */
1647: irx += rcos; iry += rsin;
1648: };
1649: if(opel) rp->xe=orx-1;
1650: rl.runs = rp - rl.r + 1;
1651: rl.y = ory;
1652: sink(&rl,&ra);
1653: };
1654: }
1655: else { abort("rotate_binary_buffer: tra->rot==%g deg unimplemented",
1656: tra->rot/DtoR);
1657: };
1658: sink(NULL,&ra); /* signal end-of-page */
1659: }
1660:
1661: /* Copy a source of RLE_Lines to a sink of RLE_Lines, transforming them
1662: by trimming, shifting, scaling, truncation, and rotation.
1663: The source is function ir(), which returns non-empty lines only,
1664: or NULL on end of page. It is passed `bop=T' on beginning of page.
1665: On return from ir(), ia->ph->cy holds the index of the line, whose height is
1666: guaranteed to lie in the range [ia->ph->bx.a.y,ia->ph->bx.b.y].
1667: All input runs are guaranteed to lie in [ia->ph->bx.a.x,ia->ph->bx.b.x].
1668: The maximum length (in pels) of each source line is ia->wid.
1669: The sink function or() takes two arguments:
1670: RLE_Line *rl; ==NULL on end-of-page
1671: Copy_arg *a;
1672: The lines sent to the sink must be in unbroken ascending integer
1673: sequence of rl->y (thus blank lines must be explicitly sent). At all times,
1674: oa->ph->cy is the line last written. After the first call to or(),
1675: oa->ph->cy lies in the range [oa->ph->bx.a.y,oa->ph->bx.b.y].
1676: Trimming, shifting, scaling, and truncation are performed either
1677: here or in function transform_rlel(). Rotation is handled specially:
1678: the complete output image (after all other transformations have been
1679: performed) is saved in an intermediate buffer (as packed binary), then
1680: rotated. Rotation is much slower than the other operations, mainly due
1681: to the necessity of touching every pixel. (Manhattan rotations might be
1682: faster if the buffer held RLE_lines, but then it would be next-to-impossible
1683: to extend to arbitrary rotations someday.)
1684: */
1685: transform_rlels(ir,ia,or,oa,tra)
1686: RLE_Line *(*ir)(); /* return next RLE_Line */
1687: Copy_arg *ia; /* used here (bop & wid) & passed to ir() */
1688: int (*or)(); /* write next RLE_Line */
1689: Copy_arg *oa; /* used here (bop && ph->bx.*.y) & passed to or() */
1690: Transform_rlel_arg *tra;
1691: { RLE_Line *irl,*orl;
1692: static RLE_Line rl0 = Init_RLE_Line; /* empty line */
1693: int tr_y; /* transformed y */
1694: int (*sv_or)();
1695: if(tra->rot!=0.0) {
1696: /* if must rotate the image, first buffer the entire
1697: set of output RLE_Lines */
1698: sv_or = or;
1699: or = (int (*)())binary_buffer;
1700: };
1701: /* signal beginning of page; reset in source() & sink() functions */
1702: ia->bop=oa->bop=T;
1703: /* set first output line number to write */
1704: tra->dy = (tra->sy = oa->ph->bx.a.y);
1705: while((irl=ir(ia))!=NULL) {
1706: if(F&&_O.dbg_r) nerr_RLE_Line("trans.i: ",irl);
1707: /* trim input lines' Y */
1708: if(irl->y < tra->tr.a.y) continue;
1709: if(irl->y > tra->tr.b.y) break;
1710: /* compute the output Y that is equal to the last
1711: of the group of transformed equivalent Y's */
1712: tr_y = (int)((irl->y + tra->off.y + 1)*tra->scl.y) - 1;
1713: /* truncate if necessary */
1714: if(tr_y>oa->ph->bx.b.y) tr_y = oa->ph->bx.b.y;
1715: /* supply implicit blank line(s) of the same length */
1716: while(tra->sy < tr_y) {
1717: rl0.len = ia->wid;
1718: transform_rlel(&rl0,tra,or,oa);
1719: };
1720: irl->len = ia->wid;
1721: transform_rlel(irl,tra,or,oa);
1722: };
1723: /* supply terminating blank line(s) of the same length */
1724: while(tra->sy < oa->ph->bx.b.y) {
1725: rl0.len = ia->wid;
1726: transform_rlel(&rl0,tra,or,oa);
1727: };
1728: transform_rlel(NULL,tra,or,oa); /* signal end of page */
1729: /* read input until end of page occurs; this is required
1730: to support catenated pages */
1731: while(irl!=NULL) irl=ir(ia);
1732: if(tra->rot!=0.0) {
1733: unsigned int *buf;
1734: buf = binary_buffer(NULL,NULL);
1735: if(buf!=NULL) {
1736: rotate_binary_buffer(buf,tra,sv_or,oa);
1737: free(buf);
1738: };
1739: };
1740: }
1741:
1742: process_page(i,o)
1743: Copy_arg *i,*o;
1744: { RLE_Line *(*source)();
1745: int (*sink)();
1746: char unit,*up,cpy[40]; /* units character */
1747: Transform_rlel_arg tra;
1748:
1749: i->wid = bbx_wid(&(i->ph->bx));
1750:
1751: _O.trim = max_Bbx; /* start by trimming nothing */
1752: /* translate units in option arguments */
1753: if(_O.optarg_l!=NULL) {
1754: strcpy(cpy,_O.optarg_l);
1755: if((up=strpbrk(cpy,UNITS))!=NULL) {
1756: unit= *up; *up='\0';
1757: _O.trim.a.x=vto_scoor(atof(cpy),unit,i->ph->res_x);
1758: }
1759: else /* assume scanner coordinates */
1760: _O.trim.a.x=atoi(cpy);
1761: };
1762: if(_O.optarg_r!=NULL) {
1763: strcpy(cpy,_O.optarg_r);
1764: if((up=strpbrk(cpy,UNITS))!=NULL) {
1765: unit= *up; *up='\0';
1766: _O.trim.b.x=vto_scoor(atof(cpy),unit,i->ph->res_x);
1767: }
1768: else /* assume scanner coordinates */
1769: _O.trim.b.x=atoi(cpy);
1770: _O.trim.b.x--; /* -w coordinate is open, Bbx is closed */
1771: };
1772: if(_O.optarg_t!=NULL) {
1773: strcpy(cpy,_O.optarg_t);
1774: if((up=strpbrk(cpy,UNITS))!=NULL) {
1775: unit= *up; *up='\0';
1776: _O.trim.a.y=vto_scoor(atof(cpy),unit,i->ph->res_y);
1777: }
1778: else /* assume scanner coordinates */
1779: _O.trim.a.y=atoi(cpy);
1780: };
1781: if(_O.optarg_b!=NULL) {
1782: strcpy(cpy,_O.optarg_b);
1783: if((up=strpbrk(cpy,UNITS))!=NULL) {
1784: unit= *up; *up='\0';
1785: _O.trim.b.y=vto_scoor(atof(cpy),unit,i->ph->res_y);
1786: }
1787: else /* assume scanner coordinates */
1788: _O.trim.b.y=atoi(cpy);
1789: _O.trim.b.y--; /* -w coordinate is open, Bbx is closed */
1790: };
1791: /* Modified output margins may lie OUTSIDE the input window as well
1792: as within it. */
1793: if(_O.trim.a.x==Scoor_MIN) _O.trim.a.x=i->ph->bx.a.x;
1794: if(_O.trim.b.x==Scoor_MAX) _O.trim.b.x=i->ph->bx.b.x;
1795: if(_O.trim.a.y==Scoor_MIN) _O.trim.a.y=i->ph->bx.a.y;
1796: if(_O.trim.b.y==Scoor_MAX) _O.trim.b.y=i->ph->bx.b.y;
1797: if(_O.dbg_m) err("trim: %s",bbx_toa(&(_O.trim)));
1798:
1799: if(strcmp(i->ph->type,"binary")==0) { source = binary_source; }
1800: else if(strcmp(i->ph->type,"bitmap")==0) { source = bitmap_source; }
1801: else if(strcmp(i->ph->type,"bitfile")==0) { source = bitfile_source; }
1802: else if(strcmp(i->ph->type,"document-image")==0) { source = dim_source; }
1803: else if(strcmp(i->ph->type,"dim")==0) { source = dim_source; }
1804: else if(strcmp(i->ph->type,"rle")==0) {
1805: RIC_hdr rh;
1806: /* reopen RLE file to use system I/O (awkward, obsolescent) */
1807: lseek(fileno(i->ph->fp),0L,0);
1808: RLE_open(fileno(i->ph->fp),&rh);
1809: i->ph->cy = i->ph->bx.a.y-1;
1810: source = rle_source;
1811: }
1812: else if(strcmp(i->ph->type,"pico")==0
1813: ||strcmp(i->ph->type,"dump")==0) {
1814: i->thresh = _O.thresh;
1815: source = pic_source;
1816: }
1817: else if(strcmp(i->ph->type,"ccitt-g31")==0) {
1818: if((i->bf=bopen(i->ph->fp,"r"))==NULL)
1819: abort("can't open bitfile");
1820: i->tbl = ccitt_table();
1821: source = g31_source;
1822: }
1823: else if(strcmp(i->ph->type,"ccitt-g32")==0) {
1824: if((i->bf=bopen(i->ph->fp,"r"))==NULL)
1825: abort("can't open bitfile");
1826: i->tbl = ccitt_table();
1827: source = g32_source;
1828: }
1829: else if(strcmp(i->ph->type,"ccitt-g4")==0) {
1830: if((i->bf=bopen(i->ph->fp,"r"))==NULL)
1831: abort("can't open bitfile");
1832: i->tbl = ccitt_table();
1833: source = g4_source;
1834: }
1835: else if(strcmp(i->ph->type,"cdf-mrlc")==0) { source = cdf_mrlc_source; }
1836: else abort("Input file TYPE=%s unsupported",i->ph->type);
1837:
1838: if(_O.dbg_h) err("In %s",PIC_hdr_toa(i->ph));
1839:
1840: /* Adjudicate -R and -x options */
1841: if(_O.out_res.x==-2) {
1842: /* -R= specified: force resolutions to be equal to the greater */
1843: if(i->ph->res_x < i->ph->res_y) {
1844: _O.out_res.x = _O.out_res.y = i->ph->res_y;
1845: }
1846: else if(i->ph->res_y < i->ph->res_x) {
1847: _O.out_res.x = _O.out_res.y = i->ph->res_x;
1848: }
1849: else _O.out_res.x = _O.out_res.y = i->ph->res_x;
1850: };
1851: if(_O.out_res.x!=-1) { /* -Rx specified; override -xX */
1852: _O.expand.x = ((double)_O.out_res.x)/i->ph->res_x;
1853: if(_O.dbg_R && _O.expand.x!=1.0)
1854: err("horizontal resolution changed: x%g (%d -> %d)",
1855: _O.expand.x,i->ph->res_x,_O.out_res.x);
1856: };
1857: if(_O.out_res.y!=-1) { /* -R,y specified; override -x,Y */
1858: _O.expand.y = ((double)_O.out_res.y)/i->ph->res_y;
1859: if(_O.dbg_R && _O.expand.y!=1.0)
1860: err("vertical resolution changed: x%g (%d -> %d)",
1861: _O.expand.y,i->ph->res_y,_O.out_res.y);
1862: };
1863:
1864: /* Setup image transformation parameters */
1865: tra = empty_Transform_rlel_arg;
1866: tra.tr = _O.trim;
1867: tra.off = _O.offset;
1868: tra.scl = _O.expand;
1869: tra.wh.x = bbx_wid(&(tra.tr));
1870: tra.wh.y = bbx_hgt(&(tra.tr));
1871: tra.rev = _O.reverse;
1872: if(tra.scl.x!=1.0) {
1873: tra.wh.x = (int)(tra.wh.x*tra.scl.x+0.5);
1874: };
1875: if(tra.scl.y!=1.0) {
1876: tra.wh.y = (int)(tra.wh.y*tra.scl.y+0.5);
1877: };
1878: switch(_O.top) {
1879: case 't': /* default */ break;
1880: case 'l': /* top is really at left */
1881: tra.rot = (Radians)(PI/2);
1882: break;
1883: case 'b': /* top is really at bottom */
1884: tra.rot = (Radians)(PI);
1885: break;
1886: case 'r': /* top is really at right */
1887: tra.rot = (Radians)((3*PI)/2);
1888: break;
1889: case 'a': /* rotation angle given */
1890: tra.rot = _O.top_angle;
1891: break;
1892: };
1893: /* is the transform the identity? (speed-optimized special case) */
1894: tra.ident = ( (bbx_eq(&(tra.tr),&(i->ph->bx)))
1895: && (tra.scl.x==1.0)
1896: && (tra.scl.y==1.0)
1897: && (tra.off.x==0)
1898: && (tra.off.y==0)
1899: && (tra.rot==0.0) );
1900:
1901: /* compute transformed output box & resolution;
1902: don't rotate here (see transform_rlels()) */
1903: if(tra.ident) {
1904: o->ph->bx = i->ph->bx;
1905: o->ph->res_x = i->ph->res_x;
1906: o->ph->res_y = i->ph->res_y;
1907: }
1908: else { o->ph->bx = tra.tr;
1909: o->ph->bx.a.x += tra.off.x;
1910: o->ph->bx.b.x += tra.off.x;
1911: o->ph->bx.a.y += tra.off.y;
1912: o->ph->bx.b.y += tra.off.y;
1913: if(tra.scl.x!=1.0) {
1914: o->ph->bx.a.x = tra.scl.x*o->ph->bx.a.x;
1915: o->ph->bx.b.x = o->ph->bx.a.x + tra.wh.x-1;
1916: };
1917: if(tra.scl.y!=1.0) {
1918: o->ph->bx.a.y = tra.scl.y*o->ph->bx.a.y;
1919: o->ph->bx.b.y = o->ph->bx.a.y + tra.wh.y-1;
1920: };
1921: o->ph->res_x = (i->ph->res_x*tra.scl.x + 0.5);
1922: o->ph->res_y = (i->ph->res_y*tra.scl.y + 0.5);
1923: };
1924:
1925: if(_O.to_bin)
1926: { strcpy(o->ph->type,"binary"); sink = binary_sink; }
1927: else if(_O.to_bitfile)
1928: { strcpy(o->ph->type,"bitfile"); sink = bitfile_sink; }
1929: else if(_O.to_bitmap)
1930: { strcpy(o->ph->type,"bitmap"); sink = bitmap_sink; }
1931: else if (_O.to_rle) {
1932: if(strcmp(i->ph->type,"rle")==0)
1933: abort("can't both read and write TYPE=rle - sorry");
1934: strcpy(o->ph->type,"rle"); sink = rle_sink;
1935: }
1936: else if(_O.to_g31) { strcpy(o->ph->type,"ccitt-g31"); sink = g31_sink; }
1937: else if(_O.to_g32) {
1938: strcpy(o->ph->type,"ccitt-g32");
1939: o->k = _O.g32_k;
1940: sink = g32_sink;
1941: }
1942: else if(_O.to_g4) { strcpy(o->ph->type,"ccitt-g4"); sink = g4_sink; }
1943: else if(_O.to_pic) { strcpy(o->ph->type,"dump"); sink = pic_sink; }
1944: #if CPU==SUN
1945: else if(_O.to_post) { strcpy(o->ph->type,"postscript"); sink = post_sink; }
1946: #endif
1947: #if CPU==SUN
1948: else if(_O.to_rast) { strcpy(o->ph->type,"sunraster"); sink = rast_sink; }
1949: #endif
1950: if(i->ph->misc!=NULL) {
1951: o->ph->misc = i->ph->misc;
1952: i->ph->misc = NULL;
1953: };
1954: if(_O.dbg_h) err("Out %s",PIC_hdr_toa(o->ph));
1955:
1956: transform_rlels(source,i,sink,o,&tra);
1957:
1958: /* Synchronize filedes pointer with stream pointer */
1959: lseek(fileno(o->ph->fp),o->ph->seek = ftell(o->ph->fp),0);
1960: }
1961:
1962: /* A file may be a catenation of pages. */
1963: process_fps(i,o)
1964: FILE *i,*o;
1965: { Copy_arg ia,oa;
1966: int stat;
1967: ia = oa = empty_Copy_arg;
1968: ia.ph = alloc_PIC_hdr(i);
1969: oa.ph = alloc_PIC_hdr(o);
1970:
1971: stat=PIC_get_hdr(ia.ph);
1972: if(_O.dbg_h && stat!=1) err("PIC_get_hdr() returns status %d",stat);
1973:
1974: /* enforce bitfile(9) I/O restrictions */
1975: if(_O.from_bitfile && strcmp(ia.ph->type,"bitfile")!=0)
1976: abort("-Bi requires input to be bitfile(9.5) format");
1977: if(!_O.from_bitfile && strcmp(ia.ph->type,"bitfile")==0) {
1978: /* TYPE= is missing, erroneously: refuse to recognize it */
1979: abort("TYPE=... header is missing");
1980: };
1981:
1982: if(strcmp(ia.ph->type,"document-image")==0
1983: || strcmp(ia.ph->type,"dim")==0) {
1984: Page pg;
1985: skip_doc(i);
1986: if(frdb_page_etc(i,&pg,IsALL)==1) {
1987: ia.ph->bx = pg.bx;
1988: ia.ph->res_x = pg.res_x;
1989: ia.ph->res_y = pg.res_y;
1990: ia.rles = *rle_lines_of_page(&pg);
1991: if(_O.shrinkwrap!=-1) {
1992: Sp trans;
1993: ia.ph->bx = *bbx_of_rle_lines(&ia.rles);
1994: ia.ph->bx.a.x -= _O.shrinkwrap;
1995: ia.ph->bx.a.y -= _O.shrinkwrap;
1996: ia.ph->bx.b.x += _O.shrinkwrap;
1997: ia.ph->bx.b.y += _O.shrinkwrap;
1998: if(bbx_area(&(ia.ph->bx))<=0)
1999: abort("-W%d shrinks to nothing",_O.shrinkwrap);
2000: trans.x = -ia.ph->bx.a.x; trans.y = -ia.ph->bx.a.y;
2001: translate_rle_lines(&ia.rles,trans);
2002: ia.ph->bx.b.x = bbx_wid(&ia.ph->bx)-1;
2003: ia.ph->bx.b.y = bbx_hgt(&ia.ph->bx)-1;
2004: ia.ph->bx.a.x = ia.ph->bx.a.y = 0;
2005: };
2006: free_page_etc(&pg,IsALL&(~IsPage));
2007: }
2008: else { free_page_etc(&pg,IsALL&(~IsPage));
2009: abort("can't read document-image file");
2010: };
2011: };
2012: if(_O.in_res.x!=SHRT_MIN&&_O.in_res.y!=SHRT_MIN) {
2013: /* force input RES to given values */
2014: if(ia.ph->res_x!=0 || ia.ph->res_y!=0) {
2015: err("input: RES=%d %d overridden by -Z%d,%d\n",
2016: ia.ph->res_x,ia.ph->res_y,_O.in_res.x,_O.in_res.y);
2017: };
2018: ia.ph->res_x = _O.in_res.x;
2019: ia.ph->res_y = _O.in_res.y;
2020: };
2021: if(ia.ph->res_x<=0 || ia.ph->res_y<=0)
2022: err("input: RES=%d %d may cause problems (set using -Zx,y)",
2023: ia.ph->res_x,ia.ph->res_y);
2024:
2025: while(strlen(ia.ph->type)>0 && stat==1 && !feof(i)
2026: && !ferror(i) && !ferror(o)) {
2027: process_page(&ia,&oa);
2028: if( strcmp(ia.ph->type,"cdf")==0
2029: || strcmp(ia.ph->type,"cdf-mrlc")==0 ) {
2030: stat=CDF_next_page(ia.ph);
2031: }
2032: else { if((stat=PIC_get_hdr(ia.ph))==1) {
2033: /* enforce bitfile(9) I/O restrictions */
2034: if(_O.from_bitfile && strcmp(ia.ph->type,"bitfile")!=0)
2035: abort("-Bi means input must be picfile");
2036: if(!_O.from_bitfile && strcmp(ia.ph->type,"bitfile")==0) {
2037: /* TYPE= is missing, erroneously: silently quit */
2038: if(_O.dbg_h) err("strange input before normal EOF - ignored");
2039: strcpy(ia.ph->type,"");
2040: };
2041: };
2042: };
2043: if(_O.dbg_h && stat!=1)
2044: err("PIC_get_hdr() returns status %d",stat);
2045: };
2046:
2047: /* EOF or error */
2048: free_PIC_hdr(ia.ph);
2049: free_PIC_hdr(oa.ph);
2050: }
2051:
2052: #if FILE_TREE
2053: /* Process filenames: if NULL, use stdin/stdout; if files, read them;
2054: if directories, create a parallel file tree and process the leaves
2055: pairwise. */
2056: process_fns(i,o)
2057: char *i; /* may be NULL; not yet fopened for read */
2058: char *o; /* may be NULL; not yet fopened for write */
2059: #define dbg_ft (F)
2060: { FILE *i_fp;
2061: FILE *o_fp;
2062: char *branch;
2063: if(dbg_ft) err("processs(\"%s\",\"%s\")",i,o);
2064: branch=path_toa(&path_process.path,1);
2065: if(dbg_ft&&branch[0]!='\0') err("%s",branch);
2066: if(i==NULL||i[0]=='\0') i_fp=stdin;
2067: else if( (i_fp=fopen(i,"r"))==NULL ) {
2068: err("can't open input file %s - skip it",i);
2069: return;
2070: };
2071: if(o==NULL||o[0]=='\0') o_fp=stdout;
2072: else if( (o_fp=fopen(o,"w"))==NULL ) {
2073: err("can't open output file %s - skip it",o);
2074: return;
2075: };
2076: process_fps(i_fp,o_fp);
2077: if(i_fp!=stdin) fclose(i_fp);
2078: if(o_fp!=stdout) fclose(o_fp); else fflush(o_fp);
2079: };
2080: #else
2081: /* Process filenames: if NULL, use stdin/stdout; if files, open and process them.
2082: */
2083: process_fns(i_fn,o_fn)
2084: char *i_fn; /* may be NULL; not yet fopened for read */
2085: char *o_fn; /* may be NULL; not yet fopened for write */
2086: { FILE *i_fp;
2087: FILE *o_fp;
2088: if(i_fn==NULL||strlen(i_fn)==0) i_fp = stdin;
2089: else { if((i_fp=fopen(i_fn,"r"))==NULL)
2090: abort("can't open input file %s",i_fn);
2091: };
2092: if(o_fn==NULL||strlen(o_fn)==0) o_fp = stdout;
2093: else { if((o_fp=fopen(o_fn,"w"))==NULL)
2094: abort("can't open output file %s",o_fn);
2095: };
2096: process_fps(i_fp,o_fp);
2097: if(i_fp!=stdin) fclose(i_fp);
2098: if(o_fp!=stdout) fclose(o_fp); else fflush(o_fp);
2099: };
2100: #endif
2101:
2102: main(arc,arv)
2103: int arc; char **arv;
2104: { parse_args(arc,arv);
2105: #if FILE_TREE
2106: process_file_trees(process_fns,_O.in_fn,_O.out_fn);
2107: #else
2108: process_fns(_O.in_fn,_O.out_fn);
2109: #endif
2110: }
2111:
2112: nerr_RLE_Line(s,rl)
2113: char *s;
2114: RLE_Line *rl;
2115: { RLE_Run *r;
2116: int ri;
2117: if(rl==NULL) fprintf(stderr,"%15s RLEL NULL.\n",s);
2118: else { fprintf(stderr,"%15s RLEL y%d r%d l%d: ",s,rl->y,rl->runs,rl->len);
2119: for(ri=0,r=rl->r; ri<rl->runs; ri++,r++)
2120: fprintf(stderr,"[%d,%d] ",r->xs,r->xe);
2121: fprintf(stderr,"\n");
2122: };
2123: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.