![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mp2res.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / mp2res|
Return to mp2res.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / dipress / src / bin / mp2res |
1.1 root 1: /*
2: * Copyright (c) 1984, 1985, 1986 Xerox Corp.
3: *
4: * This module reads a compressed bitmap file in the MacPaint
5: * format and outputs an RES file.
6: *
7: * For a description of RES (Raster Encoding Standard) see
8: * the booklet entitled "Raster Encoding Standard" XNS Standard 178506
9: * (June, 1985)
10: *
11: * HISTORY
12: * 21-Jul-86 Lee Moore (lee) at Xerox Webster Research Center
13: * Added the ability to generate IP masters, too.
14: *
15: * 07-Jul-86 Lee Moore (lee) at Xerox Webster Research Center
16: * Converted for use with getopt.
17: *
18: * 03-Jun-86 Lee Moore (lee) at Xerox Webster Research Center
19: * Created mp2res from readmac.c .
20: *
21: *
22: * K. Knox, 10-Dec-84 18:51:22, Created readmac.
23: */
24:
25: #include <stdio.h>
26:
27: #include "iptokens.h"
28: #include "literal.h"
29: #include "operator.h"
30:
31: #define err0 "usage: readmac filename\n"
32: #define err1 "mp2res: Could not open, %s.\n"
33:
34: #define TRUE 1
35: #define FALSE 0
36:
37: /* External procedures. */
38: extern char *malloc();
39:
40: /*
41: * Main program
42: * parse command line
43: * call ProcessData to do the work
44: */
45:
46: main(argc, argv)
47: int argc;
48: char *argv[];
49: {
50: int c;
51: int firstRow = 0,
52: lastRow = (720 - 1),
53: firstColumn = 0,
54: lastColumn = (576 - 1),
55: outputFileFD,
56: makeInterpress = FALSE;
57: extern char *optarg;
58: extern optind;
59: FILE *inputFileDesc;
60:
61: outputFileFD = 1; /* standard out */
62:
63: while ((c = getopt(argc, argv, "it:b:l:o:r:")) != EOF)
64: switch (c) {
65: case 'i':
66: makeInterpress = TRUE;
67: break;
68:
69: case 't': /* top */
70: firstRow = atoi(optarg);
71: break;
72:
73: case 'b': /* bottom */
74: lastRow = atoi(optarg);
75: break;
76:
77: case 'l': /* left */
78: firstColumn = atoi(optarg);
79: break;
80:
81: case 'o': /* output file */
82: if( (outputFileFD = creat(optarg, 0664)) < 0) {
83: fprintf(stderr, "mp2res: can't open %s for writing\n", optarg);
84: perror(optarg);
85: exit(1);
86: }
87: break;
88:
89: case 'r': /* right */
90: lastColumn = atoi(optarg);
91: break;
92:
93: default:
94: printf("ipmetrics: option '%c' not allowed\n");
95: }
96:
97: /* do we read from standard input? */
98: if (argc == optind) {
99: inputFileDesc = stdin;
100: } else {
101: /* open the MacPaint file */
102: if ((inputFileDesc = fopen(argv[optind], "r")) == NULL)
103: fprintf(stderr, err1, argv[optind]);
104: }
105:
106: if (! makeInterpress )
107: MakeRES(inputFileDesc, outputFileFD,
108: firstRow, lastRow, firstColumn, lastColumn);
109: else
110: MakeIP(inputFileDesc, outputFileFD,
111: firstRow, lastRow, firstColumn, lastColumn);
112:
113: exit(0);
114: }
115:
116:
117: /*
118: * Convert a MacPaint document to an RES file
119: * don't copy the data that the user doesn't want
120: */
121:
122: MakeRES(inputFileDesc, outputFileFD,
123: firstRow, lastRow, firstColumn, lastColumn)
124: FILE *inputFileDesc;
125: int outputFileFD,
126: firstRow, lastRow, firstColumn, lastColumn;
127: {
128: int i,
129: bufferSize;
130: int pixelsPerScanLine,
131: numberOfScanLines,
132: bytesPerScanLine;
133: unsigned char *image, *p;
134:
135: pixelsPerScanLine = lastColumn - firstColumn + 1;
136: numberOfScanLines = lastRow - firstRow + 1;
137:
138: if( pixelsPerScanLine % 32 != 0 )
139: fprintf(stderr, "internal error: %d is not a multiple of 32\n", pixelsPerScanLine);
140:
141: bytesPerScanLine = (pixelsPerScanLine + 7)/8;
142:
143: /* skip over MacPaint header */
144: for (i=0; i < 512; i++)
145: getc(inputFileDesc);
146:
147: bufferSize = bytesPerScanLine * numberOfScanLines;
148: image = (unsigned char *) malloc((unsigned) bufferSize);
149:
150: res_select(outputFileFD);
151:
152: AppendOp(OP_beginBlock);
153:
154: /* element 1: imageScale */
155: AppendRational(254L, 72L*100*100); /* assume 72 spots/inch */
156: AppendOp(OP_dup);
157: AppendInteger(2L);
158: AppendOp(OP_makevec);
159:
160: /* element 2: xDimension */
161: AppendInteger((long) pixelsPerScanLine); /* xPixels */
162:
163: /* element 3: yDimension */
164: AppendInteger((long) numberOfScanLines); /* yPixels */
165:
166: /* element 4: maskImage */
167: AppendInteger(0L); /* maskImage */
168:
169: /* element 5: colorImage */
170: AppendInteger((long) numberOfScanLines); /* yPixels */
171: AppendInteger((long) pixelsPerScanLine); /* xPixels */
172: AppendInteger(1L); /* sampelsPerPixel */
173: AppendInteger(1L); /* maxSampleValue */
174: AppendInteger(1L); /* samplesInterleaved */
175:
176: /* enter transformation to bring it to row major order */
177: AppendInteger(-90L);
178: AppendOp(OP_rotate);
179: AppendInteger(0L);
180: AppendInteger((long) numberOfScanLines);
181: AppendOp(OP_translate);
182: AppendOp(OP_concat);
183:
184: /* skip over as many rows as needed */
185: for (i = 0; i < firstRow; i++)
186: readscan(inputFileDesc, image);
187:
188: /* read the scan lines in */
189: for (i = firstRow, p = image; i <= lastRow; i++, p += bytesPerScanLine)
190: readscan(inputFileDesc, p);
191:
192: AppendPPVector(bufferSize, 1, pixelsPerScanLine, (unsigned char *) image);
193:
194: Op(makepixelarray); /* make the array */
195:
196: /* element 6: colorOperator */
197: AppendInteger(0L);
198:
199: /* element 7: image Properties */
200: AppendIdentifier("imageDescription");
201: AppendString("made from a MacPaint file");
202: Makevec(2);
203:
204: /* element 8: signature */
205: AppendInteger(13086L);
206:
207: AppendOp(OP_endBlock);
208:
209: ip_flush();
210:
211: free((char *) image);
212: }
213:
214: MakeIP(inputFileDesc, outputFileFD,
215: firstRow, lastRow, firstColumn, lastColumn)
216: FILE *inputFileDesc;
217: int outputFileFD,
218: firstRow, lastRow, firstColumn, lastColumn;
219: {
220: int i,
221: bufferSize;
222: int pixelsPerScanLine,
223: numberOfScanLines,
224: bytesPerScanLine;
225: unsigned char *image, *p;
226:
227: pixelsPerScanLine = lastColumn - firstColumn + 1;
228: numberOfScanLines = lastRow - firstRow + 1;
229:
230: if( pixelsPerScanLine % 32 != 0 )
231: fprintf(stderr, "%d is not a multiple of 32\n", pixelsPerScanLine);
232:
233: bytesPerScanLine = (pixelsPerScanLine + 7)/8;
234:
235: for (i=0; i < 512; i++)
236: getc(inputFileDesc);
237:
238: bufferSize = bytesPerScanLine * numberOfScanLines;
239: image = (unsigned char *) malloc((unsigned) bufferSize);
240:
241: ip_select(outputFileFD);
242:
243: AppendOp(OP_beginBlock);
244: AppendOp(OP_beginBody);
245: AppendOp(OP_endBody); /* end preamble */
246: AppendOp(OP_beginBody); /* page 1 (and only) */
247:
248: AppendRational(254L, 72L*100*100); /* assume 72 spots/inch */
249: AppendOp(OP_scale);
250: Translate(.5*.0254, .25*.0254);
251: AppendOp(OP_concat);
252: AppendOp(OP_concatt);
253:
254: AppendInteger((long) numberOfScanLines); /* yPixels */
255: AppendInteger((long) pixelsPerScanLine); /* xPixels */
256: AppendInteger(1L); /* sampelsPerPixel */
257: AppendInteger(1L); /* maxSampleValue */
258: AppendInteger(1L); /* samplesInterleaved */
259:
260: /* enter transformation to bring it to row major order */
261: AppendInteger(-90L);
262: AppendOp(OP_rotate);
263: AppendInteger(0L);
264: AppendInteger((long) numberOfScanLines);
265: AppendOp(OP_translate);
266: AppendOp(OP_concat);
267:
268: /* skip over as many rows as needed */
269: for (i = 0; i < firstRow; i++)
270: readscan(inputFileDesc, image);
271:
272: for (i = firstRow, p = image; i <= lastRow; i++, p += bytesPerScanLine)
273: readscan(inputFileDesc, p);
274:
275: /* output the result to the Interpress file */
276: AppendPPVector(bufferSize, 1, pixelsPerScanLine, (unsigned char *) image);
277:
278: Op(makepixelarray); /* make the array */
279:
280: /* draw a box around the pixel array */
281: AppendInteger(1L); /* unit stroke width */
282: AppendInteger(15L); /* stroke width imager variable */
283: AppendOp(OP_iset);
284: AppendRational(-1L, 2L);
285: AppendRational(-1L, 2L);
286: AppendOp(OP_moveto);
287: AppendInteger((long) (numberOfScanLines + 1));
288: AppendOp(OP_linetoy);
289: AppendInteger((long) (pixelsPerScanLine + 1));
290: AppendOp(OP_linetox);
291: AppendRational(-1L, 2L);
292: AppendOp(OP_linetoy);
293: AppendRational(-1L, 2L);
294: AppendOp(OP_linetox);
295: AppendOp(OP_maskstroke);
296:
297: /* prepare to show pixel array */
298: AppendInteger(0L);
299: AppendInteger(0L);
300: AppendOp(OP_setxy);
301: Op(maskpixel); /* show it */
302:
303: AppendOp(OP_endBody);
304: AppendOp(OP_endBlock);
305:
306: ip_flush();
307:
308: free((char *) image);
309: }
310:
311:
312: /*
313: * Read the next scan line from the MacPaint file
314: */
315:
316: readscan(inputFileDesc, image)
317: FILE *inputFileDesc;
318: unsigned char *image;
319: {
320: int in_pos, count, data_byte;
321:
322: in_pos = 0;
323:
324: while (in_pos < 72)
325: {
326: count = getc(inputFileDesc);
327:
328: if (count > 127)
329: count -= 256;
330:
331: if (count >= 0) {
332: /* run of raw bytes */
333: count++; /* # of bytes to read */
334:
335: while (count--)
336: image[in_pos++] = getc(inputFileDesc);
337: }
338: else {
339: /* run of repeated byte */
340: count = -count+1; /* repetition factor */
341: data_byte = getc(inputFileDesc); /* byte to repeat */
342:
343: while (count--)
344: image[in_pos++] = data_byte;
345: }
346: }
347: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.