initial commit, eq circuit emulator
[eqemu] / libs / libimago / src / conv.c
1 /*
2 libimago - a multi-format image file input/output library.
3 Copyright (C) 2010 John Tsiombikas <nuclear@member.fsf.org>
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU Lesser General Public License as published
7 by the Free Software Foundation, either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public License
16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18 #include <string.h>
19 #include "imago2.h"
20
21 /* pixel-format conversions are sub-optimal at the moment to avoid
22  * writing a lot of code. optimize at some point ?
23  */
24
25 #define CLAMP(x, a, b)  ((x) < (a) ? (a) : ((x) > (b) ? (b) : (x)))
26
27 struct pixel {
28         float r, g, b, a;
29 };
30
31 static void unpack_grey8(struct pixel *unp, void *pptr, int count);
32 static void unpack_rgb24(struct pixel *unp, void *pptr, int count);
33 static void unpack_rgba32(struct pixel *unp, void *pptr, int count);
34 static void unpack_greyf(struct pixel *unp, void *pptr, int count);
35 static void unpack_rgbf(struct pixel *unp, void *pptr, int count);
36 static void unpack_rgbaf(struct pixel *unp, void *pptr, int count);
37
38 static void pack_grey8(void *pptr, struct pixel *unp, int count);
39 static void pack_rgb24(void *pptr, struct pixel *unp, int count);
40 static void pack_rgba32(void *pptr, struct pixel *unp, int count);
41 static void pack_greyf(void *pptr, struct pixel *unp, int count);
42 static void pack_rgbf(void *pptr, struct pixel *unp, int count);
43 static void pack_rgbaf(void *pptr, struct pixel *unp, int count);
44
45 /* XXX keep in sync with enum img_fmt at imago2.h */
46 static void (*unpack[])(struct pixel*, void*, int) = {
47         unpack_grey8,
48         unpack_rgb24,
49         unpack_rgba32,
50         unpack_greyf,
51         unpack_rgbf,
52         unpack_rgbaf
53 };
54
55 /* XXX keep in sync with enum img_fmt at imago2.h */
56 static void (*pack[])(void*, struct pixel*, int) = {
57         pack_grey8,
58         pack_rgb24,
59         pack_rgba32,
60         pack_greyf,
61         pack_rgbf,
62         pack_rgbaf
63 };
64
65
66 int img_convert(struct img_pixmap *img, enum img_fmt tofmt)
67 {
68         struct pixel pbuf[8];
69         int bufsz = (img->width & 7) == 0 ? 8 : ((img->width & 3) == 0 ? 4 : 1);
70         int i, num_pix = img->width * img->height;
71         int num_iter = num_pix / bufsz;
72         char *sptr, *dptr;
73         struct img_pixmap nimg;
74
75         if(img->fmt == tofmt) {
76                 return 0;       /* nothing to do */
77         }
78
79         img_init(&nimg);
80         if(img_set_pixels(&nimg, img->width, img->height, tofmt, 0) == -1) {
81                 img_destroy(&nimg);
82                 return -1;
83         }
84
85         sptr = img->pixels;
86         dptr = nimg.pixels;
87
88         for(i=0; i<num_iter; i++) {
89                 unpack[img->fmt](pbuf, sptr, bufsz);
90                 pack[tofmt](dptr, pbuf, bufsz);
91
92                 sptr += bufsz * img->pixelsz;
93                 dptr += bufsz * nimg.pixelsz;
94         }
95
96         img_copy(img, &nimg);
97         img_destroy(&nimg);
98         return 0;
99 }
100
101 /* the following functions *could* benefit from SIMD */
102
103 static void unpack_grey8(struct pixel *unp, void *pptr, int count)
104 {
105         int i;
106         unsigned char *pix = pptr;
107
108         for(i=0; i<count; i++) {
109                 unp->r = unp->g = unp->b = (float)*pix++ / 255.0;
110                 unp->a = 1.0;
111                 unp++;
112         }
113 }
114
115 static void unpack_rgb24(struct pixel *unp, void *pptr, int count)
116 {
117         int i;
118         unsigned char *pix = pptr;
119
120         for(i=0; i<count; i++) {
121                 unp->r = (float)*pix++ / 255.0;
122                 unp->g = (float)*pix++ / 255.0;
123                 unp->b = (float)*pix++ / 255.0;
124                 unp->a = 1.0;
125                 unp++;
126         }
127 }
128
129 static void unpack_rgba32(struct pixel *unp, void *pptr, int count)
130 {
131         int i;
132         unsigned char *pix = pptr;
133
134         for(i=0; i<count; i++) {
135                 unp->r = (float)*pix++ / 255.0;
136                 unp->g = (float)*pix++ / 255.0;
137                 unp->b = (float)*pix++ / 255.0;
138                 unp->a = (float)*pix++ / 255.0;
139                 unp++;
140         }
141 }
142
143 static void unpack_greyf(struct pixel *unp, void *pptr, int count)
144 {
145         int i;
146         float *pix = pptr;
147
148         for(i=0; i<count; i++) {
149                 unp->r = unp->g = unp->b = *pix++;
150                 unp->a = 1.0;
151                 unp++;
152         }
153 }
154
155 static void unpack_rgbf(struct pixel *unp, void *pptr, int count)
156 {
157         int i;
158         float *pix = pptr;
159
160         for(i=0; i<count; i++) {
161                 unp->r = *pix++;
162                 unp->g = *pix++;
163                 unp->b = *pix++;
164                 unp->a = 1.0;
165                 unp++;
166         }
167 }
168
169 static void unpack_rgbaf(struct pixel *unp, void *pptr, int count)
170 {
171         int i;
172         float *pix = pptr;
173
174         for(i=0; i<count; i++) {
175                 unp->r = *pix++;
176                 unp->g = *pix++;
177                 unp->b = *pix++;
178                 unp->a = *pix++;
179                 unp++;
180         }
181 }
182
183
184 static void pack_grey8(void *pptr, struct pixel *unp, int count)
185 {
186         int i;
187         unsigned char *pix = pptr;
188
189         for(i=0; i<count; i++) {
190                 int lum = (int)(255.0 * (unp->r + unp->g + unp->b) / 3.0);
191                 *pix++ = CLAMP(lum, 0, 255);
192                 unp++;
193         }
194 }
195
196 static void pack_rgb24(void *pptr, struct pixel *unp, int count)
197 {
198         int i;
199         unsigned char *pix = pptr;
200
201         for(i=0; i<count; i++) {
202                 int r = (int)(unp->r * 255.0);
203                 int g = (int)(unp->g * 255.0);
204                 int b = (int)(unp->b * 255.0);
205
206                 *pix++ = CLAMP(r, 0, 255);
207                 *pix++ = CLAMP(g, 0, 255);
208                 *pix++ = CLAMP(b, 0, 255);
209                 unp++;
210         }
211 }
212
213 static void pack_rgba32(void *pptr, struct pixel *unp, int count)
214 {
215         int i;
216         unsigned char *pix = pptr;
217
218         for(i=0; i<count; i++) {
219                 int r = (int)(unp->r * 255.0);
220                 int g = (int)(unp->g * 255.0);
221                 int b = (int)(unp->b * 255.0);
222                 int a = (int)(unp->a * 255.0);
223
224                 *pix++ = CLAMP(r, 0, 255);
225                 *pix++ = CLAMP(g, 0, 255);
226                 *pix++ = CLAMP(b, 0, 255);
227                 *pix++ = CLAMP(a, 0, 255);
228                 unp++;
229         }
230 }
231
232 static void pack_greyf(void *pptr, struct pixel *unp, int count)
233 {
234         int i;
235         float *pix = pptr;
236
237         for(i=0; i<count; i++) {
238                 *pix++ = (unp->r + unp->g + unp->b) / 3.0;
239                 unp++;
240         }
241 }
242
243 static void pack_rgbf(void *pptr, struct pixel *unp, int count)
244 {
245         int i;
246         float *pix = pptr;
247
248         for(i=0; i<count; i++) {
249                 *pix++ = unp->r;
250                 *pix++ = unp->g;
251                 *pix++ = unp->b;
252                 unp++;
253         }
254 }
255
256 static void pack_rgbaf(void *pptr, struct pixel *unp, int count)
257 {
258         memcpy(pptr, unp, count * sizeof *unp);
259 }
260