src/px/ra_pict.c

#ifndef lint
static char SCCSid[] = "$SunId$ Auckuni";
#endif

/*
 *      rad2pict - 
 *              Convert an Radiance image to APPLE pict format.
 *
 *                      Orginally Iris to PICT by       Paul Haeberli - 1990
 *                      Hacked into Rad to PICT by Russell Street 1990
 *
 *      History:
 *          V 1                 -- Does basic conversion
 *          V 1.1 (2/11/91)     -- Added options for Gamma
 *                              -- verbose option
 *                              -- man page
 *                              -- better about allocating buffers
 *          V 1.2 (19/11/91)    -- Revised to handle opening "The Radiance Way"
 *                              -- Added exposure level adjustment
 */

#include <stdio.h>

#include "pict.h"
#include "color.h"
#include "resolu.h"

extern double   atof();
extern char     *malloc();

int     outbytes;                   /* This had better be 32 bits! */
char    *progname;
int     verbose = 0;
float   gamma = 2.0;
int     bradj = 0;

        /* First some utility routines */

putrect(xorg,yorg,xsize,ysize)
int xorg, yorg, xsize, ysize;
{
    putashort(yorg);
    putashort(xorg);
    putashort(ysize);
    putashort(xsize);
}

putfprect(xorg,yorg,xsize,ysize)
int xorg, yorg, xsize, ysize;
{
    putalong(yorg<<16);
    putalong(xorg<<16);
    putalong(ysize<<16);
    putalong(xsize<<16);
}

putalong(l)
long l;
{
    putbyte((l>>24)&0xff);
    putbyte((l>>16)&0xff);
    putbyte((l>>8)&0xff);
    putbyte((l>>0)&0xff);
}

putashort(s)
short s;
{
    putbyte((s>>8)&0xff);
    putbyte((s>>0)&0xff);
}

putbyte(b)
int b;
{
    if (putc(b,stdout) == EOF && ferror(stdout)) {
        fprintf(stderr,"%s: error on write\n", progname);
        exit(1);
    }
    outbytes++;
}

putbytes(buf,n)
unsigned char *buf;
int n;
{
    if(!fwrite(buf,n,1,stdout)) {
        fprintf(stderr,"%s: error on write\n", progname);
        exit(1);
    }
    outbytes+=n;
}

main(argc,argv)
int argc;
char **argv;
{
    int xsize, ysize;
    int i, picsize;
    int ssizepos, lsizepos;

    progname = argv[0];

    for (i = 1; i < argc ; i++)
        if (argv[i][0] ==  '-')
            switch (argv[i][1]) {
                case 'g':       gamma = atof(argv[++i]);
                                break;

                case 'e':       if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
                                   usage();
                                else
                                    bradj = atoi(argv[++i]);
                                break;

                case 'v':       ;
                                verbose = 1;
                                break;

                case 'r':       fprintf(stderr, "Sorry. Get a Macintosh :-)\n");
                                exit(1);

                case '-':       i++;
                                goto outofparse;
                                break;              /* NOTREACHED */

                otherwise:      usage();
                                break;
                 }
        else
            break;

outofparse:

    if (i < argc - 2)
        usage();

    if (i <= argc - 1 && freopen(argv[i], "r", stdin) == NULL) {
        fprintf(stderr, "%s: can not open input \"%s\"\n",
            progname, argv[i]);
        exit(1);
    }

    if (i <= argc - 2 && freopen(argv[i+1], "w", stdout) == NULL) {
        fprintf(stderr, "%s: can not open input \"%s\"\n",
            progname, argv[i+1]);
        exit(1);
    }
        
#ifdef DEBUG
        fprintf(stderr, "Input file: %s\n", i <= argc - 1 ? argv[i] : "stdin");
        fprintf(stderr, "Outut file: %s\n", i <= argc - 2 ? argv[i+1] : "stdout" );
        fprintf(stderr, "Gamma: %f\n", gamma);
        fprintf(stderr, "Brightness adjust: %d\n", bradj);
        fprintf(stderr, "Verbose: %s\n", verbose ? "on" : "off");
#endif


             /* OK. Now we read the size of the Radiance picture */
    if (checkheader(stdin, COLRFMT, NULL) < 0 ||
            fgetresolu(&xsize, &ysize, stdin) < 0 /* != (YMAJOR|YDECR) */ ) {
        fprintf(stderr, "%s: not a radiance picture\n", progname);
        exit(1);
        }

            /* Set the gamma correction */

    setcolrgam(gamma);

    for(i=0; i<HEADER_SIZE; i++) 
        putbyte(0);

    ssizepos = outbytes;
    putashort(0);               /* low 16 bits of file size less HEADER_SIZE */
    putrect(0,0,xsize,ysize);   /* bounding box of picture */
    putashort(PICT_picVersion);
    putashort(0x02ff);          /* version 2 pict */
    putashort(PICT_reservedHeader);     /* reserved header opcode */

    lsizepos = outbytes;
    putalong(0);                /* full size of the file */
    putfprect(0,0,xsize,ysize); /* fixed point bounding box of picture */
    putalong(0);                /* reserved */

    putashort(PICT_clipRgn);    /* the clip region */
    putashort(10);
    putrect(0,0,xsize,ysize);

    if (verbose)
        fprintf(stderr, "%s: The picture is %d by %d, with a gamma of %f\n",
            progname, xsize, ysize, gamma);


    putpict(xsize, ysize);      /* Here is where all the work is done */

    putashort(PICT_EndOfPicture); /* end of pict */

    picsize = outbytes-HEADER_SIZE;
    fseek(stdout,ssizepos,0);
    putashort(picsize&0xffff);
    fseek(stdout,lsizepos,0);
    putalong(picsize);

    fclose(stdout);
    fclose(stdin);
    
    exit(0);
    return 0;       /* lint fodder */
}

putpict(xsize, ysize)
int xsize;
int ysize;
{
    int     y;
    int     nbytes, rowbytes;
    char    *cbuf, *pbuf;

    cbuf = malloc(4 * xsize);

    if (cbuf == NULL) {
        fprintf(stderr, "%s: not enough memory\n", progname);
        exit(1);
        }

    pbuf = malloc(4 * xsize);

    if (pbuf == NULL) {
        fprintf(stderr, "%s: not enough memory\n", progname);
        exit(1);
        }

    putashort(PICT_Pack32BitsRect); /* 32 bit rgb */
    rowbytes = 4*xsize;
    putalong(0x000000ff);               /* base address */


    if(rowbytes&1)
        rowbytes++;
    putashort(rowbytes|0x8000); /* rowbytes */
    putrect(0,0,xsize,ysize);   /* bounds */
    putashort(0);               /* version */

    putashort(4);       /* packtype */
    putalong(0);        /* packsize */
    putalong(72<<16);   /* hres */
    putalong(72<<16);   /* vres */

    putashort(16);      /* pixeltype */
    putashort(32);      /* pixelsize */
    putashort(3);       /* cmpcount */


    putashort(8);       /* cmpsize */
    putalong(0);        /* planebytes */
    putalong(0);        /* pmtable */
    putalong(0);        /* pmreserved */


    putrect(0,0,xsize,ysize);   /* scr rect */
    putrect(0,0,xsize,ysize);   /* dest rect */


    putashort(0x40);    /* transfer mode */

    for(y=0; y<ysize; y++) {
        getrow(stdin, cbuf, xsize);

        nbytes = packbits(cbuf,pbuf,24*xsize);
        if(rowbytes>250) 
            putashort(nbytes);
        else
            putbyte(nbytes);
        putbytes(pbuf,nbytes);
        }

    if(outbytes&1) 
        putbyte(0);

    free(cbuf);
    free(pbuf);
}

int getrow(in, cbuf, xsize)
FILE *in;
char *cbuf;
int xsize;
{
    extern char *tempbuffer();          /* defined in color.c */
    COLR    *scanin = NULL;
    int     x;

    if ((scanin = (COLR *)tempbuffer(xsize*sizeof(COLR))) == NULL) {
        fprintf(stderr, "%s: not enough memory\n", progname);
        exit(1);
    }

    if (freadcolrs(scanin, xsize, in) < 0) {
        fprintf(stderr, "%s: read error\n", progname);
        exit(1);
        }

    if (bradj)      /* Adjust exposure level */
        shiftcolrs(scanin, xsize, bradj);


    colrs_gambs(scanin, xsize);     /* Gamma correct it */
    
    for (x = 0; x < xsize; x++) {
        cbuf[x] = scanin[x][RED];
        cbuf[xsize + x] = scanin[x][GRN];
        cbuf[2*xsize + x] = scanin[x][BLU];
        }

}


packbits(ibits,pbits,nbits)
unsigned char *ibits, *pbits;
int nbits;
{
    int bytes;                      /* UNUSED */
    unsigned char *sptr;
    unsigned char *ibitsend;
    unsigned char *optr = pbits;
    int nbytes, todo, cc, count;

    nbytes = ((nbits-1)/8)+1;
    ibitsend = ibits+nbytes;
    while(ibits<ibitsend) {
        sptr = ibits;
        ibits += 2;
        while((ibits<ibitsend)&&((ibits[-2]!=ibits[-1])||(ibits[-1]!=ibits[0])))
            ibits++;
        if(ibits != ibitsend) {
            ibits -= 2;
        }
        count = ibits-sptr;
        while(count) {
            todo = count>127 ? 127:count;
            count -= todo;
            *optr++ = todo-1;
            while(todo--)
                *optr++ = *sptr++;
        }
        if(ibits == ibitsend)
            break;
        sptr = ibits;
        cc = *ibits++;
        while( (ibits<ibitsend) && (*ibits == cc) )
            ibits++;
        count = ibits-sptr;
        while(count) {
            todo = count>128 ? 128:count;
            count -= todo;
            *optr++ = 257-todo;
            *optr++ = cc;
        }
    }
    return optr-pbits;
}

usage()
{
    fprintf(stderr, "Usage: %s [-v] [-g gamma] [infile [outfile]]\n",
        progname);
    exit(2);
}
Revision:	2.3
Committed:	Wed Nov 27 09:14:03 1991 UTC (32 years, 5 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.2:	+3 -1 lines
Log Message:	removed reference to stdlib.h
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.2	static char SCCSid[] = "$SunId$ Auckuni";
3	greg	1.1	#endif
4	greg	1.4
5	greg	1.1	/*
6	greg	2.2	* rad2pict -
7			* Convert an Radiance image to APPLE pict format.
8			*
9			* Orginally Iris to PICT by Paul Haeberli - 1990
10			* Hacked into Rad to PICT by Russell Street 1990
11			*
12			* History:
13			* V 1 -- Does basic conversion
14			* V 1.1 (2/11/91) -- Added options for Gamma
15			* -- verbose option
16			* -- man page
17			* -- better about allocating buffers
18			* V 1.2 (19/11/91) -- Revised to handle opening "The Radiance Way"
19			* -- Added exposure level adjustment
20			*/
21
22	greg	1.1	#include <stdio.h>
23	greg	2.2
24	greg	1.1	#include "pict.h"
25			#include "color.h"
26	greg	1.4	#include "resolu.h"
27	greg	2.3
28			extern double atof();
29			extern char *malloc();
30	greg	1.3
31	greg	2.2	int outbytes; /* This had better be 32 bits! */
32			char *progname;
33			int verbose = 0;
34			float gamma = 2.0;
35			int bradj = 0;
36	greg	1.1
37	greg	2.2	/* First some utility routines */
38	greg	1.1
39			putrect(xorg,yorg,xsize,ysize)
40			int xorg, yorg, xsize, ysize;
41			{
42			putashort(yorg);
43			putashort(xorg);
44			putashort(ysize);
45			putashort(xsize);
46			}
47
48			putfprect(xorg,yorg,xsize,ysize)
49			int xorg, yorg, xsize, ysize;
50			{
51			putalong(yorg<<16);
52			putalong(xorg<<16);
53			putalong(ysize<<16);
54			putalong(xsize<<16);
55			}
56
57			putalong(l)
58			long l;
59			{
60			putbyte((l>>24)&0xff);
61			putbyte((l>>16)&0xff);
62			putbyte((l>>8)&0xff);
63			putbyte((l>>0)&0xff);
64			}
65
66			putashort(s)
67			short s;
68			{
69			putbyte((s>>8)&0xff);
70			putbyte((s>>0)&0xff);
71			}
72
73			putbyte(b)
74	greg	2.2	int b;
75	greg	1.1	{
76	greg	2.2	if (putc(b,stdout) == EOF && ferror(stdout)) {
77			fprintf(stderr,"%s: error on write\n", progname);
78	greg	1.1	exit(1);
79			}
80			outbytes++;
81			}
82
83			putbytes(buf,n)
84			unsigned char *buf;
85			int n;
86			{
87	greg	2.2	if(!fwrite(buf,n,1,stdout)) {
88			fprintf(stderr,"%s: error on write\n", progname);
89	greg	1.1	exit(1);
90			}
91			outbytes+=n;
92			}
93
94			main(argc,argv)
95			int argc;
96			char **argv;
97			{
98			int xsize, ysize;
99			int i, picsize;
100			int ssizepos, lsizepos;
101
102	greg	2.2	progname = argv[0];
103	greg	1.1
104	greg	2.2	for (i = 1; i < argc ; i++)
105			if (argv[i][0] == '-')
106			switch (argv[i][1]) {
107			case 'g': gamma = atof(argv[++i]);
108			break;
109	greg	1.1
110	greg	2.2	case 'e': if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
111			usage();
112			else
113			bradj = atoi(argv[++i]);
114			break;
115
116			case 'v': ;
117			verbose = 1;
118			break;
119
120			case 'r': fprintf(stderr, "Sorry. Get a Macintosh :-)\n");
121			exit(1);
122
123			case '-': i++;
124			goto outofparse;
125			break; /* NOTREACHED */
126
127			otherwise: usage();
128			break;
129			}
130			else
131			break;
132
133			outofparse:
134
135			if (i < argc - 2)
136			usage();
137
138			if (i <= argc - 1 && freopen(argv[i], "r", stdin) == NULL) {
139			fprintf(stderr, "%s: can not open input \"%s\"\n",
140			progname, argv[i]);
141	greg	1.1	exit(1);
142			}
143
144	greg	2.2	if (i <= argc - 2 && freopen(argv[i+1], "w", stdout) == NULL) {
145			fprintf(stderr, "%s: can not open input \"%s\"\n",
146			progname, argv[i+1]);
147	greg	1.1	exit(1);
148			}
149	greg	2.2
150			#ifdef DEBUG
151			fprintf(stderr, "Input file: %s\n", i <= argc - 1 ? argv[i] : "stdin");
152			fprintf(stderr, "Outut file: %s\n", i <= argc - 2 ? argv[i+1] : "stdout" );
153			fprintf(stderr, "Gamma: %f\n", gamma);
154			fprintf(stderr, "Brightness adjust: %d\n", bradj);
155			fprintf(stderr, "Verbose: %s\n", verbose ? "on" : "off");
156			#endif
157	greg	1.1
158	greg	2.2
159			/* OK. Now we read the size of the Radiance picture */
160			if (checkheader(stdin, COLRFMT, NULL) < 0 \|\|
161			fgetresolu(&xsize, &ysize, stdin) < 0 /* != (YMAJOR\|YDECR) */ ) {
162			fprintf(stderr, "%s: not a radiance picture\n", progname);
163	greg	1.1	exit(1);
164	greg	2.2	}
165	greg	1.1
166	greg	2.2	/* Set the gamma correction */
167	greg	1.1
168	greg	2.2	setcolrgam(gamma);
169
170	greg	1.1	for(i=0; i<HEADER_SIZE; i++)
171			putbyte(0);
172	greg	2.2
173	greg	1.1	ssizepos = outbytes;
174			putashort(0); /* low 16 bits of file size less HEADER_SIZE */
175			putrect(0,0,xsize,ysize); /* bounding box of picture */
176			putashort(PICT_picVersion);
177			putashort(0x02ff); /* version 2 pict */
178			putashort(PICT_reservedHeader); /* reserved header opcode */
179
180			lsizepos = outbytes;
181			putalong(0); /* full size of the file */
182			putfprect(0,0,xsize,ysize); /* fixed point bounding box of picture */
183			putalong(0); /* reserved */
184
185			putashort(PICT_clipRgn); /* the clip region */
186			putashort(10);
187			putrect(0,0,xsize,ysize);
188
189	greg	2.2	if (verbose)
190			fprintf(stderr, "%s: The picture is %d by %d, with a gamma of %f\n",
191			progname, xsize, ysize, gamma);
192	greg	1.1
193	greg	2.2
194			putpict(xsize, ysize); /* Here is where all the work is done */
195
196	greg	1.1	putashort(PICT_EndOfPicture); /* end of pict */
197
198			picsize = outbytes-HEADER_SIZE;
199	greg	2.2	fseek(stdout,ssizepos,0);
200	greg	1.1	putashort(picsize&0xffff);
201	greg	2.2	fseek(stdout,lsizepos,0);
202	greg	1.1	putalong(picsize);
203
204	greg	2.2	fclose(stdout);
205			fclose(stdin);
206
207	greg	1.1	exit(0);
208	greg	2.2	return 0; /* lint fodder */
209	greg	1.1	}
210
211			putpict(xsize, ysize)
212			int xsize;
213			int ysize;
214			{
215	greg	2.2	int y;
216			int nbytes, rowbytes;
217			char cbuf, pbuf;
218	greg	1.1
219	greg	2.2	cbuf = malloc(4 * xsize);
220
221			if (cbuf == NULL) {
222			fprintf(stderr, "%s: not enough memory\n", progname);
223			exit(1);
224			}
225
226			pbuf = malloc(4 * xsize);
227
228			if (pbuf == NULL) {
229			fprintf(stderr, "%s: not enough memory\n", progname);
230			exit(1);
231			}
232
233	greg	1.1	putashort(PICT_Pack32BitsRect); /* 32 bit rgb */
234			rowbytes = 4*xsize;
235			putalong(0x000000ff); /* base address */
236
237	greg	2.2
238	greg	1.1	if(rowbytes&1)
239			rowbytes++;
240			putashort(rowbytes\|0x8000); /* rowbytes */
241			putrect(0,0,xsize,ysize); /* bounds */
242			putashort(0); /* version */
243
244			putashort(4); /* packtype */
245			putalong(0); /* packsize */
246			putalong(72<<16); /* hres */
247			putalong(72<<16); /* vres */
248
249			putashort(16); /* pixeltype */
250			putashort(32); /* pixelsize */
251			putashort(3); /* cmpcount */
252
253	greg	2.2
254	greg	1.1	putashort(8); /* cmpsize */
255			putalong(0); /* planebytes */
256			putalong(0); /* pmtable */
257			putalong(0); /* pmreserved */
258
259	greg	2.2
260	greg	1.1	putrect(0,0,xsize,ysize); /* scr rect */
261			putrect(0,0,xsize,ysize); /* dest rect */
262
263	greg	2.2
264	greg	1.1	putashort(0x40); /* transfer mode */
265	greg	2.2
266	greg	1.1	for(y=0; y<ysize; y++) {
267	greg	2.2	getrow(stdin, cbuf, xsize);
268	greg	1.1
269			nbytes = packbits(cbuf,pbuf,24*xsize);
270			if(rowbytes>250)
271			putashort(nbytes);
272			else
273			putbyte(nbytes);
274			putbytes(pbuf,nbytes);
275	greg	2.2	}
276	greg	1.1
277			if(outbytes&1)
278			putbyte(0);
279	greg	2.2
280			free(cbuf);
281			free(pbuf);
282	greg	1.1	}
283
284	greg	2.2	int getrow(in, cbuf, xsize)
285			FILE *in;
286			char *cbuf;
287			int xsize;
288	greg	1.1	{
289	greg	2.2	extern char tempbuffer(); / defined in color.c */
290			COLR *scanin = NULL;
291	greg	1.1	int x;
292
293	greg	2.2	if ((scanin = (COLR )tempbuffer(xsizesizeof(COLR))) == NULL) {
294			fprintf(stderr, "%s: not enough memory\n", progname);
295			exit(1);
296	greg	1.1	}
297
298			if (freadcolrs(scanin, xsize, in) < 0) {
299	greg	2.2	fprintf(stderr, "%s: read error\n", progname);
300	greg	1.1	exit(1);
301	greg	2.2	}
302	greg	1.1
303	greg	2.2	if (bradj) /* Adjust exposure level */
304			shiftcolrs(scanin, xsize, bradj);
305
306
307			colrs_gambs(scanin, xsize); /* Gamma correct it */
308	greg	1.1
309			for (x = 0; x < xsize; x++) {
310	greg	2.2	cbuf[x] = scanin[x][RED];
311			cbuf[xsize + x] = scanin[x][GRN];
312			cbuf[2*xsize + x] = scanin[x][BLU];
313			}
314
315	greg	1.1	}
316
317	greg	2.2
318	greg	1.1	packbits(ibits,pbits,nbits)
319			unsigned char ibits, pbits;
320			int nbits;
321			{
322	greg	2.2	int bytes; /* UNUSED */
323	greg	1.1	unsigned char *sptr;
324			unsigned char *ibitsend;
325			unsigned char *optr = pbits;
326			int nbytes, todo, cc, count;
327
328			nbytes = ((nbits-1)/8)+1;
329			ibitsend = ibits+nbytes;
330	greg	2.2	while(ibits<ibitsend) {
331	greg	1.1	sptr = ibits;
332			ibits += 2;
333			while((ibits<ibitsend)&&((ibits[-2]!=ibits[-1])\|\|(ibits[-1]!=ibits[0])))
334			ibits++;
335			if(ibits != ibitsend) {
336			ibits -= 2;
337			}
338			count = ibits-sptr;
339			while(count) {
340			todo = count>127 ? 127:count;
341			count -= todo;
342			*optr++ = todo-1;
343			while(todo--)
344			optr++ = sptr++;
345			}
346			if(ibits == ibitsend)
347			break;
348			sptr = ibits;
349			cc = *ibits++;
350			while( (ibits<ibitsend) && (*ibits == cc) )
351			ibits++;
352			count = ibits-sptr;
353			while(count) {
354			todo = count>128 ? 128:count;
355			count -= todo;
356			*optr++ = 257-todo;
357			*optr++ = cc;
358			}
359			}
360			return optr-pbits;
361	greg	2.2	}
362
363			usage()
364			{
365			fprintf(stderr, "Usage: %s [-v] [-g gamma] [infile [outfile]]\n",
366			progname);
367			exit(2);
368	greg	1.1	}