Bunch of gcc 4.0 warning fixes.
[blender.git] / source / blender / imbuf / intern / cspace.c
1 /**
2  *
3  * $Id$
4  *
5  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version. The Blender
11  * Foundation also sells licenses for use in proprietary software under
12  * the Blender License.  See http://www.blender.org/BL/ for information
13  * about this.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
25  * All rights reserved.
26  *
27  * The Original Code is: all of this file.
28  *
29  * Contributor(s): none yet.
30  *
31  * ***** END GPL/BL DUAL LICENSE BLOCK *****
32  */
33
34 #include "BLI_blenlib.h"
35
36 #include "imbuf.h"
37 #include "imbuf_patch.h"
38 #include "IMB_imbuf_types.h"
39
40 void IMB_cspace(struct ImBuf *ibuf, float mat[][4]);
41
42 /************************************************************************/
43 /*                              COLORSPACE                              */
44 /************************************************************************/
45
46 static void fillmattab(double val, unsigned short *mattab)
47 {
48         int tot,ival;
49         int i;
50
51         val *= (1 << 22);
52         ival = val;
53         tot = 32767; /* een half */
54
55         for(i = 256; i > 0; i--){
56                 *(mattab) = (tot >> 16);
57                 mattab += 3;
58                 tot += ival;
59         }
60 }
61
62
63 static void cspfill(short *buf, unsigned short *fill, int x)
64 {
65         unsigned short r,g,b;
66
67         b = fill[0];
68         g = fill[1];
69         r = fill[2];
70         for (;x>0;x--){
71                 buf[0] = b;
72                 buf[1] = g;
73                 buf[2] = r;
74                 buf += 3;
75         }
76 }
77
78
79 static void cspadd(short *buf, unsigned short *cont, unsigned char *rect, int x)
80 {
81         short i;
82         for (;x>0;x--){
83                 i = *(rect);
84                 rect += 4;
85                 buf[0] += cont[i*3];
86                 buf[1] += cont[i*3 + 1];
87                 buf[2] += cont[i*3 + 2];
88                 buf += 3;
89         }
90 }
91
92
93 static void cspret(short *buf, unsigned char *rect, int x)
94 {
95         int r,g,b;
96         
97         for(; x > 0; x--){
98                 b = buf[0];
99                 g = buf[1];
100                 r = buf[2];
101
102                 if (b & 0x4000){
103                         if (b<0) rect[2]=0;
104                         else rect[2]=255;
105                 } else rect[2] = b >> 6;
106
107                 if (g & 0x4000){
108                         if (g<0) rect[1]=0;
109                         else rect[1]=255;
110                 } else rect[1] = g >> 6;
111
112                 if (r & 0x4000){
113                         if (r<0) rect[0]=0;
114                         else rect[0]=255;
115                 } else rect[0] = r >> 6;
116
117                 buf += 3;
118                 rect += 4;
119         }
120 }
121
122
123 static void rotcspace(struct ImBuf *ibuf, unsigned short *cont_1, unsigned short *cont_2, unsigned short *cont_3, unsigned short *add)
124 {
125         short x,y,*buf;
126         uchar *rect;
127
128         x=ibuf->x;
129         rect= (uchar *)ibuf->rect;
130
131         buf=(short *)malloc(x*3*sizeof(short));
132         if (buf){
133                 for(y=ibuf->y;y>0;y--){
134                         cspfill(buf,add,x);
135                         cspadd(buf,cont_1,rect+0,x);
136                         cspadd(buf,cont_2,rect+1,x);
137                         cspadd(buf,cont_3,rect+2,x);
138                         cspret(buf,rect,x);
139                         rect += x<<2;
140                 }
141                 free(buf);
142         }
143 }
144
145
146 void IMB_cspace(struct ImBuf *ibuf, float mat[][4])
147 {
148         unsigned short *cont_1,*cont_2,*cont_3,add[3];
149
150         cont_1=(unsigned short *)malloc(256*3*sizeof(short));
151         cont_2=(unsigned short *)malloc(256*3*sizeof(short));
152         cont_3=(unsigned short *)malloc(256*3*sizeof(short));
153
154         if (cont_1 && cont_2 && cont_3){
155
156                 fillmattab(mat[0][0],cont_1);
157                 fillmattab(mat[0][1],cont_1+1);
158                 fillmattab(mat[0][2],cont_1+2);
159
160                 fillmattab(mat[1][0],cont_2);
161                 fillmattab(mat[1][1],cont_2+1);
162                 fillmattab(mat[1][2],cont_2+2);
163
164                 fillmattab(mat[2][0],cont_3);
165                 fillmattab(mat[2][1],cont_3+1);
166                 fillmattab(mat[2][2],cont_3+2);
167
168                 add[0] = (mat[3][0] * 64.0) + .5;
169                 add[1] = (mat[3][1] * 64.0) + .5;
170                 add[2] = (mat[3][2] * 64.0) + .5;
171
172                 rotcspace(ibuf, cont_1, cont_2, cont_3, add);
173         }
174
175         if (cont_1) free(cont_1);
176         if (cont_2) free(cont_2);
177         if (cont_3) free(cont_3);
178 }
179