ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/ra_t8.c
(Generate patch)

Comparing ray/src/px/ra_t8.c (file contents):
Revision 1.1 by greg, Thu Feb 2 10:49:37 1989 UTC vs.
Revision 2.3 by greg, Fri Oct 9 15:24:21 1992 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1992 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 15 | Line 15 | static char SCCSid[] = "$SunId$ LBL";
15  
16   #include  "color.h"
17  
18 + #include  "resolu.h"
19 +
20   #include  "pic.h"
21  
22   #include  "targa.h"
23  
24 + #ifdef MSDOS
25 + #include  <fcntl.h>
26 + #endif
27 +
28 + #include  <math.h>
29 +
30 + #ifndef  BSD
31 + #define  bcopy(s,d,n)           (void)memcpy(d,s,n)
32 + extern char  *memcpy();
33 + #endif
34                          /* descriptor for a picture file or frame buffer */
35   typedef struct {
36          char    *name;                  /* file name */
# Line 31 | Line 43 | typedef struct {
43          } pos;                          /* position(s) */
44   } pic;
45  
46 < #define  goodpic(h)     (my_imType(h) && my_mapType(h))
47 < #define  my_imType(h)   (((h)->dataType==IM_CMAP || (h)->dataType==IM_CCMAP) \
46 > #define  goodpic(h)     (my_imType(h) && my_mapType(h))
47 > #define  my_imType(h)   (((h)->dataType==IM_CMAP || (h)->dataType==IM_CCMAP) \
48                                  && (h)->dataBits==8 && (h)->imType==0)
49 < #define  my_mapType(h)  ((h)->mapType==CM_HASMAP && \
49 > #define  my_mapType(h)  ((h)->mapType==CM_HASMAP && \
50                                  ((h)->CMapBits==24 || (h)->CMapBits==32))
51  
52 < #define  taralloc(h)    (pixel *)emalloc((h)->x*(h)->y*sizeof(pixel))
52 > #define  taralloc(h)    (pixel *)emalloc((h)->x*(h)->y*sizeof(pixel))
53  
54   extern pic      *openinput();
55  
# Line 45 | Line 57 | extern char    *ecalloc(), *emalloc();
57  
58   extern long  ftell();
59  
60 < extern double  atof(), pow();
60 > double  gamma = 2.2;                    /* gamma correction */
61  
62 < double  gamma = 2.0;                    /* gamma correction */
62 > int  bradj = 0;                         /* brightness adjustment */
63  
64   pic     *inpic;
65  
# Line 55 | Line 67 | char  *progname;
67  
68   char  errmsg[128];
69  
70 < COLR    *inline;
70 > COLR    *inl;
71  
72   pixel   *tarData;
73  
# Line 67 | Line 79 | int  argc;
79   char  *argv[];
80   {
81          colormap  rasmap;
82 <        struct hdStruct  head;
82 >        struct hdStruct  head;
83          int  dither = 1;
84          int  reverse = 0;
85          int  ncolors = 256;
86          int  greyscale = 0;
87          int  i;
88 <        
88 > #ifdef MSDOS
89 >        extern int  _fmode;
90 >        _fmode = O_BINARY;
91 >        setmode(fileno(stdin), O_BINARY);
92 >        setmode(fileno(stdout), O_BINARY);
93 > #endif
94          progname = argv[0];
95  
96          for (i = 1; i < argc; i++)
# Line 91 | Line 108 | char  *argv[];
108                          case 'b':
109                                  greyscale = 1;
110                                  break;
111 +                        case 'e':
112 +                                if (argv[i+1][0] != '+' && argv[i+1][0] != '-')
113 +                                        goto userr;
114 +                                bradj = atoi(argv[++i]);
115 +                                break;
116                          case 'c':
117                                  ncolors = atoi(argv[++i]);
118                                  break;
# Line 120 | Line 142 | char  *argv[];
142                          quiterr(errmsg);
143                  }
144                                          /* put header */
145 <                printargs(argc, argv, stdout);
145 >                printargs(i, argv, stdout);
146 >                fputformat(COLRFMT, stdout);
147                  putchar('\n');
148 <                printf("-Y %d +X %d\n", ymax, xmax);
148 >                fprtresolu(xmax, ymax, stdout);
149                                          /* convert file */
150                  tg2ra(&head);
151          } else {
152 <                if (i > argc-1 || i < argc-2)
152 >                if (i < argc-2 || (!greyscale && i > argc-1))
153                          goto userr;
154                  if ((inpic = openinput(argv[i], &head)) == NULL) {
155                          sprintf(errmsg, "can't open input \"%s\"", argv[i]);
# Line 149 | Line 172 | char  *argv[];
172          quiterr(NULL);
173   userr:
174          fprintf(stderr,
175 <        "Usage: %s [-d][-c ncolors][-b][-g gamma] input [output]\n",
175 >        "Usage: %s [-d][-c ncolors][-b][-g gamma][-e +/-stops] input [output]\n",
176                          progname);
177 <        fprintf(stderr, "   Or: %s -r [-g gamma] [input [output]]\n",
177 >        fprintf(stderr, "   Or: %s -r [-g gamma][-e +/-stops] [input [output]]\n",
178                          progname);
179          exit(1);
180   }
# Line 205 | Line 228 | int code;
228  
229  
230   getthead(hp, ip, fp)            /* read header from input */
231 < struct hdStruct  *hp;
231 > struct hdStruct  *hp;
232   char  *ip;
233   register FILE  *fp;
234   {
# Line 227 | Line 250 | register FILE  *fp;
250  
251          if (ip != NULL)
252                  if (nidbytes)
253 <                        fread(ip, nidbytes, 1, fp);
253 >                        fread((char *)ip, nidbytes, 1, fp);
254                  else
255                          *ip = '\0';
256          else if (nidbytes)
# Line 238 | Line 261 | register FILE  *fp;
261  
262  
263   putthead(hp, ip, fp)            /* write header to output */
264 < struct hdStruct  *hp;
264 > struct hdStruct  *hp;
265   char  *ip;
266   register FILE  *fp;
267   {
# Line 278 | Line 301 | register struct hdStruct  *h;
301                  p->fp = stdin;
302          else if ((p->fp = fopen(fname, "r")) == NULL)
303                  return(NULL);
304 <                                        /* discard header */
305 <        getheader(p->fp, NULL);
306 <        if (fscanf(p->fp, "-Y %d +X %d\n", &ymax, &xmax) != 2)
307 <                quiterr("bad picture size");
304 >                                        /* get header info. */
305 >        if (checkheader(p->fp, COLRFMT, NULL) < 0 ||
306 >                        fgetresolu(&xmax, &ymax, p->fp) < 0)
307 >                quiterr("bad picture format");
308          p->nexty = 0;
309          p->bytes_line = 0;              /* variable length lines */
310          p->pos.y = (long *)ecalloc(ymax, sizeof(long));
# Line 300 | Line 323 | register struct hdStruct  *h;
323          h->dataBits = 8;
324          h->imType = 0;
325                                          /* allocate scanline */
326 <        inline = (COLR *)emalloc(xmax*sizeof(COLR));
326 >        inl = (COLR *)emalloc(xmax*sizeof(COLR));
327                                          /* allocate targa data */
328          tarData = taralloc(h);
329  
# Line 309 | Line 332 | register struct hdStruct  *h;
332  
333  
334   tg2ra(hp)                       /* targa file to RADIANCE file */
335 < struct hdStruct  *hp;
335 > struct hdStruct  *hp;
336   {
337          union {
338                  BYTE  c3[256][3];
# Line 320 | Line 343 | struct hdStruct  *hp;
343          register int  i, j;
344  
345                                          /* get color table */
346 <        if ((hp->CMapBits==24 ? fread(map.c3, sizeof(map.c3), 1, stdin) :
347 <                        fread(map.c4, sizeof(map.c4), 1, stdin)) != 1)
346 >        if ((hp->CMapBits==24 ? fread((char *)(map.c3+hp->mapOrig),
347 >                                3*hp->mapLength,1,stdin) :
348 >                        fread((char *)(map.c4+hp->mapOrig),
349 >                                4*hp->mapLength,1,stdin)) != 1)
350                  quiterr("error reading color table");
351                                          /* convert table */
352          for (i = hp->mapOrig; i < hp->mapOrig+hp->mapLength; i++)
# Line 335 | Line 360 | struct hdStruct  *hp;
360                                          pow((map.c4[i][3]+.5)/256.,gamma),
361                                          pow((map.c4[i][2]+.5)/256.,gamma),
362                                          pow((map.c4[i][1]+.5)/256.,gamma));
363 <
363 >        if (bradj)
364 >                shiftcolrs(ctab, 256, bradj);
365                                          /* allocate targa data */
366          tarData = taralloc(hp);
367                                          /* get data */
# Line 358 | Line 384 | picreadline3(y, l3)                    /* read in 3-byte scanline */
384   int  y;
385   register rgbpixel  *l3;
386   {
387 <        register BYTE   *l4;
362 <        register int    shift, c;
363 <        int     i;
387 >        register int    i;
388  
389 <        if (inpic->nexty != y) {                                /* find scanline */
389 >        if (inpic->nexty != y) {                        /* find scanline */
390                  if (inpic->bytes_line == 0) {
391                          if (inpic->pos.y[y] == 0) {
392                                  while (inpic->nexty < y) {
393 <                                        if (freadcolrs(inline, xmax, inpic->fp) < 0)
393 >                                        if (freadcolrs(inl, xmax, inpic->fp) < 0)
394                                                  quiterr("read error in picreadline3");
395                                          inpic->pos.y[++inpic->nexty] = ftell(inpic->fp);
396                                  }
# Line 376 | Line 400 | register rgbpixel  *l3;
400                          quiterr("seek error in picreadline3");
401          } else if (inpic->bytes_line == 0 && inpic->pos.y[inpic->nexty] == 0)
402                  inpic->pos.y[inpic->nexty] = ftell(inpic->fp);
403 <        if (freadcolrs(inline, xmax, inpic->fp) < 0)    /* read scanline */
403 >        if (freadcolrs(inl, xmax, inpic->fp) < 0)       /* read scanline */
404                  quiterr("read error in picreadline3");
405          inpic->nexty = y+1;
406                                                          /* convert scanline */
407 <        for (l4=inline[0], i=xmax; i--; l4+=4, l3++) {
408 <                shift = l4[EXP] - COLXS;
409 <                if (shift >= 8) {
410 <                        l3->r = l3->g = l3->b = 255;
411 <                } else if (shift <= -8) {
388 <                        l3->r = l3->g = l3->b = 0;
389 <                } else if (shift > 0) {
390 <                        c = l4[RED] << shift;
391 <                        l3->r = c > 255 ? 255 : c;
392 <                        c = l4[GRN] << shift;
393 <                        l3->g = c > 255 ? 255 : c;
394 <                        c = l4[BLU] << shift;
395 <                        l3->b = c > 255 ? 255 : c;
396 <                } else if (shift < 0) {
397 <                        l3->r = l4[RED] >> -shift;
398 <                        l3->g = l4[GRN] >> -shift;
399 <                        l3->b = l4[BLU] >> -shift;
400 <                } else {
401 <                        l3->r = l4[RED];
402 <                        l3->g = l4[GRN];
403 <                        l3->b = l4[BLU];
404 <                }
407 >        normcolrs(inl, xmax, bradj);
408 >        for (i = 0; i < xmax; i++) {
409 >                l3[i].r = inl[i][RED];
410 >                l3[i].g = inl[i][GRN];
411 >                l3[i].b = inl[i][BLU];
412          }
413   }
414  
# Line 410 | Line 417 | picwriteline(y, l)                     /* save output scanline */
417   int  y;
418   pixel  *l;
419   {
420 <        bcopy(l, &tarData[(ymax-1-y)*xmax], xmax*sizeof(pixel));
420 >        bcopy((char *)l, (char *)&tarData[(ymax-1-y)*xmax], xmax*sizeof(pixel));
421   }
422  
423  
424   writetarga(h, d, fp)            /* write out targa data */
425 < struct hdStruct  *h;
425 > struct hdStruct  *h;
426   pixel  *d;
427   FILE  *fp;
428   {
429          if (h->dataType == IM_CMAP) {           /* uncompressed */
430 <                if (fwrite(d, h->x*sizeof(pixel), h->y, fp) != h->y)
430 >                if (fwrite((char *)d,h->x*sizeof(pixel),h->y,fp) != h->y)
431                          quiterr("error writing targa file");
432                  return;
433          }
# Line 429 | Line 436 | FILE  *fp;
436  
437  
438   readtarga(h, data, fp)          /* read in targa data */
439 < struct hdStruct  *h;
439 > struct hdStruct  *h;
440   pixel  *data;
441   FILE  *fp;
442   {
# Line 437 | Line 444 | FILE  *fp;
444          register pixel  *dp;
445  
446          if (h->dataType == IM_CMAP) {           /* uncompressed */
447 <                if (fread(data, h->x*sizeof(pixel), h->y, fp) != h->y)
447 >                if (fread((char *)data,h->x*sizeof(pixel),h->y,fp) != h->y)
448                          goto readerr;
449                  return;
450          }
# Line 480 | Line 487 | colormap  map;
487          register int  i, val;
488  
489          for (i = 0; i < 256; i++) {
490 <                val = pow(i/256.0, 1.0/gamma) * 256.0;
490 >                val = pow((i+0.5)/256.0, 1.0/gamma) * 256.0;
491                  map[0][i] = map[1][i] = map[2][i] = val;
492          }
493   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines