![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rlelib.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 rlelib.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: /* T. Pavlidis - ATT-BL MH - first versions */
6: /* H. S. Baird - ATT-BL MH - first versions */
7:
8: /* rlelib.c - subroutines for writing/reading run-length-encoded format files.
9: BUG: Uses system I/O for speed, but sacrifices machine-independence:
10: should use fioi.h macroes instead.
11: See rle.h for summary of rle file and format of public functions.
12: Writing a rle file:
13: fd=creat()
14: RLE_put_hdr(fd,hp) - once: allocate buffers, write header
15: RLE_put_Line(fd,lp) - repeatedly
16: RLE_close(fd) - once: flush and deallocate buffers
17: Reading a rle file:
18: fd=open()
19: RLE_open(fd,hp) - once: read header, 1st line into buffer
20: RLE_get_Line(l,r) - repeatedly (on EOF, deallocates buffer)
21: The user can read line-at-a-time or run-at-a-time, but should not intermix them:
22: line-at-a-time:
23: (RLE_Line *) RLE_get_Line(l,r) - return ptr to next line with some run
24: in the interval [l,r];
25: read from opened file (NULL if EOF, abort on error)
26: allocates large buffer and frees it when done
27: run-at-a-time:
28: int RLE_get_Run(&R) - read next run into (RLE_Run) R
29: returns the line number (-1 for EOF, abort on ERROR)
30: does not allocate large buffer;
31: if only a few runs will be used, can be faster
32: */
33:
34: #include <stdio.h>
35: #define LIBC_INCL 1
36: #include "CPU.h"
37: #include "stdocr.h"
38: #include "rle.h"
39:
40: #define RLE_dbg F
41: #define dbg_rd F
42: #define dbg_wr F
43:
44: /* Treated as local static: */
45: typedef struct RLE_global {
46: int fd; /* rle file descriptor */
47: boolean eof;
48: int cy, cx; /* current line no., x-coord */
49: short runs, nrun; /* no. runs, next run in current line */
50: RLE_Line *lp; /* pointer to line (malloc space) */
51: int bpl; /* maximum no. bytes in packed rle line */
52: char *bf; /* I/O buffer (malloc space) */
53: int bfsize; /* size of buffer */
54: char *cp; /* cur. ptr, into bf */
55: } RLE_global;
56: #define Init_RLE_global {0,F,-1,-1,0,0,NULL,0,NULL,0,NULL}
57: RLE_global _RLE = Init_RLE_global;
58:
59: RLE_put_hdr( fd, rhp, bufn )
60: int fd;
61: RIC_hdr *rhp;
62: int bufn; /* minimum number of lines to buffer locally */
63: { char hdr[100];
64: int stat;
65: sprintf(hdr,"TYPE=rle\nWINDOW=%d %d %d %d\nRES=%d %d\n\n",
66: /* use half-open WINDOW convention: l&t closed, r&b open*/
67: rhp->bx.a.x,rhp->bx.a.y,rhp->bx.b.x+1,rhp->bx.b.y+1,
68: rhp->res_x,rhp->res_y);
69: if((stat=write(fd,hdr,strlen(hdr)))!=strlen(hdr)) {
70: abort("rlelib: can't put hdr, stat %d",stat);
71: };
72: _RLE.fd = fd;
73: _RLE.cy = rhp->bx.a.y-1;
74: _RLE.bpl = rhp->bx.b.x-rhp->bx.a.x+9; /* maximum bytes per line */
75: _RLE.bfsize = bufn*_RLE.bpl;
76: if((_RLE.bf=(char *)malloc(_RLE.bfsize))==NULL)
77: abort("can't alloc _RLE.bf[%d]",_RLE.bfsize);
78: _RLE.cp = _RLE.bf;
79: }
80:
81: #define PUT(A,B) { if((A)<128) *(B)++ = (A); \
82: else { *(B)++ = HIGH(A) | 0200; *(B)++ = LOW(A); } \
83: }
84:
85: /* write out a non-blank line of runs */
86: RLE_put_Line(fd,rlp)
87: int fd; /* file descr (already open) */
88: RLE_Line *rlp;
89: { register char *bp;
90: short blank_lines_mny; /* the number of preceding blank lines, minus 1 */
91: register RLE_Run *rp,*ep;
92: Scoor xsofar;
93: short bytes_mny;
94: int stat; /* I/O status */
95: if((_RLE.bfsize-(_RLE.cp-_RLE.bf)) < _RLE.bpl) {
96: /* not enough room left in buffer for worst-case line */
97: RLE_flush();
98: };
99: /* leave space for (short) bytes_mny count */
100: bp=_RLE.cp+sizeof(short);
101: if((blank_lines_mny=(rlp->y-_RLE.cy-1))>0) /* blank lines were skipped */ {
102: PUT(0,bp); /* ``0 runs'' signals blank lines */
103: PUT(blank_lines_mny,bp);
104: };
105: _RLE.cy=rlp->y;
106: PUT(rlp->runs,bp);
107: xsofar=0;
108: for(rp=rlp->r,ep=rp+rlp->runs; rp!=ep; rp++) {
109: PUT(rp->xs-xsofar,bp); xsofar = rp->xs;
110: PUT(rp->xe-xsofar+1,bp); xsofar = rp->xe+1;
111: };
112: /* go back & write no. bytes at top of line */
113: *((short *) _RLE.cp) = bp-_RLE.cp-sizeof(short);
114: _RLE.cp = bp;
115: if(dbg_wr) err("RLE_put_Line y%d nh%d",_RLE.cy,bytes_mny-2);
116: };
117:
118: /* write out a set of runs */
119: RLE_put_Lines(fd,rlsp)
120: int fd; /* file descr (already open) */
121: RLE_Lines *rlsp;
122: { int i;
123: RLE_Line *rlp;
124: for(i=0,rlp=rlsp->rla; i<rlsp->mny; i++,rlp++)
125: RLE_put_Line(fd,rlp);
126: }
127:
128: RLE_flush()
129: { int bytes;
130: int stat;
131: if((bytes=(_RLE.cp-_RLE.bf))>0)
132: if(stat=write(_RLE.fd,_RLE.bf,bytes)!=bytes)
133: abort("can't write _RLE.bf[%d], status %d",bytes,stat);
134: _RLE.cp = _RLE.bf;
135: }
136:
137: RLE_close(fd)
138: int fd;
139: { RLE_flush();
140: if(_RLE.bf!=NULL) free(_RLE.bf);
141: _RLE.bf = _RLE.cp = NULL;
142: _RLE.bfsize = 0;
143: }
144:
145: /* ``open'' RLE_file for reading:
146: save filedes, read header, and read first line into buffer */
147: boolean RLE_open( fd, hp )
148: int fd;
149: RIC_hdr *hp;
150: { _RLE.fd = fd;
151: /* read header */
152: RLE_get_hdr( fd, hp );
153: if(_RLE.bf!=NULL) free(_RLE.bf);
154: _RLE.bfsize = _RLE.bpl;
155: if((_RLE.bf=(char *)malloc(_RLE.bfsize))==NULL)
156: abort("can't alloc _RLE.bf[%d]",_RLE.bfsize);
157: /* read first non-blank line */
158: _RLE.cy = hp->bx.a.y-1;
159: if (!RLE_rdbf()) return(F);
160: _RLE.eof = F;
161: return(T);
162: }
163:
164: /* read next short from rle-line buffer, updating arg ptr */
165: short RLE_gshort(p)
166: char **p;
167: { register n;
168: register char *q;
169: q = *p;
170: if((*q)&0200) {
171: n = (((*q & 0177)<<8)&077400) | (*(q+1) & 0377);
172: (*p)++;
173: }
174: else n = *q;
175: (*p)++;
176: return(n);
177: }
178:
179: /* system I/O variation on fgets(3), except it replaces \n with \0,
180: and returns the number of chars read (including \0) */
181: int RLE_fgets(bf,max,fd)
182: char *bf;
183: int max;
184: int fd;
185: { char *cp;
186: int stat,mny;
187: cp=bf; mny=0;
188: while(((stat=read(fd,cp,1))==1)&&(++mny<max)&&((*cp)!='\n')) cp++;
189: if(stat!=1) return(stat);
190: else if(mny>=max) return(-1);
191: *cp='\0';
192: return(mny);
193: }
194:
195: /* read ascii header from rle file, convert to RIC_hdr,
196: return status: 1 OK, 0 EOF, -1 error */
197: int RLE_get_hdr( fd, hp )
198: int fd; /* should have been open'ed earlier */
199: RIC_hdr *hp;
200: #define HL_MAX 80
201: #define HTERM "=, \n" /* terminations for header words: "=,<sp><tab>" */
202: { char *cp,*parm,hline[HL_MAX];
203: int status,nrd;
204: if((status=RLE_fgets(hline,HL_MAX,fd))<=0) return(status);
205: while(strlen(hline)>1) {
206: if(RLE_dbg) err("hline \"%s\"",hline);
207: parm=strtok(hline,HTERM);
208: if(parm!=NULL&&strcmp(parm,"TYPE")==0) {
209: if((parm=strtok(0,HTERM))!=NULL
210: &&strcmp(parm,"rle")==0) ;
211: else return(-1);
212: }
213: else if(parm!=NULL&&strcmp(parm,"WINDOW")==0) {
214: /* assume half-open WINDOW: l&t closed, r&b open */
215: if((parm=strtok(0,HTERM))!=NULL) hp->bx.a.x=atoi(parm);
216: else return(-1);
217: if((parm=strtok(0,HTERM))!=NULL) hp->bx.a.y=atoi(parm);
218: else return(-1);
219: if((parm=strtok(0,HTERM))!=NULL) hp->bx.b.x=atoi(parm)-1;
220: else return(-1);
221: if((parm=strtok(0,HTERM))!=NULL) hp->bx.b.y=atoi(parm)-1;
222: else return(-1);
223: }
224: else if(parm!=NULL&&strcmp(parm,"RES")==0) {
225: if((parm=strtok(0,HTERM))!=NULL) hp->res_x=atoi(parm);
226: else return(-1);
227: if((parm=strtok(0,HTERM))!=NULL) hp->res_y=atoi(parm);
228: else return(-1);
229: }
230: else return(-1);
231: if((status=RLE_fgets(hline,HL_MAX,fd))<=0) return(status);
232: };
233: /* maximum possible no. bytes in a packed rle line */
234: _RLE.bpl = hp->bpl = hp->bx.b.x-hp->bx.a.x+9;
235: if(dbg_rd) fprintf(stderr,"rlelib: RLE_get_hdr: %s\n",RIC_hdr_toa(hp));
236: return(1);
237: }
238:
239: /* read the next run into *Rp, and return line number
240: (-1 for EOF, abort on error) */
241: int RLE_get_Run( Rp )
242: RLE_Run *Rp;
243: { if(_RLE.nrun >= _RLE.runs) { /* no more, try to read next line */
244: if (!RLE_rdbf()) /* EOF */ return(-1);
245: };
246: /* another run */
247: Rp->xs = (_RLE.cx += RLE_gshort(&_RLE.cp));
248: Rp->xe = (_RLE.cx += RLE_gshort(&_RLE.cp)) - 1;
249: _RLE.nrun++;
250: return(_RLE.cy);
251: }
252:
253: /* Return ptr to the next line with at least one run overlapping the margins
254: [lm,rm]. The reported runs are not trimmed to fit exactly within margins.
255: If no more lines, return NULL. On error, abort */
256: RLE_Line *RLE_get_Line(lm,rm)
257: int lm, rm; /* left, right margins */
258: { register int rr; /* runs read */
259: register RLE_Run *rp; /* write ptr */
260:
261: do { if(_RLE.eof) {
262: free(_RLE.lp); _RLE.lp = NULL;
263: free(_RLE.bf); _RLE.bf = NULL;
264: return(NULL);
265: };
266: if(_RLE.lp==NULL) { /* allocate space for RLE_Line */
267: _RLE.lp = (RLE_Line *) malloc(sizeof(RLE_Line));
268: if(_RLE.lp==NULL) {
269: abort("rlelib: can't malloc RLE_Line (%d bytes)",
270: sizeof(RLE_Line));
271: };
272: };
273: _RLE.lp->y = _RLE.cy;
274: /* guaranteed to be at least one run in line */
275: rr=0; rp=_RLE.lp->r; _RLE.lp->runs=0;
276: /* skip runs that are outside left margin */
277: do RLE_get_Run(rp);
278: while((rr++ < _RLE.runs) && (rp->xe < lm));
279: /* accept runs until cross right margin */
280: while(rp->xs <= rm) {
281: _RLE.lp->runs++; /* count accepted runs */
282: if(rr++ >= _RLE.runs) break;
283: RLE_get_Run(++rp);
284: };
285: /* look ahead to next line */
286: if (!RLE_rdbf()) /* EOF */ _RLE.eof=T;
287: }
288: while(_RLE.lp->runs==0); /* as result of margins, some lines may empty */
289: return(_RLE.lp);
290: }
291:
292: /* read next line buffer - return F if EOF, abort on error
293: sideffects: sets up _RLE.cp, _RLE.cy, _RLE.cx, _RLE.runs, _RLE.nrun */
294: boolean RLE_rdbf()
295: { short nh;
296: if(dbg_rd) err("enter RLE_rdbf");
297: /* get number of bytes holding RLE of a scan line */
298: if( read(_RLE.fd,&nh,sizeof(short)) != sizeof(short)) {
299: return(F); /* normal EOF */
300: };
301: if( Readvax )
302: nh = swapshortin( nh );
303: if(dbg_rd) err("rlelib: RLE_rdbf: nh %d",nh);
304: if(nh > _RLE.bpl) {
305: abort("rlelib: too many bytes in line: %d > %d(_RLE.bpl)",
306: nh,_RLE.bpl);
307: };
308:
309: /* get those bytes */
310: if( read(_RLE.fd,_RLE.bf,nh) != nh) {
311: abort("rlelib: rle line truncated");
312: };
313: if(dbg_rd) {
314: int bi;
315: err("rlelib: RLE_rdbf: _RLE.bf[0-%d] octal:",nh-1);
316: for(bi=0;bi<nh;bi++)
317: fprintf(stderr," 0%o",0377&(_RLE.bf[bi]));
318: fprintf(stderr,"\n");
319: };
320:
321: /* decode the bytes */
322: _RLE.cp = _RLE.bf;
323: _RLE.runs = RLE_gshort(&_RLE.cp);
324: if(dbg_rd) err("rlelib: _RLE.runs %d",_RLE.runs);
325: if(_RLE.runs==0) { /* blank lines seen */
326: _RLE.cy += RLE_gshort(&_RLE.cp);
327: _RLE.runs = RLE_gshort(&_RLE.cp);
328: if(dbg_rd)
329: err("rlelib: _RLE.cy %d _RLE.runs %d",_RLE.cy,_RLE.runs);
330: };
331: if(_RLE.runs>RLE_RUNS || _RLE.runs<1) {
332: abort("rlelib: illegal no. runs %d in line",_RLE.runs);
333: };
334: _RLE.cy++;
335: if(dbg_rd) err("rlelib: RLE_rdbf: _RLE.runs %d _RLE.cy %d",_RLE.runs,_RLE.cy);
336: _RLE.cx = _RLE.nrun = 0; /* next run will be first */
337: if(dbg_rd) err("rlelib: RLE_rdbf: T exit");
338: return(T);
339: }
340:
341: /* brrl - compute a binary raster line from a run-length-encoded scanline.
342: runa[] is an array of shorts, grouped in pairs (xs,xe) to describe the starting
343: and ending index (inclusive) of each run of black pixels (1 bits).
344: xe >= xs > xe. The runs are in strictly ascending order on xs.
345: lm & rm are the left and right margin indices of pixels, outside of which the
346: pixels are forced to be white. rm >= lm. The `lm'th pixel is written
347: into the `olm'th bit of the output raster (olm>=0).
348: rasp[] is a raser line of chars; on entry, it is assumed to have been zeroed
349: out. rasp[0] holds the leftmost byte in the line and the 001 bit of each
350: byte is the leftmost bit in that byte.
351: The user must ensure that rasp[] is at least (rm-lm+olm+9)/8 bytes long.
352: Returns the number of black pixels in the raster line.
353: NOTE: this uses the ``little-endian'' convention, in which the leftmost pixel
354: in a byte is placed in the least-significant bit (0x01). See `brrlb()' below
355: for the alternative ``big-endian'' version.
356: */
357: int brrl(runs,runa,lm,rm,olm,rasp)
358: int runs; /* number of run-segments in runa[] */
359: short runa[]; /* array of run-segments [xs,xe] (pairs of short) */
360: int lm,rm; /* left,right margin bit indices within raster */
361: int olm; /* `lm'th input pixel will be written to `olm'th bit */
362: char unsigned rasp[]; /* binary raster line (zeroed out on entry) */
363: { int pixels,bi;
364: RLE_Run r,*rp,*re;
365: pixels = 0;
366: re = (rp = (RLE_Run *) runa) + runs;
367: while(rp<re && rp->xe<lm) rp++; /* skip runs to the left of 'lm' */
368: while(rp<re && rp->xs<=rm) {
369: /* truncate to margins */
370: if((r.xs = rp->xs)<lm) r.xs = lm;
371: if((r.xe = rp->xe)>rm) r.xe = rm;
372: /* shift to output indices */
373: r.xs += olm-lm; r.xe += olm-lm;
374: /** SLOW **/
375: for(bi=r.xs; bi<=r.xe; bi++) rasp[bi/8] |= (01)<<(bi%8);
376: pixels += r.xe-r.xs+1;
377: rp++;
378: };
379: return(pixels);
380: }
381:
382: /* ``big-endian'' version of brrl: bits are packed so that the leftmost
383: pixel is placed in the high-order bit (0x80) of each byte.
384: */
385: int brrlb(runs,runa,lm,rm,olm,rasp)
386: int runs;
387: short runa[];
388: int lm,rm,olm;
389: char unsigned rasp[];
390: { int pixels,bi;
391: RLE_Run r,*rp,*re;
392: pixels = 0;
393: re = (rp = (RLE_Run *) runa) + runs;
394: while(rp<re && rp->xe<lm) rp++; /* skip runs to the left of 'lm' */
395: while(rp<re && rp->xs<=rm) {
396: /* truncate to margins */
397: if((r.xs = rp->xs)<lm) r.xs = lm;
398: if((r.xe = rp->xe)>rm) r.xe = rm;
399: /* shift to output indices */
400: r.xs += olm-lm; r.xe += olm-lm;
401: /** SLOW **/
402: for(bi=r.xs; bi<=r.xe; bi++) rasp[bi/8] |= (0200)>>(bi%8);
403: pixels += r.xe-r.xs+1;
404: rp++;
405: };
406: return(pixels);
407: }
408:
409: /* crrl - compute a character raster line from a run-length-encoded scanline.
410: runa[] is an array of shorts, grouped in pairs (xs,xe) to describe the starting
411: and ending index (inclusive) of each run of black pixels (1 bits): xs<=xe.
412: The runs are in strictly ascending order on xs. lm & rm are the left and
413: right margin indices, outside of which pixels are forced to be white. rm >= lm.
414: rasp[] is a raster line, one unsigned char per pixel; rasp[0] holds the
415: leftmost pixel. The user must ensure that rasp[] is at least (rm-lm+1)
416: bytes long. Black pixels are encoded as 0, white as 255. Returns the number
417: of black pixels in the raster line.
418: */
419: #define WHITE_pel 0377
420: #define BLACK_pel 0000
421: int crrl(runs,runa,lm,rm,rasp)
422: int runs; /* number of run-segments in runa[] */
423: short runa[]; /* array of run-segments [xs,xe] (pairs of short) */
424: int lm,rm; /* left,right margin bit indices within raster */
425: unsigned char rasp[]; /* char raster line */
426: { int pixels,bi,wid;
427: RLE_Run r,*rp,*re;
428: unsigned char *cp,*ep;
429: wid=rm-lm+1;
430: memset(rasp,WHITE_pel,wid);
431: re = (rp = (RLE_Run *) runa) + runs;
432: while(rp<re&&rp->xe<lm) rp++; /* skip runs to the left of 'lm' */
433: if(rp>=re) return(0);
434:
435: r = *rp; r.xs -= lm; r.xe -= lm;
436: pixels = 0;
437: do { /* truncate left,right margin */
438: if(r.xs<0) r.xs = 0;
439: if(r.xe>(wid-1)) r.xe = wid-1;
440: /* write r into raster line */
441: pixels += (r.xe-r.xs+1);
442: for(cp=rasp+r.xs,ep=rasp+r.xe; cp<=ep; cp++) *cp = BLACK_pel;
443: /* step to next run */
444: r = *(++rp); r.xs -= lm; r.xe -= lm;
445: }
446: while(r.xs<=(wid-1)&&rp<re);
447: return(pixels);
448: }
449:
450: /* trcr - threshold & run-length-encode a char raster line. `rasp' is a raster
451: line, one unsigned char per pixel: rasp[0] is the leftmost pixel in the line.
452: Pixels with value < 'thresh' are translated to black, else white.
453: Analyzes the line into a series of runs of `1's, placing them into array
454: `runs'. Observes margins: starts at `lm' bit and continues through `rm';
455: bits outside the margins are assumed 0. A `run' is two shorts (the starting &
456: ending indices of the run of `1's, inclusive). The indices are shifted
457: so that the `lm'th pixel goes to run index `olm'. Returns the number of runs.
458: NOTE: The user must ensure that: (1) margins fall within `rasp[]';
459: (2) `runp[]' is big enough to hold the worst-case no. of runs that can result
460: ((rm-lm+2)/2). The contents of the raster-line are unmodified.
461: */
462: int trcr(rasp,lm,rm,olm,thresh,runp)
463: char unsigned rasp[]; /* binary raster line (with 1 extra byte at end) */
464: int lm,rm; /* left,right margin indices within raster */
465: int olm; /* `lm' pixel goes to `olm' run index */
466: int thresh;
467: short runp[]; /* array of run-segments [xs,xe] (pairs of short) */
468: #define dbg_trcr (T)
469: { unsigned char *cp,*ep;
470: short x,*xp;
471: int cv,pv; /* current,prior binary pixel value */
472: ep=(cp=rasp+lm)+rm; x=olm; xp=runp;
473: pv=0; /* assume pixels left of 'lm' are 0 */
474: while (cp<=ep) {
475: if((*cp)<thresh) {
476: /* black pixel */
477: cv=1;
478: if(pv==0) { *xp = x; xp++; };
479: }
480: else { /* white pixel */
481: cv=0;
482: if(pv==1) { *xp = x-1; xp++; };
483: };
484: pv=cv; x++;
485: cp++;
486: };
487: if(pv==1) { *xp = x-1; xp++; }; /* assume pixels right of 'rm' is 0 */
488: return((xp-runp)/2);
489: }
490:
491: /* Transform a sequence of rle-lines using trimming, offsetting, scaling,
492: truncation, and reverse-video. Scaling may lead to interpolation or
493: decimation of lines, so an input line may be mapped into 0, 1, or more
494: output lines.
495: Input lines may be buffered, and there may be latency. To flush buffers,
496: this must be called with NULL argument at end of the sequence. Each output
497: line will be passed to function `sink()', which returns 1 if OK and 0 to quit. Quits are passed back immediately with no latency. Sink's 1st arg RLE_Line
498: *l is a line of runs in output coordinates, whose `len' is the maximum length
499: of the line. l==NULL means end of sequence.
500: Return 1 if OK, 0 to quit. A copy of *l is passed to sink().
501: a->sy is incremented for every line written to the sink, and is attached to
502: the output lines as *.y.
503: */
504: int transform_rlel(l,a,sink,sa)
505: RLE_Line *l; /* NULL if end of sequence */
506: Transform_rlel_arg *a;
507: int (*sink)(); /* takes args: (RLE_Line *), and int */
508: VOID *sa; /* passed to sink() as 2nd arg */
509: { RLE_Line m,r;
510: register RLE_Run *rp,*ep,*mp;
511: RLE_Run mr,mm,rr;
512: int rm;
513: int o_a_x,o_b_x; /* maximum output index */
514: if(l==NULL) {
515: sink(NULL,sa);
516: return(1);
517: };
518: m.len = l->len;
519: m.runs = l->runs;
520: if(a->ident) {
521: if(m.runs>0) memcpy(m.r,l->r,2*m.runs*sizeof(short));
522: m.y = a->sy;
523: if(sink(&m,sa)==0) return(0);
524: else { a->sy++;
525: return(1);
526: };
527: };
528: /* maximum permissable output bounds */
529: o_a_x = (int)((a->tr.a.x + a->off.x)*a->scl.x);
530: o_b_x = o_a_x + a->wh.x - 1;
531: if(a->sy<=((int)a->dy)) {
532: /* compute runs to be ouput: rp - input runs; mp - output runs*/
533: mp=(m.r - 1);
534: for(ep=(rp=l->r)+l->runs; rp<ep; rp++) {
535: /* trim using a->tr */
536: mr = *rp;
537: if(mr.xe < a->tr.a.x) /* off left margin */ continue;
538: if(mr.xs > a->tr.b.x) /* off right margin */ break;
539: if(mr.xs < a->tr.a.x) /* extends left too far */
540: mr.xs=a->tr.a.x;
541: if(mr.xe > a->tr.b.x) /* extends right too far */
542: mr.xe=a->tr.b.x;
543:
544: /* offset using a->off */
545: mr.xs += a->off.x;
546: mr.xe += a->off.x;
547:
548: /* expand using a->scl */
549: mr.xs = (int)(mr.xs*a->scl.x);
550: mr.xe = ((int)((mr.xe+1)*a->scl.x))-1;
551: if(mr.xe<mr.xs) mr.xe=mr.xs;
552:
553: /* truncate to maximum output width */
554: if(mr.xe<o_a_x) /* off left margin */ continue;
555: if(mr.xs>o_b_x) /* off right margin */ break;
556: if(mr.xs<o_a_x) /* extends left too far */ mr.xs=o_a_x;
557: if(mr.xe>o_b_x) /* extends right too far */ mr.xe=o_b_x;
558: /* store */
559: if(mp < m.r) /* first */ *(++mp) = mr;
560: else /* can merge with prior run? */ {
561: if(mp->xe >= (mr.xs-1)) /* yes */ mp->xe = mr.xe;
562: else /* no */ *(++mp) = mr;
563: };
564: };
565: m.runs = mp - m.r + 1;
566: m.len = a->wh.x;
567: do { m.y = a->sy;
568: if(a->rev) {
569: /* r = reverse-video(m) */
570: rp=r.r; rr.xs=o_a_x;
571: for(ep=(mp=m.r)+m.runs; mp<ep; mp++) {
572: if(rr.xs<mp->xs) {
573: rr.xe=mp->xs-1;
574: *(rp++)=rr;
575: };
576: rr.xs=mp->xe+1;
577: };
578: if(rr.xs<=o_b_x) {
579: rr.xe=o_b_x;
580: *(rp++)=rr;
581: };
582: r.runs = rp-r.r;
583: r.len = m.len;
584: r.y = m.y;
585: if(sink(&r,sa)==0) return(0);
586: }
587: else { if(sink(&m,sa)==0) return(0); };
588: a->sy++;
589: }
590: while(a->sy<=((int)a->dy));
591: };
592: a->dy += a->scl.y;
593: return(1);
594: }
595:
596: /* Insert a (copy of) the given RLE_Line in the RLE_Lines */
597: insert_rlel(rlp,rlsp)
598: RLE_Line *rlp;
599: RLE_Lines *rlsp;
600: { abort("insert_rlel: unimplemented");
601: }
602:
603: err_RLE_line(s,rl)
604: char *s; /* name */
605: RLE_Line *rl;
606: { RLE_Run *r;
607: int ri;
608: if(rl==NULL) fprintf(stderr,"RLEL %10s NULL\n",s);
609: else { fprintf(stderr,"RLEL %10s y%d r%d l%d: ",
610: s,rl->y,rl->runs,rl->len);
611: for(ri=0,r=rl->r;ri<rl->runs;ri++,r++)
612: fprintf(stderr,"[%d,%d] ",r->xs,r->xe);
613: fprintf(stderr,"\n");
614: };
615: }
616:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.