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

Comparing ray/src/px/ra_tiff.c (file contents):
Revision 2.9 by gregl, Thu Jul 24 11:47:05 1997 UTC vs.
Revision 2.18 by gwlarson, Sun May 30 17:35:08 1999 UTC

# Line 33 | Line 33 | extern char  *malloc();
33   struct {
34          uint16  flags;          /* conversion flags (defined above) */
35          uint16  comp;           /* TIFF compression type */
36 +        uint16  phot;           /* TIFF photometric type */
37          uint16  pconf;          /* TIFF planar configuration */
38          float   gamcor;         /* gamma correction value */
39          short   bradj;          /* Radiance exposure adjustment (stops) */
40          uint16  orient;         /* visual orientation (TIFF spec.) */
41 <        float   stonits;        /* input conversion to nits */
41 >        double  stonits;        /* input conversion to nits */
42          float   pixrat;         /* pixel aspect ratio */
43          FILE    *rfp;           /* Radiance stream pointer */
44          TIFF    *tif;           /* TIFF pointer */
# Line 51 | Line 52 | struct {
52          } r;                    /* Radiance scanline */
53          union {
54                  uint8   *bp;            /* byte pointer */
55 +                uint16  *wp;            /* word pointer */
56                  float   *fp;            /* float pointer */
57                  char    *p;             /* generic pointer */
58          } t;                    /* TIFF scanline */
59          int     (*tf)();        /* translation procedure */
60   }       cvts = {        /* conversion structure */
61 <        0, COMPRESSION_NONE, PLANARCONFIG_CONTIG, GAMCOR, 0,
61 >        0, COMPRESSION_NONE, PHOTOMETRIC_RGB,
62 >        PLANARCONFIG_CONTIG, GAMCOR, 0, 1, 1., 1.,
63   };
64  
65   #define CHK(f)          (cvts.flags & (f))
# Line 66 | Line 69 | struct {
69  
70   int     Luv2Color(), L2Color(), RGB2Colr(), Gry2Colr();
71   int     Color2Luv(), Color2L(), Colr2RGB(), Colr2Gry();
72 + int     RRGGBB2Color(), GGry2Color();
73  
74   short   ortab[8] = {            /* orientation conversion table */
75          YMAJOR|YDECR,
# Line 105 | Line 109 | char  *argv[];
109                                  cvts.comp = COMPRESSION_LZW;
110                                  break;
111                          case 'L':               /* LogLuv 32-bit output */
112 <                                cvts.comp = COMPRESSION_LOGLUV32;
112 >                                cvts.comp = COMPRESSION_SGILOG;
113 >                                cvts.phot = PHOTOMETRIC_LOGLUV;
114                                  break;
115                          case 'l':               /* LogLuv 24-bit output */
116 <                                cvts.comp = COMPRESSION_LOGLUV24;
116 >                                cvts.comp = COMPRESSION_SGILOG24;
117 >                                cvts.phot = PHOTOMETRIC_LOGLUV;
118                                  break;
119                          case 'b':               /* greyscale output? */
120                                  TGL(C_GRY);
# Line 141 | Line 147 | doneopts:
147                  if (i != argc-2)
148                          goto userr;
149  
150 <                if (CHK(C_GRY) && (cvts.comp == COMPRESSION_LOGLUV24 ||
151 <                                        cvts.comp == COMPRESSION_LOGLUV32))
152 <                        cvts.comp = COMPRESSION_LOGL16;
150 >                if (CHK(C_GRY))         /* consistency corrections */
151 >                        if (cvts.phot == PHOTOMETRIC_RGB)
152 >                                cvts.phot = PHOTOMETRIC_MINISBLACK;
153 >                        else {
154 >                                cvts.phot = PHOTOMETRIC_LOGL;
155 >                                cvts.comp = COMPRESSION_SGILOG;
156 >                        }
157  
158                  ra2tiff(i, argv);
159          }
# Line 216 | Line 226 | initfromtif()          /* initialize conversion from TIFF inpu
226          if (TIFFGetField(cvts.tif, TIFFTAG_XRESOLUTION, &f1) &&
227                          TIFFGetField(cvts.tif, TIFFTAG_YRESOLUTION, &f2))
228                  cvts.pixrat = f1/f2;
219 –        else
220 –                cvts.pixrat = 1.;
229  
230 <        if (!TIFFGetFieldDefaulted(cvts.tif, TIFFTAG_ORIENTATION, &cvts.orient))
223 <                cvts.orient = 1;
230 >        TIFFGetFieldDefaulted(cvts.tif, TIFFTAG_ORIENTATION, &cvts.orient);
231  
232 <        switch (cvts.comp) {
233 <        case COMPRESSION_LOGL16:
234 <                SET(C_GRY|C_RFLT|C_TFLT|C_GAMUT);
235 <                cvts.pconf = PLANARCONFIG_CONTIG;
236 <                TIFFSetField(cvts.tif, TIFFTAG_LOGLUVDATAFMT,
230 <                                LOGLUVDATAFMT_FLTY);
231 <                TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
232 <                                SAMPLEFORMAT_IEEEFP);
233 <                cvts.tf = L2Color;
234 <                break;
235 <        case COMPRESSION_LOGLUV24:
236 <        case COMPRESSION_LOGLUV32:
232 >        if (!TIFFGetFieldDefaulted(cvts.tif, TIFFTAG_PHOTOMETRIC, &cvts.phot))
233 >                quiterr("TIFF has unspecified photometric type");
234 >
235 >        switch (cvts.phot) {
236 >        case PHOTOMETRIC_LOGLUV:
237                  SET(C_RFLT|C_TFLT);
238                  if (!CHK(C_XYZE)) {
239                          cpcolormat(cvts.cmat, xyz2rgbmat);
240                          SET(C_CXFM|C_GAMUT);
241 <                } else if (cvts.comp == COMPRESSION_LOGLUV32)
241 >                } else if (cvts.comp == COMPRESSION_SGILOG)
242                          SET(C_GAMUT);
243                  if (cvts.pconf != PLANARCONFIG_CONTIG)
244                          quiterr("cannot handle separate Luv planes");
245 <                TIFFSetField(cvts.tif, TIFFTAG_LOGLUVDATAFMT,
246 <                                LOGLUVDATAFMT_FLTXYZ);
247 <                TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
248 <                                SAMPLEFORMAT_IEEEFP);
245 >                TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
246 >                                SGILOGDATAFMT_FLOAT);
247                  cvts.tf = Luv2Color;
248                  break;
249 <        default:
250 <                SET(C_GAMMA|C_GAMUT);
249 >        case PHOTOMETRIC_LOGL:
250 >                SET(C_GRY|C_RFLT|C_TFLT|C_GAMUT);
251 >                cvts.pconf = PLANARCONFIG_CONTIG;
252 >                TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
253 >                                SGILOGDATAFMT_FLOAT);
254 >                cvts.tf = L2Color;
255 >                break;
256 >        case PHOTOMETRIC_YCBCR:
257 >                if (cvts.comp == COMPRESSION_JPEG &&
258 >                                cvts.pconf == PLANARCONFIG_CONTIG) {
259 >                        TIFFSetField(cvts.tif, TIFFTAG_JPEGCOLORMODE,
260 >                                        JPEGCOLORMODE_RGB);
261 >                        cvts.phot = PHOTOMETRIC_RGB;
262 >                } else
263 >                        quiterr("unsupported photometric type");
264 >                /* fall through */
265 >        case PHOTOMETRIC_RGB:
266 >                SET(C_GAMMA);
267                  setcolrgam(cvts.gamcor);
268                  if (CHK(C_XYZE)) {
269                          comprgb2xyzmat(cvts.cmat,
# Line 257 | Line 271 | initfromtif()          /* initialize conversion from TIFF inpu
271                          SET(C_CXFM);
272                  }
273                  if (!TIFFGetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, &hi) ||
274 <                                (hi != 1 && hi != 3))
275 <                        quiterr("unsupported samples per pixel");
276 <                if (hi == 1) {
277 <                        SET(C_GRY);
278 <                        cvts.pconf = PLANARCONFIG_CONTIG;
279 <                        cvts.tf = Gry2Colr;
266 <                } else
274 >                                hi != 3)
275 >                        quiterr("unsupported samples per pixel for RGB");
276 >                if (!TIFFGetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, &hi) ||
277 >                                hi != 8 & hi != 16)
278 >                        quiterr("unsupported bits per sample for RGB");
279 >                if (hi == 8)
280                          cvts.tf = RGB2Colr;
281 +                else {
282 +                        cvts.tf = RRGGBB2Color;
283 +                        SET(C_RFLT);
284 +                }
285 +                break;
286 +        case PHOTOMETRIC_MINISBLACK:
287 +                SET(C_GRY|C_GAMMA);
288 +                setcolrgam(cvts.gamcor);
289 +                cvts.pconf = PLANARCONFIG_CONTIG;
290 +                if (!TIFFGetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, &hi) ||
291 +                                hi != 1)
292 +                        quiterr("unsupported samples per pixel for greyscale");
293                  if (!TIFFGetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, &hi) ||
294 <                                hi != 8)
295 <                        quiterr("unsupported bits per sample");
294 >                                hi != 8 & hi != 16)
295 >                        quiterr("unsupported bits per sample for greyscale");
296 >                if (hi == 8)
297 >                        cvts.tf = Gry2Colr;
298 >                else {
299 >                        cvts.tf = GGry2Color;
300 >                        SET(C_RFLT);
301 >                }
302                  break;
303 +        default:
304 +                quiterr("unsupported photometric type");
305 +                break;
306          }
307  
274 –        if (TIFFGetField(cvts.tif, TIFFTAG_PHOTOMETRIC, &hi) &&
275 –                hi != (CHK(C_GRY) ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB))
276 –                quiterr("unsupported photometric interpretation");
277 –
308          if (!TIFFGetField(cvts.tif, TIFFTAG_IMAGEWIDTH, &cvts.xmax) ||
309                  !TIFFGetField(cvts.tif, TIFFTAG_IMAGELENGTH, &cvts.ymax))
310                  quiterr("unknown input image resolution");
# Line 342 | Line 372 | char   *s;
372                          SET(C_XYZE);
373                  else
374                          quiterr("unrecognized input picture format");
375 <                return;
375 >                return(1);
376          }
377          if (isexpos(s)) {
378                  cvts.stonits /= exposval(s);
379 <                return;
379 >                return(1);
380          }
381          if (isaspect(s)) {
382                  cvts.pixrat *= aspectval(s);
383 <                return;
383 >                return(1);
384          }
385          if (isprims(s)) {
386                  primsval(cvts.prims, s);
387                  SET(C_PRIM);
388 <                return;
388 >                return(1);
389          }
390 +        return(0);
391   }
392  
393  
# Line 385 | Line 416 | initfromrad()                  /* initialize input from a Radiance pi
416                  cvts.stonits *= WHTEFFICACY;
417                                                  /* set up conversion */
418          TIFFSetField(cvts.tif, TIFFTAG_COMPRESSION, cvts.comp);
419 +        TIFFSetField(cvts.tif, TIFFTAG_PHOTOMETRIC, cvts.phot);
420  
421 <        switch (cvts.comp) {
422 <        case COMPRESSION_LOGL16:
391 <                SET(C_GRY|C_RFLT|C_TFLT);
392 <                TIFFSetField(cvts.tif, TIFFTAG_LOGLUVDATAFMT,
393 <                                LOGLUVDATAFMT_FLTY);
394 <                TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
395 <                                SAMPLEFORMAT_IEEEFP);
396 <                cvts.tf = Color2L;
397 <                break;
398 <        case COMPRESSION_LOGLUV24:
399 <        case COMPRESSION_LOGLUV32:
421 >        switch (cvts.phot) {
422 >        case PHOTOMETRIC_LOGLUV:
423                  SET(C_RFLT|C_TFLT);
424                  CLR(C_GRY);
425                  if (!CHK(C_XYZE)) {
426                          cpcolormat(cvts.cmat, rgb2xyzmat);
427                          SET(C_CXFM);
428                  }
429 <                TIFFSetField(cvts.tif, TIFFTAG_LOGLUVDATAFMT,
430 <                                LOGLUVDATAFMT_FLTXYZ);
431 <                TIFFSetField(cvts.tif, TIFFTAG_SAMPLEFORMAT,
432 <                                SAMPLEFORMAT_IEEEFP);
429 >                if (cvts.comp != COMPRESSION_SGILOG &&
430 >                                cvts.comp != COMPRESSION_SGILOG24)
431 >                        quiterr("internal error 2 in initfromrad");
432 >                TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
433 >                                SGILOGDATAFMT_FLOAT);
434                  cvts.tf = Color2Luv;
435                  break;
436 <        default:
436 >        case PHOTOMETRIC_LOGL:
437 >                SET(C_GRY|C_RFLT|C_TFLT);
438 >                if (cvts.comp != COMPRESSION_SGILOG)    
439 >                        quiterr("internal error 3 in initfromrad");
440 >                TIFFSetField(cvts.tif, TIFFTAG_SGILOGDATAFMT,
441 >                                SGILOGDATAFMT_FLOAT);
442 >                cvts.tf = Color2L;
443 >                break;
444 >        case PHOTOMETRIC_RGB:
445                  SET(C_GAMMA|C_GAMUT);
446 +                CLR(C_GRY);
447                  setcolrgam(cvts.gamcor);
448                  if (CHK(C_XYZE)) {
449                          compxyz2rgbmat(cvts.cmat,
450                                          CHK(C_PRIM) ? cvts.prims : stdprims);
451                          SET(C_CXFM);
452                  }
420 –                if (CHK(C_GRY))
421 –                        cvts.tf = Colr2Gry;
422 –                else
423 –                        cvts.tf = Colr2RGB;
453                  if (CHK(C_PRIM)) {
454                          TIFFSetField(cvts.tif, TIFFTAG_PRIMARYCHROMATICITIES,
455                                          (float *)cvts.prims);
456                          TIFFSetField(cvts.tif, TIFFTAG_WHITEPOINT,
457                                          (float *)cvts.prims[WHT]);
458                  }
459 +                cvts.tf = Colr2RGB;
460                  break;
461 +        case PHOTOMETRIC_MINISBLACK:
462 +                SET(C_GRY|C_GAMMA|C_GAMUT);
463 +                setcolrgam(cvts.gamcor);
464 +                cvts.tf = Colr2Gry;
465 +                break;
466 +        default:
467 +                quiterr("internal error 4 in initfromrad");
468 +                break;
469          }
470                                                  /* set other TIFF fields */
471          TIFFSetField(cvts.tif, TIFFTAG_IMAGEWIDTH, cvts.xmax);
472          TIFFSetField(cvts.tif, TIFFTAG_IMAGELENGTH, cvts.ymax);
473          TIFFSetField(cvts.tif, TIFFTAG_SAMPLESPERPIXEL, CHK(C_GRY) ? 1 : 3);
474          TIFFSetField(cvts.tif, TIFFTAG_BITSPERSAMPLE, CHK(C_TFLT) ? 32 : 8);
437 –        TIFFSetField(cvts.tif, TIFFTAG_PHOTOMETRIC,
438 –                        CHK(C_GRY) ? PHOTOMETRIC_MINISBLACK : PHOTOMETRIC_RGB);
475          TIFFSetField(cvts.tif, TIFFTAG_XRESOLUTION, 72.);
476          TIFFSetField(cvts.tif, TIFFTAG_YRESOLUTION, 72./cvts.pixrat);
477          TIFFSetField(cvts.tif, TIFFTAG_ORIENTATION, cvts.orient);
# Line 443 | Line 479 | initfromrad()                  /* initialize input from a Radiance pi
479          TIFFSetField(cvts.tif, TIFFTAG_PLANARCONFIG, cvts.pconf);
480          TIFFSetField(cvts.tif, TIFFTAG_STONITS,
481                          cvts.stonits/pow(2.,(double)cvts.bradj));
482 <        i1 = TIFFScanlineSize(cvts.tif);
482 >        if (cvts.comp == COMPRESSION_NONE)
483 >                i1 = TIFFScanlineSize(cvts.tif);
484 >        else
485 >                i1 = 3*cvts.xmax;       /* conservative guess */
486          i2 = 8192/i1;                           /* compute good strip size */
487          if (i2 < 1) i2 = 1;
488          TIFFSetField(cvts.tif, TIFFTAG_ROWSPERSTRIP, (uint32)i2);
# Line 482 | Line 521 | uint32 y;
521   {
522          register int    x;
523  
524 <        if (CHK(C_RFLT|C_TFLT) != (C_RFLT|C_TFLT) | CHK(C_GRY))
524 >        if (CHK(C_RFLT|C_TFLT|C_GRY) != (C_RFLT|C_TFLT))
525                  quiterr("internal error 1 in Luv2Color");
526  
527          if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
528                  quiterr("error reading TIFF input");
529          
530          for (x = cvts.xmax; x--; ) {
531 <                cvts.r.colors[x][RED] = cvts.t.fp[3*x];
532 <                cvts.r.colors[x][GRN] = cvts.t.fp[3*x + 1];
533 <                cvts.r.colors[x][BLU] = cvts.t.fp[3*x + 2];
531 >                colval(cvts.r.colors[x],CIEX) = cvts.t.fp[3*x];
532 >                colval(cvts.r.colors[x],CIEY) = cvts.t.fp[3*x + 1];
533 >                colval(cvts.r.colors[x],CIEZ) = cvts.t.fp[3*x + 2];
534                  if (CHK(C_CXFM))
535                          colortrans(cvts.r.colors[x], cvts.cmat,
536                                          cvts.r.colors[x]);
# Line 511 | Line 550 | uint32 y;
550  
551  
552   int
553 + RRGGBB2Color(y)                 /* read/convert/write RGB16->COLOR scanline */
554 + uint32  y;
555 + {
556 +        int     dogamma = cvts.gamcor < 0.99 | cvts.gamcor > 1.01;
557 +        register double d;
558 +        register int    x;
559 +
560 +        if (CHK(C_RFLT|C_TFLT|C_GRY) != C_RFLT)
561 +                quiterr("internal error 1 in RRGGBB2Color");
562 +
563 +        if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
564 +                quiterr("error reading TIFF input");
565 +        
566 +        for (x = cvts.xmax; x--; ) {
567 +                d = (cvts.t.wp[3*x] + 0.5)*(1./(1L<<16));
568 +                if (dogamma) d = pow(d, cvts.gamcor);
569 +                colval(cvts.r.colors[x],RED) = d;
570 +                d = (cvts.t.wp[3*x + 1] + 0.5)*(1./(1L<<16));
571 +                if (dogamma) d = pow(d, cvts.gamcor);
572 +                colval(cvts.r.colors[x],GRN) = d;
573 +                d = (cvts.t.wp[3*x + 2] + 0.5)*(1./(1L<<16));
574 +                if (dogamma) d = pow(d, cvts.gamcor);
575 +                colval(cvts.r.colors[x],BLU) = d;
576 +                if (CHK(C_CXFM))
577 +                        colortrans(cvts.r.colors[x], cvts.cmat,
578 +                                        cvts.r.colors[x]);
579 +                if (CHK(C_GAMUT))
580 +                        clipgamut(cvts.r.colors[x], cvts.t.fp[3*x + 1],
581 +                                        CGAMUT_LOWER, cblack, cwhite);
582 +        }
583 +        if (cvts.bradj) {
584 +                d = pow(2.,(double)cvts.bradj);
585 +                for (x = cvts.xmax; x--; )
586 +                        scalecolor(cvts.r.colors[x], d);
587 +        }
588 +
589 +        if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
590 +                quiterr("error writing Radiance picture");
591 + }
592 +
593 +
594 + int
595   L2Color(y)                      /* read/convert/write L16->COLOR scanline */
596   uint32  y;
597   {
# Line 523 | Line 604 | uint32 y;
604                  quiterr("error reading TIFF input");
605          
606          for (x = cvts.xmax; x--; )
607 <                cvts.r.colors[x][RED] =
608 <                cvts.r.colors[x][GRN] =
609 <                cvts.r.colors[x][BLU] = cvts.t.fp[x] > 0. ? cvts.t.fp[x] : 0.;
607 >                colval(cvts.r.colors[x],RED) =
608 >                colval(cvts.r.colors[x],GRN) =
609 >                colval(cvts.r.colors[x],BLU) =
610 >                                cvts.t.fp[x] > 0. ? cvts.t.fp[x] : 0.;
611  
612          if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
613                  quiterr("error writing Radiance picture");
# Line 554 | Line 636 | uint32 y;
636                  if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
637                          goto readerr;
638                  if (TIFFReadScanline(cvts.tif,
639 <                                (tidata_t)(cvts.t.bp + cvts.xmax), y, 1) < 0)
639 >                                (tdata_t)(cvts.t.bp + cvts.xmax), y, 1) < 0)
640                          goto readerr;
641                  if (TIFFReadScanline(cvts.tif,
642 <                                (tidata_t)(cvts.t.bp + 2*cvts.xmax), y, 2) < 0)
642 >                                (tdata_t)(cvts.t.bp + 2*cvts.xmax), y, 2) < 0)
643                          goto readerr;
644                  for (x = cvts.xmax; x--; ) {
645                          cvts.r.colrs[x][RED] = cvts.t.bp[x];
# Line 594 | Line 676 | uint32 y;
676   {
677          register int    x;
678  
679 <        if (CHK(C_RFLT|C_TFLT) | !CHK(C_GRY))
679 >        if (CHK(C_RFLT|C_TFLT|C_GRY) != C_GRY)
680                  quiterr("internal error 1 in Gry2Colr");
681  
682          if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
# Line 615 | Line 697 | uint32 y;
697  
698  
699   int
700 + GGry2Color(y)                   /* read/convert/write G16->COLOR scanline */
701 + uint32  y;
702 + {
703 +        int     dogamma = cvts.gamcor < 0.99 | cvts.gamcor > 1.01;
704 +        double  m;
705 +        register double d;
706 +        register int    x;
707 +
708 +        if (CHK(C_TFLT|C_GRY|C_RFLT) != (C_GRY|C_RFLT))
709 +                quiterr("internal error 1 in GGry2Color");
710 +
711 +        if (TIFFReadScanline(cvts.tif, cvts.t.p, y, 0) < 0)
712 +                quiterr("error reading TIFF input");
713 +
714 +        if (cvts.bradj)
715 +                m = pow(2., (double)cvts.bradj);
716 +        for (x = cvts.xmax; x--; ) {
717 +                d = (cvts.t.wp[x] + 0.5)*(1./(1L<<16));
718 +                if (dogamma) d = pow(d, cvts.gamcor);
719 +                if (cvts.bradj) d *= m;
720 +                colval(cvts.r.colors[x],RED) =
721 +                colval(cvts.r.colors[x],GRN) =
722 +                colval(cvts.r.colors[x],BLU) = d;
723 +        }
724 +        if (fwritescan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
725 +                quiterr("error writing Radiance picture");
726 + }
727 +
728 +
729 + int
730   Color2L(y)                      /* read/convert/write COLOR->L16 scanline */
731   uint32  y;
732   {
733          double  m = pow(2.,(double)cvts.bradj);
734          register int    x;
735  
736 <        if (CHK(C_RFLT|C_TFLT) != (C_RFLT|C_TFLT) | !CHK(C_GRY))
736 >        if (CHK(C_RFLT|C_TFLT|C_GRY) != (C_RFLT|C_TFLT|C_GRY))
737                  quiterr("internal error 1 in Color2L");
738  
739          if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
# Line 642 | Line 754 | uint32 y;
754   {
755          register int    x;
756  
757 <        if (CHK(C_RFLT|C_TFLT) != (C_RFLT|C_TFLT) | CHK(C_GRY))
757 >        if (CHK(C_RFLT|C_TFLT|C_GRY) != (C_RFLT|C_TFLT))
758                  quiterr("internal error 1 in Color2Luv");
759  
760          if (freadscan(cvts.r.colors, cvts.xmax, cvts.rfp) < 0)
# Line 659 | Line 771 | uint32 y;
771          }
772  
773          for (x = cvts.xmax; x--; ) {
774 <                cvts.t.fp[3*x] = colval(cvts.r.colors[x],RED);
775 <                cvts.t.fp[3*x+1] = colval(cvts.r.colors[x],GRN);
776 <                cvts.t.fp[3*x+2] = colval(cvts.r.colors[x],BLU);
774 >                cvts.t.fp[3*x] = colval(cvts.r.colors[x],CIEX);
775 >                cvts.t.fp[3*x+1] = colval(cvts.r.colors[x],CIEY);
776 >                cvts.t.fp[3*x+2] = colval(cvts.r.colors[x],CIEZ);
777          }
778  
779          if (TIFFWriteScanline(cvts.tif, cvts.t.p, y, 0) < 0)
# Line 675 | Line 787 | uint32 y;
787   {
788          register int    x;
789  
790 <        if (CHK(C_RFLT|C_TFLT) | !CHK(C_GRY))
790 >        if (CHK(C_RFLT|C_TFLT|C_GRY) != C_GRY)
791                  quiterr("internal error 1 in Colr2Gry");
792  
793          if (freadcolrs(cvts.r.colrs, cvts.xmax, cvts.rfp) < 0)

Diff Legend

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