ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/tmapluv.c

Comparing ray/src/common/tmapluv.c (file contents):
Revision 3.9 by schorsch, Sun Jul 27 22:12:01 2003 UTC vs.
Revision 3.10 by greg, Fri Jan 7 20:33:02 2005 UTC

#	Line 30 | Line 30 | static void    luv32NewSpace();
30		static MEM_PTR  luv24Init();
31		static void     luv24NewSpace();
32		#else
33	<	static MEM_PTR  luv32Init(struct tmStruct *);
34	<	static void     luv32NewSpace(struct tmStruct *);
35	<	static MEM_PTR  luv24Init(struct tmStruct *);
36	<	static void     luv24NewSpace(struct tmStruct *);
33	>	static MEM_PTR  luv32Init(TMstruct *);
34	>	static void     luv32NewSpace(TMstruct *);
35	>	static MEM_PTR  luv24Init(TMstruct *);
36	>	static void     luv24NewSpace(TMstruct *);
37		#endif
38
39		typedef struct {
#	Line 65 | Line 65 | static int     uv14neu = -1;           /* neutral index for 14-bit
65
66
67		static void
68	<	uv2rgb(rgb, tm, uvp)                    /* compute RGB from uv coordinate */
68	>	uv2rgb(rgb, tms, uvp)                   /* compute RGB from uv coordinate */
69		BYTE    rgb[3];
70	<	register struct tmStruct        *tm;
70	>	register TMstruct       *tms;
71		double  uvp[2];
72	<	{       /* Should check that tm->inppri==TM_XYZPRIM beforehand... */
72	>	{       /* Should check that tms->inppri==TM_XYZPRIM beforehand... */
73		double  d, x, y;
74		COLOR   XYZ, RGB;
75		/* convert to XYZ */
76		d = 1./(6.*uvp[0] - 16.*uvp[1] + 12.);
77		x = 9.*uvp[0] * d;
78		y = 4.*uvp[1] * d;
79	<	XYZ[CIEY] = 1./tm->inpsf;
79	>	XYZ[CIEY] = 1./tms->inpsf;
80		XYZ[CIEX] = x/y * XYZ[CIEY];
81		XYZ[CIEZ] = (1.-x-y)/y * XYZ[CIEY];
82		/* convert to RGB and clip */
83	<	colortrans(RGB, tm->cmat, XYZ);
83	>	colortrans(RGB, tms->cmat, XYZ);
84		clipgamut(RGB, 1., CGAMUT_LOWER, cblack, cwhite);
85		/* perform final scaling & gamma */
86	<	d = tm->clf[RED] * RGB[RED];
87	<	rgb[RED] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tm->mongam));
88	<	d = tm->clf[GRN] * RGB[GRN];
89	<	rgb[GRN] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tm->mongam));
90	<	d = tm->clf[BLU] * RGB[BLU];
91	<	rgb[BLU] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tm->mongam));
86	>	d = tms->clf[RED] * RGB[RED];
87	>	rgb[RED] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tms->mongam));
88	>	d = tms->clf[GRN] * RGB[GRN];
89	>	rgb[GRN] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tms->mongam));
90	>	d = tms->clf[BLU] * RGB[BLU];
91	>	rgb[BLU] = d>=.999 ? 255 : (int)(256.*pow(d, 1./tms->mongam));
92		}
93
94
#	Line 123 | Line 123 | double uvp[2];                 /* world (u',v') -> returned desatura
123
124
125		int
126	<	tmCvLuv32(ls, cs, luvs, len)            /* convert raw 32-bit LogLuv values */
127	<	TMbright        *ls;
128	<	BYTE    *cs;
129	<	uint32  *luvs;
130	<	int     len;
126	>	tmCvLuv32(                              /* convert raw 32-bit LogLuv values */
127	>	TMstruct        *tms,
128	>	TMbright        *ls,
129	>	BYTE    *cs,
130	>	uint32  *luvs,
131	>	int     len
132	>	)
133		{
134		static char     funcName[] = "tmCvLuv32";
135		double  uvp[2];
136		register LUV32DATA      *ld;
137		register int    i, j;
138		/* check arguments */
139	<	if (tmTop == NULL)
139	>	if (tms == NULL)
140		returnErr(TM_E_TMINVAL);
141		if ((ls == NULL) | (luvs == NULL) | (len < 0))
142		returnErr(TM_E_ILLEGAL);
#	Line 145 | Line 147 | int    len;
147		tmMkMesofact();
148		}
149		/* get package data */
150	<	if ((ld = (LUV32DATA *)tmPkgData(tmTop,luv32Reg)) == NULL)
150	>	if ((ld = (LUV32DATA *)tmPkgData(tms,luv32Reg)) == NULL)
151		returnErr(TM_E_NOMEM);
152		/* convert each pixel */
153		for (i = len; i--; ) {
#	Line 157 | Line 159 | int    len;
159		if (cs == TM_NOCHROM)           /* no color? */
160		continue;
161		/* get chrominance */
162	<	if (tmTop->flags & TM_F_MESOPIC && ls[i] < BMESUPPER) {
162	>	if (tms->flags & TM_F_MESOPIC && ls[i] < BMESUPPER) {
163		uvp[0] = 1./UVSCALE*((luvs[i]>>8 & 0xff) + .5);
164		uvp[1] = 1./UVSCALE*((luvs[i] & 0xff) + .5);
165		ls[i] = compmeshift(ls[i], uvp);
166	<	j = tmTop->flags&TM_F_BW || ls[i]<BMESLOWER
166	>	j = tms->flags&TM_F_BW || ls[i]<BMESLOWER
167		? UVNEU
168		: (int)(uvp[0]*UVSCALE)<<8
169		| (int)(uvp[1]*UVSCALE);
170		} else {
171	<	j = tmTop->flags&TM_F_BW ? UVNEU : luvs[i]&0xffff;
171	>	j = tms->flags&TM_F_BW ? UVNEU : luvs[i]&0xffff;
172		}
173		if (!isuvset(ld, j)) {
174		uvp[0] = 1./UVSCALE*((j>>8) + .5);
175		uvp[1] = 1./UVSCALE*((j & 0xff) + .5);
176	<	uv2rgb(ld->rgbval[j], tmTop, uvp);
176	>	uv2rgb(ld->rgbval[j], tms, uvp);
177		setuv(ld, j);
178		}
179		cs[3*i  ] = ld->rgbval[j][RED];
#	Line 183 | Line 185 | int    len;
185
186
187		int
188	<	tmCvLuv24(ls, cs, luvs, len)            /* convert raw 24-bit LogLuv values */
189	<	TMbright        *ls;
190	<	BYTE    *cs;
191	<	uint32  *luvs;
192	<	int     len;
188	>	tmCvLuv24(                      /* convert raw 24-bit LogLuv values */
189	>	TMstruct        *tms,
190	>	TMbright        *ls,
191	>	BYTE    *cs,
192	>	uint32  *luvs,
193	>	int     len
194	>	)
195		{
196		char    funcName[] = "tmCvLuv24";
197		double  uvp[2];
198		register LUV24DATA      *ld;
199		register int    i, j;
200		/* check arguments */
201	<	if (tmTop == NULL)
201	>	if (tms == NULL)
202		returnErr(TM_E_TMINVAL);
203		if ((ls == NULL) | (luvs == NULL) | (len < 0))
204		returnErr(TM_E_ILLEGAL);
#	Line 205 | Line 209 | int    len;
209		tmMkMesofact();
210		}
211		/* get package data */
212	<	if ((ld = (LUV24DATA *)tmPkgData(tmTop,luv24Reg)) == NULL)
212	>	if ((ld = (LUV24DATA *)tmPkgData(tms,luv24Reg)) == NULL)
213		returnErr(TM_E_NOMEM);
214		/* convert each pixel */
215		for (i = len; i--; ) {
#	Line 214 | Line 218 | int    len;
218		if (cs == TM_NOCHROM)           /* no color? */
219		continue;
220		/* get chrominance */
221	<	if (tmTop->flags & TM_F_MESOPIC && ls[i] < BMESUPPER) {
221	>	if (tms->flags & TM_F_MESOPIC && ls[i] < BMESUPPER) {
222		if (uv_decode(&uvp[0], &uvp[1], luvs[i]&0x3fff) < 0) {
223		uvp[0] = U_NEU;         /* should barf? */
224		uvp[1] = V_NEU;
225		}
226		ls[i] = compmeshift(ls[i], uvp);
227	<	if (tmTop->flags&TM_F_BW || ls[i]<BMESLOWER
227	>	if (tms->flags&TM_F_BW || ls[i]<BMESLOWER
228		|| (j = uv_encode(uvp[0], uvp[1],
229		SGILOGENCODE_NODITHER)) < 0)
230		j = uv14neu;
231		} else {
232	<	j = tmTop->flags&TM_F_BW ? uv14neu :
232	>	j = tms->flags&TM_F_BW ? uv14neu :
233		(int)(luvs[i]&0x3fff);
234		}
235		if (!isuvset(ld, j)) {
236		if (uv_decode(&uvp[0], &uvp[1], j) < 0) {
237		uvp[0] = U_NEU; uvp[1] = V_NEU;
238		}
239	<	uv2rgb(ld->rgbval[j], tmTop, uvp);
239	>	uv2rgb(ld->rgbval[j], tms, uvp);
240		setuv(ld, j);
241		}
242		cs[3*i  ] = ld->rgbval[j][RED];
#	Line 244 | Line 248 | int    len;
248
249
250		int
251	<	tmCvL16(ls, l16s, len)                  /* convert 16-bit LogL values */
252	<	TMbright        *ls;
253	<	uint16  *l16s;
254	<	int     len;
251	>	tmCvL16(                                /* convert 16-bit LogL values */
252	>	TMstruct        *tms,
253	>	TMbright        *ls,
254	>	uint16  *l16s,
255	>	int     len
256	>	)
257		{
258		static char     funcName[] = "tmCvL16";
259		static double   lastsf;
260		static int      offset;
261		register int    i;
262		/* check arguments */
263	<	if (tmTop == NULL)
263	>	if (tms == NULL)
264		returnErr(TM_E_TMINVAL);
265		if ((ls == NULL) | (l16s == NULL) | (len < 0))
266		returnErr(TM_E_ILLEGAL);
267		/* check scaling offset */
268	<	if (!FEQ(tmTop->inpsf, lastsf)) {
268	>	if (!FEQ(tms->inpsf, lastsf)) {
269		offset = BRT2SCALE(64);
270	<	if (tmTop->inpsf > 1.0001)
271	<	offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)+.5);
272	<	else if (tmTop->inpsf < 0.9999)
273	<	offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)-.5);
274	<	lastsf = tmTop->inpsf;
270	>	if (tms->inpsf > 1.0001)
271	>	offset -= (int)(TM_BRTSCALE*log(tms->inpsf)+.5);
272	>	else if (tms->inpsf < 0.9999)
273	>	offset -= (int)(TM_BRTSCALE*log(tms->inpsf)-.5);
274	>	lastsf = tms->inpsf;
275		}
276		/* convert each pixel */
277		for (i = len; i--; ) {
#	Line 279 | Line 285 | int    len;
285
286
287		static void
288	<	luv32NewSpace(tm)               /* initialize 32-bit LogLuv color space */
289	<	struct tmStruct *tm;
288	>	luv32NewSpace(tms)              /* initialize 32-bit LogLuv color space */
289	>	TMstruct        *tms;
290		{
291		register LUV32DATA      *ld;
292
293	<	if (tm->inppri != TM_XYZPRIM) {         /* panic time! */
293	>	if (tms->inppri != TM_XYZPRIM) {                /* panic time! */
294		fputs("Improper input color space in luv32NewSpace!\n", stderr);
295		exit(1);
296		}
297	<	ld = (LUV32DATA *)tm->pd[luv32Reg];
297	>	ld = (LUV32DATA *)tms->pd[luv32Reg];
298		ld->offset = BRT2SCALE(64);
299	<	if (tm->inpsf > 1.0001)
300	<	ld->offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)+.5);
301	<	else if (tm->inpsf < 0.9999)
302	<	ld->offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)-.5);
299	>	if (tms->inpsf > 1.0001)
300	>	ld->offset -= (int)(TM_BRTSCALE*log(tms->inpsf)+.5);
301	>	else if (tms->inpsf < 0.9999)
302	>	ld->offset -= (int)(TM_BRTSCALE*log(tms->inpsf)-.5);
303		clruvall(ld);
304		}
305
306
307		static MEM_PTR
308	<	luv32Init(tm)                   /* allocate data for 32-bit LogLuv decoder */
309	<	struct tmStruct *tm;
308	>	luv32Init(tms)                  /* allocate data for 32-bit LogLuv decoder */
309	>	TMstruct        *tms;
310		{
311		register LUV32DATA      *ld;
312
313		ld = (LUV32DATA *)malloc(sizeof(LUV32DATA));
314		if (ld == NULL)
315		return(NULL);
316	<	tm->pd[luv32Reg] = (MEM_PTR)ld;
317	<	luv32NewSpace(tm);
316	>	tms->pd[luv32Reg] = (MEM_PTR)ld;
317	>	luv32NewSpace(tms);
318		return((MEM_PTR)ld);
319		}
320
321
322		static void
323	<	luv24NewSpace(tm)               /* initialize 24-bit LogLuv color space */
324	<	struct tmStruct *tm;
323	>	luv24NewSpace(tms)              /* initialize 24-bit LogLuv color space */
324	>	TMstruct *tms;
325		{
326		register LUV24DATA      *ld;
327
328	<	if (tm->inppri != TM_XYZPRIM) {         /* panic time! */
328	>	if (tms->inppri != TM_XYZPRIM) {                /* panic time! */
329		fputs("Improper input color space in luv24NewSpace!\n", stderr);
330		exit(1);
331		}
332	<	ld = (LUV24DATA *)tm->pd[luv24Reg];
332	>	ld = (LUV24DATA *)tms->pd[luv24Reg];
333		ld->offset = BRT2SCALE(12);
334	<	if (tm->inpsf > 1.0001)
335	<	ld->offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)+.5);
336	<	else if (tm->inpsf < 0.9999)
337	<	ld->offset -= (int)(TM_BRTSCALE*log(tmTop->inpsf)-.5);
334	>	if (tms->inpsf > 1.0001)
335	>	ld->offset -= (int)(TM_BRTSCALE*log(tms->inpsf)+.5);
336	>	else if (tms->inpsf < 0.9999)
337	>	ld->offset -= (int)(TM_BRTSCALE*log(tms->inpsf)-.5);
338		clruvall(ld);
339		}
340
341
342		static MEM_PTR
343	<	luv24Init(tm)                   /* allocate data for 24-bit LogLuv decoder */
344	<	struct tmStruct *tm;
343	>	luv24Init(tms)                  /* allocate data for 24-bit LogLuv decoder */
344	>	TMstruct        *tms;
345		{
346		register LUV24DATA      *ld;
347
348		ld = (LUV24DATA *)malloc(sizeof(LUV24DATA));
349		if (ld == NULL)
350		return(NULL);
351	<	tm->pd[luv24Reg] = (MEM_PTR)ld;
351	>	tms->pd[luv24Reg] = (MEM_PTR)ld;
352		if (uv14neu < 0)                /* initialize neutral color index */
353		uv14neu = uv_encode(U_NEU, V_NEU, SGILOGENCODE_NODITHER);
354	<	luv24NewSpace(tm);
354	>	luv24NewSpace(tms);
355		return((MEM_PTR)ld);
356		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)