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

Comparing ray/src/common/tmapcolrs.c (file contents):
Revision 3.16 by schorsch, Sat Oct 23 18:55:52 2004 UTC vs.
Revision 3.17 by greg, Fri Jan 7 20:33:02 2005 UTC

# Line 30 | Line 30 | typedef struct {
30          TMbright        inpsfb;         /* encoded tm->inpsf */
31   } COLRDATA;
32  
33 < static MEM_PTR  colrInit(struct tmStruct *);
34 < static void     colrNewSpace(struct tmStruct *);
33 > static MEM_PTR  colrInit(TMstruct *);
34 > static void     colrNewSpace(TMstruct *);
35   static gethfunc headline;
36  
37   static struct tmPackage colrPkg = {     /* our package functions */
# Line 44 | Line 44 | static TMbright        logi[LOGISZ];
44  
45  
46   int
47 < tmCvColrs(ls, cs, scan, len)            /* convert RGBE/XYZE colors */
48 < TMbright        *ls;
49 < BYTE    *cs;
50 < COLR    *scan;
51 < int     len;
47 > tmCvColrs(                              /* convert RGBE/XYZE colors */
48 > TMstruct        *tms,
49 > TMbright        *ls,
50 > BYTE    *cs,
51 > COLR    *scan,
52 > int     len
53 > )
54   {
55          static char     funcName[] = "tmCvColrs";
56          COLR    cmon;
57          register COLRDATA       *cd;
58          register int    i, bi, li;
59  
60 <        if (tmTop == NULL)
60 >        if (tms == NULL)
61                  returnErr(TM_E_TMINVAL);
62          if ((ls == NULL) | (scan == NULL) | (len < 0))
63                  returnErr(TM_E_ILLEGAL);
64   #if TM_PIC_CTRANS
65 <        if (tmNeedMatrix(tmTop)) {              /* need floating point */
65 >        if (tmNeedMatrix(tms)) {                /* need floating point */
66   #else
67 <        if (tmTop->inppri == TM_XYZPRIM) {      /* no way around this */
67 >        if (tms->inppri == TM_XYZPRIM) {        /* no way around this */
68   #endif
69                  register COLOR  *newscan;
70                  newscan = (COLOR *)tempbuffer(len*sizeof(COLOR));
# Line 70 | Line 72 | int    len;
72                          returnErr(TM_E_NOMEM);
73                  for (i = len; i--; )
74                          colr_color(newscan[i], scan[i]);
75 <                return(tmCvColors(ls, cs, newscan, len));
75 >                return(tmCvColors(tms, ls, cs, newscan, len));
76          }
77          if (colrReg < 0) {                      /* build tables if necessary */
78                  colrReg = tmRegPkg(&colrPkg);
# Line 82 | Line 84 | int    len;
84                          logi[i] = 0;
85                  tmMkMesofact();
86          }
87 <        if ((cd = (COLRDATA *)tmPkgData(tmTop,colrReg)) == NULL)
87 >        if ((cd = (COLRDATA *)tmPkgData(tms,colrReg)) == NULL)
88                  returnErr(TM_E_NOMEM);
89          for (i = len; i--; ) {
90                  copycolr(cmon, scan[i]);
# Line 100 | Line 102 | int    len;
102                  if (cs == TM_NOCHROM)                   /* no color? */
103                          continue;
104                                                          /* mesopic adj. */
105 <                if (tmTop->flags & TM_F_MESOPIC && bi < BMESUPPER) {
105 >                if (tms->flags & TM_F_MESOPIC && bi < BMESUPPER) {
106                          register int    pf, sli = normscot(cmon);
107                          if (bi < BMESLOWER)
108                                  cmon[RED] = cmon[GRN] = cmon[BLU] = sli;
109                          else {
110 <                                if (tmTop->flags & TM_F_BW)
110 >                                if (tms->flags & TM_F_BW)
111                                          cmon[RED] = cmon[GRN] = cmon[BLU] = li;
112                                  pf = tmMesofact[bi-BMESLOWER];
113                                  sli *= 256 - pf;
# Line 113 | Line 115 | int    len;
115                                  cmon[GRN] = ( sli + pf*cmon[GRN] ) >> 8;
116                                  cmon[BLU] = ( sli + pf*cmon[BLU] ) >> 8;
117                          }
118 <                } else if (tmTop->flags & TM_F_BW) {
118 >                } else if (tms->flags & TM_F_BW) {
119                          cmon[RED] = cmon[GRN] = cmon[BLU] = li;
120                  }
121                  bi = ( (int32)GAMTSZ*cd->clfb[RED]*cmon[RED]/li ) >> 8;
# Line 172 | Line 174 | headline(                      /* grok a header line */
174  
175  
176   int
177 < tmLoadPicture(lpp, cpp, xp, yp, fname, fp)      /* convert Radiance picture */
178 < TMbright        **lpp;
179 < BYTE    **cpp;
180 < int     *xp, *yp;
181 < char    *fname;
182 < FILE    *fp;
177 > tmLoadPicture(                          /* convert Radiance picture */
178 > TMstruct        *tms,
179 > TMbright        **lpp,
180 > BYTE    **cpp,
181 > int     *xp,
182 > int     *yp,
183 > char    *fname,
184 > FILE    *fp
185 > )
186   {
187          char    *funcName = fname==NULL ? "tmLoadPicture" : fname;
188          FILE    *inpf;
# Line 186 | Line 191 | FILE   *fp;
191          COLR    *scanin = NULL;
192          int     i;
193                                                  /* check arguments */
194 <        if (tmTop == NULL)
194 >        if (tms == NULL)
195                  returnErr(TM_E_TMINVAL);
196          if ((lpp == NULL) | (xp == NULL) | (yp == NULL) |
197                          ((fname == NULL) & (fp == TM_GETFILE)))
# Line 209 | Line 214 | FILE   *fp;
214          else if (info.format == FMTCIE)
215                  info.primp = TM_XYZPRIM;
216                                                  /* prepare library */
217 <        if ((err = tmSetSpace(info.primp, 1./info.expos)) != TM_E_OK)
217 >        if ((err = tmSetSpace(tms, info.primp, 1./info.expos)) != TM_E_OK)
218                  goto done;
219          err = TM_E_NOMEM;                       /* allocate arrays */
220          *lpp = (TMbright *)malloc(sizeof(TMbright) * *xp * *yp);
# Line 228 | Line 233 | FILE   *fp;
233                  if (freadcolrs(scanin, *xp, inpf) < 0) {
234                          err = TM_E_BADFILE; break;
235                  }
236 <                err = tmCvColrs(*lpp + (i * *xp),
236 >                err = tmCvColrs(tms, *lpp + (i * *xp),
237                          cpp==TM_NOCHROMP ? TM_NOCHROM : *cpp + (i * 3 * *xp),
238                                  scanin, *xp);
239                  if (err != TM_E_OK)
# Line 261 | Line 266 | double gamval, Lddyn, Ldmax;
266   char    *fname;
267   {
268          char    *funcName = fname;
269 +        TMstruct        *tms = NULL;
270          char    cmdbuf[1024];
271          FILE    *infp;
272          register COLR   *scan;
# Line 348 | Line 354 | char   *fname;
354   FILE    *fp;
355   {
356          char    *funcName = fname==NULL ? "tmMapPicture" : fname;
357 +        TMstruct        *tms;
358          BYTE    *cp;
359          TMbright        *lp;
360          int     err;
# Line 367 | Line 374 | FILE   *fp;
374                                  monpri, gamval, Lddyn, Ldmax, fname) );
375   #endif
376                                                  /* initialize tone mapping */
377 <        if (tmInit(flags, monpri, gamval) == NULL)
377 >        if ((tms = tmInit(flags, monpri, gamval)) == NULL)
378                  returnErr(TM_E_NOMEM);
379                                                  /* load & convert picture */
380 <        err = tmLoadPicture(&lp, (flags&TM_F_BW) ? TM_NOCHROMP : &cp,
380 >        err = tmLoadPicture(tms, &lp, (flags&TM_F_BW) ? TM_NOCHROMP : &cp,
381                          xp, yp, fname, fp);
382          if (err != TM_E_OK) {
383 <                tmDone(NULL);
383 >                tmDone(tms);
384                  return(err);
385          }
386                                                  /* allocate space for result */
# Line 381 | Line 388 | FILE   *fp;
388                  *psp = (BYTE *)malloc(sizeof(BYTE) * *xp * *yp);
389                  if (*psp == NULL) {
390                          free((MEM_PTR)lp);
391 <                        tmDone(NULL);
391 >                        tmDone(tms);
392                          returnErr(TM_E_NOMEM);
393                  }
394                  cp = TM_NOCHROM;
395          } else
396                  *psp = cp;
397                                                  /* compute color mapping */
398 <        err = tmAddHisto(lp, *xp * *yp, 1);
398 >        err = tmAddHisto(tms, lp, *xp * *yp, 1);
399          if (err != TM_E_OK)
400                  goto done;
401 <        err = tmComputeMapping(gamval, Lddyn, Ldmax);
401 >        err = tmComputeMapping(tms, gamval, Lddyn, Ldmax);
402          if (err != TM_E_OK)
403                  goto done;
404                                                  /* map colors */
405 <        err = tmMapPixels(*psp, lp, cp, *xp * *yp);
405 >        err = tmMapPixels(tms, *psp, lp, cp, *xp * *yp);
406  
407   done:                                           /* clean up */
408          free((MEM_PTR)lp);
409 <        tmDone(NULL);
409 >        tmDone(tms);
410          if (err != TM_E_OK) {                   /* free memory on error */
411                  free((MEM_PTR)*psp);
412                  *psp = NULL;
# Line 411 | Line 418 | done:                                          /* clean up */
418  
419   static void
420   colrNewSpace(tms)               /* color space changed for tone mapping */
421 < register struct tmStruct        *tms;
421 > register TMstruct       *tms;
422   {
423          register COLRDATA       *cd;
424          double  d;
# Line 428 | Line 435 | register struct tmStruct       *tms;
435  
436   static MEM_PTR
437   colrInit(tms)                   /* initialize private data for tone mapping */
438 < register struct tmStruct        *tms;
438 > register TMstruct       *tms;
439   {
440          register COLRDATA       *cd;
441          register int    i;

Diff Legend

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