![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to postlib.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 postlib.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. Thompson - ATT-BL HO - first versions */
6: /* Routines for generating PostScript from RLE. */
7: /* The routines at the bottom of this file, which */
8: /* do the actual conversion to postscript, were */
9: /* hacked out of 'sun2ps'. The original header */
10: /* giving credit to its authors is there. */
11:
12: /* The 'binary' version of the output is collected in a */
13: /* temporary file, which is then fed back to the routines */
14: /* that generate postscript in a run-length-encoded form. */
15: /* Ideally it should just convert the original run-length */
16: /* encoding directly, but the REAL bottleneck is the */
17: /* PostScript printer, of course. Printing an 800 by 800 */
18: /* pixel image takes 5 minutes. */
19:
20: #include <stdio.h>
21: #include <math.h>
22: #include <string.h>
23: #include "CPU.h"
24: #include "boole.h"
25: #include "limits.h" /* numeric extreme values */
26: #include "Units.h"
27: #include "Coord.h"
28: #include "pic.h"
29:
30: FILE *Fp, *tmpfile();
31: int Raswidth;
32: int Raslength;
33: int Rasbytes; /* bytes per row */
34: int Inv = 0;
35: int Aspect = 1; /* if non-zero, retain original aspect ratio */
36: int Land = 0; /* if non-zero, print in landscape mode */
37: char Revbyte[256];
38: /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 */
39: char Revnib[16] = {
40: 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15
41: };
42:
43: void
44: POST_start(h)
45: PIC_hdr *h;
46: {
47: int n, v;
48:
49: /* build a table of reversed bytes */
50: for ( n=0; n<256; n++ )
51: Revbyte[n] = Revnib[(n>>4)&0xf] | Revnib[n&0xf]<<4;
52:
53: h->bpl = (h->bpl+7)/8;
54: Rasbytes = h->bpl;
55: Raslength = h->bpl * h->bx.b.y;
56: Raswidth = h->bx.b.x;
57: postmain(1,NULL,Raswidth,h->bx.b.y);
58: #if CPU==SUN
59: Fp = tmpfile();
60: #else
61: Fp = fopen("tmp.postlib.0","rw");
62: #endif
63: }
64:
65: void
66: POST_end()
67: {
68: int c;
69: rewind(Fp);
70: (VOID) Encode(Raslength, Inv);
71: PrintPostScriptClosing();
72: fclose(Fp);
73: }
74:
75: /* write a full line of picture data, returning status: 1 OK, 0 EOF, -1 ERR */
76: int POST_wline(h,line)
77: PIC_hdr *h;
78: unsigned char *line;
79: { int stat;
80: if( (stat=fwrite(line,1,h->bpl,Fp)) == h->bpl) {
81: h->seek += h->bpl;
82: h->cy++;
83: return(1);
84: }
85: else { /* ERR */
86: err("write to fd%d stat%d",fileno(h->fp),stat);
87: if((stat>=0)&&(stat<h->bpl)) return(0 /*EOF*/);
88: else return(-1);
89: };
90: }
91:
92: /******************************************************************************
93: * *
94: * File: sun2ps.c *
95: * Author: Glenn Boysko *
96: * Organization: Case Western Reserve University *
97: * EMail: {decvax, sun}!mandrill!boysko *
98: * [email protected] *
99: * Created: Wed Mar 23 9:25pm *
100: * Contents: Sun Rasterfile to PostScript image (using a run-length *
101: * encoding scheme.) *
102: * *
103: * (Adapted from "postimage" filter by J. R. Bammi.) *
104: * *
105: * @(#)sun2ps.c 1.8
106: ******************************************************************************/
107:
108: /*
109: * Usage:
110: * sun2ps [-s sizex sizey] [-t transx transy] [-r rot] [-l] [-i] [-a] file ...
111: *
112: * -s sizex sizey = size of postscript image - default 7.5 x 10 inches.
113: * -t transx transy = translate image - default 0.5 0.5 inches
114: * -r rotate = rotate image - default 0 degress
115: * -l = landscape (overrides *all* settings.)
116: * -i = inverse image - default no inverse
117: * (Inverse enabled implies white on black.)
118: * -a = maintain correct aspect ratio - default none.
119: *
120: */
121:
122: /* Sun standard raster file format (as obtained by screendump(1)).
123: *
124: * Header (8 16-bit quantities)
125: * Color Map
126: * Image
127: *
128: */
129:
130: /* Header Format:
131: *
132: * ras_magic (int) Raster Magic number 0x59a66a95
133: * ras_width (int) Width of image in pixels.
134: * ras_height (int) Height of image in pixels.
135: * ras_depth (int) Bits per pixel. Either 1 or 8 bits.
136: * ras_length (int) Length of image in bytes.
137: * ras_type (int) Type of file. Assumed to be RT_STANDARD (1) if
138: * produced by a screendump command.
139: * ras_maptype (int) Type of color map.
140: * ras_maplength (int) Length of color map in bytes.
141: *
142: */
143:
144: /* Ras_maplength bytes of Color map data. */
145:
146: /* Ras_length bytes of Image data. */
147:
148: /* Buffer and Input Modes... */
149: #define LITERAL 0
150: #define COPY 1
151: #define IGNORE 2
152:
153: /* Transmission Variables. */
154: int BufCount;
155:
156: unsigned char Buffer[128],
157: CurrByte,
158: NextByte,
159: *BufferP = Buffer;
160:
161: /* Diagnostic Variables. */
162: int DiagNLongRuns = 0,
163: DiagMaxRunLength = 0,
164: DiagNumRuns = 0;
165: double DiagSumRunLength = 0;
166:
167: postmain(argc,argv,width,height)
168: int argc;
169: char **argv;
170: int width, height;
171: {
172: char *filename;
173: double sizex, sizey, transx, transy, rotate;
174:
175: extern double atof();
176:
177: filename = "STDIN";
178: sizex = 7.5;
179: sizey = 10.0;
180: transx = transy = 0.5;
181: rotate = 0.0;
182:
183: while(--argc > 0)
184: {
185: ++argv;
186: if((*argv)[0] == '-')
187: {
188: switch((*argv)[1])
189: {
190: case 'l':
191: case 'L':
192: Land = 1;
193: break;
194:
195: case 's':
196: case 'S':
197: sizex = atof(*++argv);
198: sizey = atof(*++argv);
199: argc -= 2;
200: break;
201:
202: case 't':
203: case 'T':
204: transx = atof(*++argv);
205: transy = atof(*++argv);
206: argc -= 2;
207: break;
208:
209: case 'r':
210: case 'R':
211: rotate = atof(*++argv);
212: argc--;
213: break;
214:
215: case 'I':
216: case 'i':
217: Inv = 1;
218: break;
219:
220: case 'A':
221: case 'a':
222: Aspect = 1;
223: break;
224:
225: default:
226: fprintf(stderr,"Illegal switch %c - ignored\n",
227: (*argv)[1]);
228: }
229: }
230: }
231: if (Land)
232: {
233: transx = 8.0;
234: transy = 0.5;
235: sizex = 10.0;
236: sizey = 7.5;
237: rotate = 90.0;
238: }
239: if (Aspect) {
240: if ((sizex / width) < (sizey / height)) {
241: sizey = sizex * (height * 1.0 / width);
242: }
243: else {
244: sizex = sizey * (width * 1.0 / height);
245: }
246: }
247: PrintPostScriptRoutines(height, width, 1 /*depth*/ ,
248: transx, transy, sizex, sizey, rotate);
249: }
250:
251: /******************************************************************************
252: * I/O Routines. *
253: ******************************************************************************/
254: int
255: gb() /* Get a byte from Fp. */
256: {
257: int byte;
258:
259: if (!feof(Fp))
260: byte = getc(Fp);
261: else
262: Error("Premature EOF.\n");
263: if (ferror(Fp))
264: Error("I/O Error.\n");
265: return(Revbyte[byte]);
266: }
267:
268: SendHex(Byte) /* Send a Hex char to Stdout. */
269: unsigned char Byte;
270: {
271: static int LineCount = 0;
272:
273: printf("%02x", 0xff & Byte);
274: if (++LineCount == Rasbytes)
275: {
276: putchar('\n');
277: LineCount = 0;
278: }
279: }
280:
281: int
282: SendBuffer(Inv) /* Send a buffer to Stdout. Return BytesSent. */
283: int Inv;
284: {
285: int i, BytesSent;
286:
287: if (BufferMode() == LITERAL)
288: {
289: SendHex( (unsigned char) 0xff & BufCount );
290: for (i = 0; i < BufCount+1; i++)
291: {
292: SendHex( (Inv) ? Buffer[i] : ~Buffer[i]);
293: }
294: BytesSent = BufCount+2;
295: }
296: else if (BufferMode() == COPY)
297: {
298: SendHex( (unsigned char) 0xff & (0x100 + BufCount) );
299: SendHex( (Inv) ? Buffer[0] : ~Buffer[0]);
300: BytesSent = 2;
301: DiagRecLRun(mag(BufCount)+1);
302: }
303: return(BytesSent);
304: }
305:
306: /******************************************************************************
307: * Utility Routines. *
308: ******************************************************************************/
309: int
310: mag(Byte) /* Magitude of a signed char. */
311: int Byte;
312: {
313: if (Byte & 0x80)
314: {
315: /* Signed */
316: Byte = ~(--Byte);
317: }
318: return( 0xff & Byte );
319: }
320:
321: /******************************************************************************
322: * Buffer Management Routines. *
323: ******************************************************************************/
324: int
325: InputMode()
326: {
327: if (CurrByte == NextByte)
328: return(COPY);
329: return(LITERAL);
330: }
331:
332: int
333: BufferMode()
334: {
335: if (BufCount >= 0 && BufCount <= 127)
336: return(LITERAL);
337: else if (BufCount >= -127 && BufCount <= -1)
338: return(COPY);
339: return(IGNORE);
340: }
341:
342: InitLitMode(NBytes, Inv)
343: int *NBytes, Inv;
344: {
345: BufferP = Buffer;
346: BufCount = -1;
347: ContLitMode(NBytes, Inv);
348: }
349:
350: ContLitMode(NBytes, Inv)
351: int *NBytes, Inv;
352: {
353: if (BufCount == 127)
354: {
355: SendBuffer(Inv);
356: BufferP = Buffer;
357: BufCount = -1;
358: }
359: *BufferP++ = CurrByte;
360: BufCount++;
361: CurrByte = NextByte;
362: NextByte = (unsigned char) gb();
363: (*NBytes)--;
364: }
365:
366: InitCopyMode(NBytes, Inv)
367: int *NBytes, Inv;
368: {
369: BufferP = Buffer;
370: *BufferP++ = CurrByte;
371: BufCount = -1;
372: CurrByte = (unsigned char) gb();
373: NextByte = (unsigned char) gb();
374: *NBytes -= 2;
375: }
376:
377: ContCopyMode(NBytes, Inv)
378: int *NBytes, Inv;
379: {
380: if (BufCount == -127)
381: {
382: SendBuffer(Inv);
383: InitCopyMode(NBytes, Inv);
384: DiagNLongRuns++;
385: }
386: BufCount--;
387: CurrByte = NextByte;
388: NextByte = gb();
389: (*NBytes)--;
390: }
391:
392: /******************************************************************************
393: * Encoding Algorithm. *
394: ******************************************************************************/
395: int
396: Encode(NBytes, Inv)
397: int NBytes, Inv;
398: {
399: int BytesSent = 0;
400:
401: /* Initialize Buffer, BufCount, NextByte, CurrByte */
402: CurrByte = (unsigned char) gb();
403: NextByte = (unsigned char) gb();
404: if (InputMode() == LITERAL)
405: {
406: InitLitMode(&NBytes, Inv);
407: }
408: else
409: {
410: InitCopyMode(&NBytes, Inv);
411: }
412: while (NBytes > 3)
413: {
414: switch(BufferMode())
415: {
416: case LITERAL:
417: if (InputMode() == COPY)
418: {
419: BytesSent += SendBuffer(Inv);
420: InitCopyMode(&NBytes, Inv);
421: }
422: else
423: {
424: ContLitMode(&NBytes, Inv);
425: }
426: break;
427: case COPY:
428: if (CurrByte == Buffer[0])
429: {
430: ContCopyMode(&NBytes, Inv);
431: }
432: else
433: {
434: BytesSent += SendBuffer(Inv);
435: if (InputMode() == COPY)
436: {
437: InitCopyMode(&NBytes, Inv);
438: }
439: else
440: {
441: InitLitMode(&NBytes, Inv);
442: }
443: }
444: break;
445: default:
446: Error("Bad Buffer Mode... Sorry\n");
447: break;
448: }
449: }
450: BytesSent += SendBuffer(Inv);
451: /* Send out rem'g 2-3 bytes in LITERAL mode. */
452: Buffer[0] = CurrByte;
453: Buffer[1] = NextByte;
454: if (NBytes == 3)
455: Buffer[2] = gb();
456: BufCount = NBytes-1;
457: BytesSent += SendBuffer(Inv);
458: return(BytesSent);
459: }
460:
461: /******************************************************************************
462: * Diagnostic Routines. *
463: ******************************************************************************/
464: DiagRecLRun(Rlength)
465: int Rlength;
466: {
467: #ifdef DIAGS
468: if (Rlength > DiagMaxRunLength)
469: DiagMaxRunLength = Rlength;
470: DiagSumRunLength += Rlength;
471: DiagNumRuns++;
472: #endif
473: }
474:
475: Diags()
476: {
477: #ifdef DIAGS
478: fprintf(stderr, "Longest Run (<= 128) = %d\n", DiagMaxRunLength);
479: fprintf(stderr, "Number of Runs over 128 = %d\n", DiagNLongRuns);
480: fprintf(stderr, "Average Run Length of %d. (%d Runs)\n",
481: (int) DiagSumRunLength / DiagNumRuns, DiagNumRuns);
482: #endif
483: }
484:
485: /******************************************************************************
486: * PostScript Output Routines. *
487: ******************************************************************************/
488: PrintPostScriptRoutines(ras_h, ras_w, ras_d, tx, ty, sx, sy, rot)
489: int ras_h, ras_w, ras_d;
490: double tx, ty, sx, sy, rot;
491: {
492: printf("%%!\n/inch {72 mul} def\n");
493: printf("/bpp %d def\n", ras_d);
494: printf("/scanlines %d def\n", ras_h);
495: printf("/scansize %d def\n", ras_w);
496: printf("/bitmapx\n{");
497: printf(" %d %d %d [%d 0 0 %d 0 %d] ", ras_w, ras_h, ras_d, ras_w,
498: -ras_h, ras_h);
499: printf("{currentfile readrlehexstring pop } image\n} def\n");
500: printf("gsave\n");
501: printf("%f inch %f inch translate\n",tx, ty);
502: printf("%f rotate\n", rot );
503: printf("%f inch %f inch scale\n", sx, sy);
504: printf("/readrlehexstring\t%% rle_file => decoded_string boolean\n");
505: printf("{\n\t/fileptr exch def\n\tfileptr 1 string readhexstring {");
506: printf("\n\t\t0 get dup 128 and 0 eq\n");
507: printf("\t\t{ 1 add /Buffer exch string def\n");
508: printf("\t\t\tfileptr Buffer readhexstring\n\t\t}\n\t\t{");
509: printf(" 256 exch sub /BufCount exch def\n");
510: printf("\t\t\t/Buffer BufCount 1 add string def\n");
511: printf("\t\t\t/RunInt fileptr 1 string readhexstring");
512: printf(" pop 0 get def\n");
513: printf("\t\t\t0 1 BufCount { RunInt Buffer 3 1 roll put } for\n");
514: printf("\t\t\tBuffer true\n\t\t} ifelse\n\t}\n\t{ false } ifelse\n");
515: printf("} def\n");
516: printf("/clipathx\n{\tnewpath\n\t0 0 moveto\n\t%f inch 0", sx);
517: printf(" lineto\n\t%f inch %f inch lineto\n\t0 %f inch lineto\n",
518: sx, sy, sy);
519: printf("\tclosepath\n} def\nclipathx clip\n");
520: printf("bitmapx\n");
521: }
522:
523: PrintPostScriptClosing()
524: {
525: printf("\ngrestore\n");
526: printf("showpage\n");
527: }
528:
529: /******************************************************************************
530: * Error Routine. *
531: ******************************************************************************/
532: Error(S1, S2, S3)
533: char *S1, *S2, *S3;
534: {
535: fprintf(stderr, S1, S2, S3);
536: exit(-1);
537: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.