darwin fixes
[swftools.git] / lib / gfximage.c
1 #include <stdlib.h>
2 #include <math.h>
3 #include <memory.h>
4 #include "jpeg.h"
5 #include "png.h"
6 #include "mem.h"
7 #include "gfximage.h"
8 #include "types.h"
9
10 void gfximage_save_jpeg(gfximage_t*img, const char*filename, int quality)
11 {
12     int x,y;
13     int l = img->width*img->height;
14     unsigned char*data = (unsigned char*)rfx_alloc(img->width*img->height*3);
15     int s,t;
16     for(t=0,s=0;t<l;s+=3,t++) {
17         data[s+0] = img->data[t].r;
18         data[s+1] = img->data[t].g;
19         data[s+2] = img->data[t].b;
20     }
21     jpeg_save(data, img->width, img->height, quality, filename);
22     free(data);
23 }
24
25 void gfximage_save_png(gfximage_t*image, const char*filename)
26 {
27     writePNG(filename, (void*)image->data, image->width, image->height);
28 }
29
30 typedef struct scale_lookup {
31     int pos;
32     unsigned int weight;
33 } scale_lookup_t;
34
35 typedef struct rgba_int {
36     unsigned int r,g,b,a;
37 } rgba_int_t;
38
39 static int bicubic = 0;
40
41 static scale_lookup_t**make_scale_lookup(int width, int newwidth)
42 {
43     scale_lookup_t*lookupx = (scale_lookup_t*)rfx_alloc((width>newwidth?width:newwidth)*2*sizeof(scale_lookup_t));
44     scale_lookup_t**lblockx = (scale_lookup_t**)rfx_alloc((newwidth+1)*sizeof(scale_lookup_t**));
45     double fx = ((double)width)/((double)newwidth);
46     double px = 0;
47     int x;
48     scale_lookup_t*p_x = lookupx;
49
50     if(newwidth<=width) {
51         for(x=0;x<newwidth;x++) {
52             double ex = px + fx;
53             int fromx = (int)px;
54             int tox = (int)ex;
55             double rem = fromx+1-px;
56             int i = (int)(256/fx);
57             int xweight = (int)(rem*256/fx);
58             int xx;
59             int w = 0;
60             lblockx[x] = p_x;
61             if(tox>=width) tox = width-1;
62             for(xx=fromx;xx<=tox;xx++) {
63                 if(xx==fromx && xx==tox) p_x->weight = 256;
64                 else if(xx==fromx) p_x->weight = xweight;
65                 else if(xx==tox) p_x->weight = 256-w;
66                 else p_x->weight = i;
67                 w+=p_x->weight;
68                 p_x->pos = xx;
69                 p_x++;
70             }
71             px = ex;
72         }
73     } else {
74         for(x=0;x<newwidth;x++) {
75             int ix1 = (int)px;
76             int ix2 = ((int)px)+1;
77             double r = px-ix1;
78             if(ix2>=width) ix2=width-1;
79             lblockx[x] = p_x;
80             if(bicubic)
81                 r = -2*r*r*r+3*r*r;
82             p_x[0].weight = (int)(256*(1-r));
83             p_x[0].pos = ix1;
84             p_x[1].weight = 256-p_x[0].weight;
85             p_x[1].pos = ix2;
86             p_x+=2;
87             px += fx;
88         }
89     }
90     lblockx[newwidth] = p_x;
91     return lblockx;
92 }
93
94 static void encodeMonochromeImage(gfxcolor_t*data, int width, int height, gfxcolor_t*colors)
95 {
96     int t;
97     int len = width*height;
98
99     U32* img = (U32*)data;
100     U32 color1 = img[0];
101     U32 color2 = 0;
102     for(t=1;t<len;t++) {
103         if(img[t] != color1) {
104             color2 = img[t];
105             break;
106         }
107     }
108     *(U32*)&colors[0] = color1;
109     *(U32*)&colors[1] = color2;
110     for(t=0;t<len;t++) {
111         if(img[t] == color1) {
112             img[t] = 0;
113         } else {
114             img[t] = 0xffffffff;
115         }
116     }
117 }
118
119 static void decodeMonochromeImage(gfxcolor_t*data, int width, int height, gfxcolor_t*colors)
120 {
121     int t;
122     int len = width*height;
123
124     for(t=0;t<len;t++) {
125         U32 m = data[t].r;
126         data[t].r = (colors[0].r * (255-m) + colors[1].r * m) >> 8;
127         data[t].g = (colors[0].g * (255-m) + colors[1].g * m) >> 8;
128         data[t].b = (colors[0].b * (255-m) + colors[1].b * m) >> 8;
129         data[t].a = (colors[0].a * (255-m) + colors[1].a * m) >> 8;
130     }
131 }
132
133 void blurImage(gfxcolor_t*src, int width, int height, int r)  __attribute__ ((noinline));
134
135 void blurImage(gfxcolor_t*src, int width, int height, int r)
136 {
137     int e = 2; // r times e is the sampling interval
138     double*gauss = (double*)rfx_alloc(r*e*sizeof(double));
139     double sum=0;
140     int x;
141     for(x=0;x<r*e;x++) {
142         double t = (x - r*e/2.0)/r;
143         gauss[x] = exp(-0.5*t*t);
144         sum += gauss[x];
145     }
146     int*weights = (int*)rfx_alloc(r*e*sizeof(int));
147     for(x=0;x<r*e;x++) {
148         weights[x] = (int)(gauss[x]*65536.0001/sum);
149     }
150     int range = r*e/2;
151
152     gfxcolor_t*tmp = rfx_alloc(sizeof(gfxcolor_t)*width*height);
153
154     int y;
155     for(y=0;y<height;y++) {
156         gfxcolor_t*s = &src[y*width];
157         gfxcolor_t*d = &tmp[y*width];
158         for(x=0;x<range;x++) {
159             d[x] = s[x];
160         }
161         for(x=range;x<width-range;x++) {
162             int r=0;
163             int g=0;
164             int b=0;
165             int a=0;
166             int*f = weights;
167             int xx;
168             for(xx=x-range;xx<x+range;xx++) {
169                 r += s[xx].r * f[0];
170                 g += s[xx].g * f[0];
171                 b += s[xx].b * f[0];
172                 a += s[xx].a * f[0];
173                 f++;
174             }
175             d[x].r = r >> 16;
176             d[x].g = g >> 16;
177             d[x].b = b >> 16;
178             d[x].a = a >> 16;
179         }
180         for(x=width-range;x<width;x++) {
181             d[x] = s[x];
182         }
183     }
184
185     for(x=0;x<width;x++) {
186         gfxcolor_t*s = &tmp[x];
187         gfxcolor_t*d = &src[x];
188         int yy=0;
189         for(y=0;y<range;y++) {
190             d[yy] = s[yy];
191             yy+=width;
192         }
193         for(y=range;y<height-range;y++) {
194             int r=0;
195             int g=0;
196             int b=0;
197             int a=0;
198             int*f = weights;
199             int cy,cyy=yy-range*width;
200             for(cy=y-range;cy<y+range;cy++) {
201                 r += s[cyy].r * f[0];
202                 g += s[cyy].g * f[0];
203                 b += s[cyy].b * f[0];
204                 a += s[cyy].a * f[0];
205                 cyy += width;
206                 f++;
207             }
208             d[yy].r = r >> 16;
209             d[yy].g = g >> 16;
210             d[yy].b = b >> 16;
211             d[yy].a = a >> 16;
212             yy += width;
213         }
214         for(y=0;y<range;y++) {
215             d[yy] = s[yy];
216             yy += width;
217         }
218     }
219
220     rfx_free(tmp);
221     rfx_free(weights);
222     rfx_free(gauss);
223 }
224
225 int swf_ImageGetNumberOfPaletteEntries2(gfxcolor_t*_img, int width, int height)
226 {
227     int len = width*height;
228     int t;
229     U32* img = (U32*)_img;
230     U32 color1 = img[0];
231     U32 color2 = 0;
232     for(t=1;t<len;t++) {
233         if(img[t] != color1) {
234             color2 = img[t];
235             break;
236         }
237     }
238     if(t==len)
239         return 1;
240
241     for(;t<len;t++) {
242         if(img[t] != color1 && img[t] != color2) {
243             return width*height;
244         }
245     }
246     return 2;
247 }
248
249 gfximage_t* gfximage_rescale(gfximage_t*image, int newwidth, int newheight)
250 {
251     int x,y;
252     gfxcolor_t* newdata; 
253     scale_lookup_t *p, **lblockx,**lblocky;
254     rgba_int_t*tmpline;
255     int monochrome = 0;
256     gfxcolor_t monochrome_colors[2];
257     
258     if(newwidth<1 || newheight<1)
259         return 0;
260
261     int width = image->width;
262     int height = image->height;
263     gfxcolor_t*data = image->data;
264
265     if(swf_ImageGetNumberOfPaletteEntries2(data, width, height) == 2) {
266         monochrome=1;
267         encodeMonochromeImage(data, width, height, monochrome_colors);
268         int r1 = width / newwidth;
269         int r2 = height / newheight;
270         int r = r1<r2?r1:r2;
271         if(r>4) {
272             /* high-resolution monochrome images are usually dithered, so 
273                low-pass filter them first to get rid of any moire patterns */
274             blurImage(data, width, height, r+1);
275         }
276     }
277
278     tmpline = (rgba_int_t*)rfx_alloc(width*sizeof(rgba_int_t));
279     newdata = (gfxcolor_t*)rfx_alloc(newwidth*newheight*sizeof(gfxcolor_t));
280   
281     lblockx = make_scale_lookup(width, newwidth);
282     lblocky = make_scale_lookup(height, newheight);
283
284     for(p=lblocky[0];p<lblocky[newheight];p++)
285         p->pos*=width;
286
287     for(y=0;y<newheight;y++) {
288         gfxcolor_t*destline = &newdata[y*newwidth];
289         
290         /* create lookup table for y */
291         rgba_int_t*l = tmpline;
292         scale_lookup_t*p_y,*p_x;
293         memset(tmpline, 0, width*sizeof(rgba_int_t));
294         for(p_y=lblocky[y];p_y<lblocky[y+1];p_y++) {
295             gfxcolor_t*line = &data[p_y->pos];
296             scale_lookup_t*p_x;
297             int weight = p_y->weight;
298             for(x=0;x<width;x++) {
299                 tmpline[x].r += line[x].r*weight;
300                 tmpline[x].g += line[x].g*weight;
301                 tmpline[x].b += line[x].b*weight;
302                 tmpline[x].a += line[x].a*weight;
303             }
304         }
305
306         /* process x direction */
307         p_x = lblockx[0];
308         for(x=0;x<newwidth;x++) {
309             unsigned int r=0,g=0,b=0,a=0;
310             scale_lookup_t*p_x_to = lblockx[x+1];
311             do { 
312                 rgba_int_t* col = &tmpline[p_x->pos];
313                 unsigned int weight = p_x->weight;
314                 r += col->r*weight;
315                 g += col->g*weight;
316                 b += col->b*weight;
317                 a += col->a*weight;
318                 p_x++;
319             } while (p_x<p_x_to);
320
321             destline->r = r >> 16;
322             destline->g = g >> 16;
323             destline->b = b >> 16;
324             destline->a = a >> 16;
325            
326             destline++;
327         }
328     }
329
330     if(monochrome)
331         decodeMonochromeImage(newdata, newwidth, newheight, monochrome_colors);
332
333     rfx_free(tmpline);
334     rfx_free(*lblockx);
335     rfx_free(lblockx);
336     rfx_free(*lblocky);
337     rfx_free(lblocky);
338
339     gfximage_t*image2 = (gfximage_t*)malloc(sizeof(gfximage_t));
340     image2->data = newdata;
341     image2->width = newwidth;
342     image2->height = newheight;
343     return image2;
344 }
345
346 void gfximage_free(gfximage_t*b)
347 {
348     free(b->data);
349     b->data = 0;
350     free(b);
351 }
352