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

Comparing src/common/colrops.c (file contents):
Revision 2.3 by greg, Tue Sep 8 10:04:33 1992 UTC vs.
Revision 2.13 by greg, Mon Dec 18 18:54:38 2023 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1992 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Integer operations on COLR scanlines
6   */
7  
8 < #include "color.h"
8 > #include "copyright.h"
9  
10 < #define NULL            0
10 > #include <stdio.h>
11 > #include <math.h>
12  
13 < extern char     *bmalloc();
13 > #include "rtmisc.h"
14 > #include "color.h"
15  
16 +
17   #define MAXGSHIFT       31              /* maximum shift for gamma table */
18  
19 < static BYTE     *g_mant = NULL, *g_nexp = NULL;
19 > static uby8     *g_mant = NULL, *g_nexp = NULL;
20  
21 < static BYTE     (*g_bval)[256] = NULL;
21 > static uby8     (*g_bval)[256] = NULL;
22  
23 – extern double   pow();
23  
24 <
25 < setcolrcor(f, a2)               /* set brightness correction */
26 < double  (*f)();
27 < double  a2;
24 > int
25 > setcolrcor(                     /* set brightness correction */
26 >        double  (*f)(double,double),
27 >        double  a2
28 > )
29   {
30          double  mult;
31 <        register int    i, j;
31 >        int     i, j;
32                                          /* allocate tables */
33          if (g_bval == NULL && (g_bval =
34 <                        (BYTE (*)[256])bmalloc((MAXGSHIFT+1)*256)) == NULL)
34 >                        (uby8 (*)[256])bmalloc((MAXGSHIFT+1)*256)) == NULL)
35                  return(-1);
36                                          /* compute colr -> gamb mapping */
37          mult = 1.0/256.0;
# Line 44 | Line 44 | double a2;
44   }
45  
46  
47 < setcolrinv(f, a2)               /* set inverse brightness correction */
48 < double  (*f)();
49 < double  a2;
47 > int
48 > setcolrinv(                     /* set inverse brightness correction */
49 >        double  (*f)(double,double),
50 >        double  a2
51 > )
52   {
53          double  mult;
54 <        register int    i, j;
54 >        int     i, j;
55                                          /* allocate tables */
56 <        if (g_mant == NULL && (g_mant = (BYTE *)bmalloc(256)) == NULL)
56 >        if (g_mant == NULL && (g_mant = (uby8 *)bmalloc(256)) == NULL)
57                  return(-1);
58 <        if (g_nexp == NULL && (g_nexp = (BYTE *)bmalloc(256)) == NULL)
58 >        if (g_nexp == NULL && (g_nexp = (uby8 *)bmalloc(256)) == NULL)
59                  return(-1);
60                                          /* compute gamb -> colr mapping */
61          i = 0;
62          mult = 256.0;
63 <        for (j = 255; j > 0; j--) {
64 <                while ((g_mant[j] = mult * (*f)(j/256.0, a2)) < 128) {
63 >        for (j = 256; j--; ) {
64 >                while ((g_mant[j] = mult * (*f)((j+.5)/256.0, a2)) < 128) {
65                          i++;
66                          mult *= 2.0;
67                  }
68                  g_nexp[j] = i;
69          }
68 –        g_mant[0] = 0;
69 –        g_nexp[0] = COLXS;
70          return(0);
71   }
72  
73  
74 < setcolrgam(g)                   /* set gamma conversion */
75 < double  g;
74 > int
75 > setcolrgam(                             /* set gamma conversion */
76 >        double  g
77 > )
78   {
79          if (setcolrcor(pow, 1.0/g) < 0)
80                  return(-1);
# Line 80 | Line 82 | double g;
82   }
83  
84  
85 < colrs_gambs(scan, len)          /* convert scanline of colrs to gamma bytes */
86 < register COLR   *scan;
87 < int     len;
85 > int
86 > colrs_gambs(                    /* convert scanline of colrs to gamma bytes */
87 >        COLR    *scan,
88 >        int     len
89 > )
90   {
91 <        register int    i, expo;
91 >        int     i, expo;
92  
93          if (g_bval == NULL)
94                  return(-1);
# Line 129 | Line 133 | int    len;
133   }
134  
135  
136 < gambs_colrs(scan, len)          /* convert gamma bytes to colr scanline */
137 < register COLR   *scan;
138 < int     len;
136 > int
137 > gambs_colrs(            /* convert gamma bytes to colr scanline */
138 >        COLR    *scan,
139 >        int     len
140 > )
141   {
142 <        register int    nexpo;
142 >        int     nexpo;
143  
144 <        if (g_mant == NULL | g_nexp == NULL)
144 >        if ((g_mant == NULL) | (g_nexp == NULL))
145                  return(-1);
146          while (len-- > 0) {
147                  nexpo = g_nexp[scan[0][RED]];
# Line 165 | Line 171 | int    len;
171   }
172  
173  
174 < shiftcolrs(scan, len, adjust)   /* shift a scanline of colors by 2^adjust */
175 < register COLR   *scan;
176 < register int    len;
177 < register int    adjust;
174 > void
175 > shiftcolrs(             /* shift a scanline of colors by 2^adjust */
176 >        COLR    *scan,
177 >        int     len,
178 >        int     adjust
179 > )
180   {
181          int     minexp;
182  
# Line 186 | Line 194 | register int   adjust;
194   }
195  
196  
197 < normcolrs(scan, len, adjust)    /* normalize a scanline of colrs */
198 < register COLR  *scan;
199 < int  len;
200 < int  adjust;
197 > void
198 > normcolrs(              /* normalize a scanline of colrs */
199 >        COLR  *scan,
200 >        int  len,
201 >        int  adjust
202 > )
203   {
204 <        register int  c;
205 <        register int  shift;
204 >        int  c;
205 >        int  shift;
206  
207          while (len-- > 0) {
208                  shift = scan[0][EXP] + adjust - COLXS;

Diff Legend

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