added palette image support
[swftools.git] / lib / devices / render.c
1 /* render.c
2
3    Part of the swftools package.
4
5    Copyright (c) 2005/2006/2007 Matthias Kramm <kramm@quiss.org> 
6  
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
20
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <math.h>
24 #include <memory.h>
25 #include "../gfxdevice.h"
26 #include "../gfxtools.h"
27 #include "../mem.h"
28 #define PNG_INLINE_EXPORTS
29 #include "../types.h"
30 #include "../png.c"
31 #include "../log.h"
32 #include "render.h"
33
34 typedef gfxcolor_t RGBA;
35
36 typedef struct _renderpoint
37 {
38     float x;
39 } renderpoint_t;
40
41 typedef struct _renderline
42 {
43     renderpoint_t*points;
44     int size;
45     int num;
46 } renderline_t;
47
48 typedef struct _internal_result {
49     gfximage_t img;
50     struct _internal_result*next;
51     char palette;
52 } internal_result_t;
53
54 typedef struct _clipbuffer {
55     U32*data;
56     struct _clipbuffer*next;
57 } clipbuffer_t;
58
59 typedef struct _internal {
60     int width;
61     int height;
62     int width2;
63     int height2;
64     int bitwidth;
65     int multiply;
66     int antialize;
67     int zoom;
68     int ymin, ymax;
69     int fillwhite;
70
71     char palette;
72
73     RGBA* img;
74
75     clipbuffer_t*clipbuf;
76
77     renderline_t*lines;
78
79     internal_result_t*results;
80     internal_result_t*result_next;
81 } internal_t;
82
83 typedef enum {filltype_solid,filltype_clip,filltype_bitmap,filltype_gradient} filltype_t;
84
85 typedef struct _fillinfo {
86     filltype_t type;
87     gfxcolor_t*color;
88     gfximage_t*image;
89     gfxmatrix_t*matrix;
90     gfxcxform_t*cxform;
91     RGBA*gradient;
92     char clip_or_radial;
93 } fillinfo_t;
94
95
96 static inline void add_pixel(internal_t*i, float x, int y)
97 {
98     renderpoint_t p;
99
100     if(x >= i->width2 || y >= i->height2 || y<0) return;
101     p.x = x;
102     if(y<i->ymin) i->ymin = y;
103     if(y>i->ymax) i->ymax = y;
104
105     renderline_t*l = &i->lines[y];
106
107     if(l->num == l->size) {
108         l->size += 32;
109         l->points = (renderpoint_t*)rfx_realloc(l->points, l->size * sizeof(renderpoint_t));
110     }
111     l->points[l->num] = p;
112     l->num++;
113 }
114
115 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
116    problem appears to often */
117 #define CUT 0.5
118
119 #define INT(x) ((int)((x)+16)-16)
120
121 static void add_line(gfxdevice_t*dev , double x1, double y1, double x2, double y2)
122 {
123     internal_t*i = (internal_t*)dev->internal;
124     double diffx, diffy;
125     double ny1, ny2, stepx;
126 /*    if(DEBUG&4) {
127         int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
128         printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
129     }*/
130
131     if(y2 < y1) {
132         double x;
133         double y;
134         x = x1;x1 = x2;x2=x;
135         y = y1;y1 = y2;y2=y;
136     }
137     
138     diffx = x2 - x1;
139     diffy = y2 - y1;
140     
141     ny1 = INT(y1)+CUT;
142     ny2 = INT(y2)+CUT;
143
144     if(ny1 < y1) {
145         ny1 = INT(y1) + 1.0 + CUT;
146     }
147     if(ny2 >= y2) {
148         ny2 = INT(y2) - 1.0 + CUT;
149     }
150
151     if(ny1 > ny2)
152         return;
153
154     stepx = diffx/diffy;
155     x1 = x1 + (ny1-y1)*stepx;
156     x2 = x2 + (ny2-y2)*stepx;
157
158     {
159         int posy=INT(ny1);
160         int endy=INT(ny2);
161         double posx=0;
162         double startx = x1;
163
164         while(posy<=endy) {
165             float xx = (float)(startx + posx);
166             add_pixel(i, xx ,posy);
167             posx+=stepx;
168             posy++;
169         }
170     }
171 }
172 #define PI 3.14159265358979
173 static void add_solidline(gfxdevice_t*dev, double x1, double y1, double x2, double y2, double width)
174 {
175     /* TODO: handle cap styles */
176
177     internal_t*i = (internal_t*)dev->internal;
178
179     double dx = x2-x1;
180     double dy = y2-y1;
181     double sd;
182     double d;
183
184     int t;
185     int segments;
186     double lastx,lasty;
187     double vx,vy;
188     double xx,yy;
189   
190     /* Make sure the line is always at least one pixel wide */
191 #ifdef LINEMODE1
192     /* That's what Macromedia's Player does at least at zoom level >= 1.  */
193     width += 1.0;
194 #else
195     /* That's what Macromedia's Player seems to do at zoom level 0.  */
196     /* TODO: needs testing */
197
198     /* TODO: how does this interact with scaling? */
199     if(width * i->multiply < 1.0)
200         width = 1.0 / i->multiply;
201 #endif
202
203     sd = (double)dx*(double)dx+(double)dy*(double)dy;
204     d = sqrt(sd);
205
206     if(!dx && !dy) {
207         vx = 1;
208         vy = 0;
209     } else {
210         vx = ( dy/d);
211         vy = (-dx/d);
212     }
213
214     segments = width/2;
215     if(segments < 2)
216         segments = 2;
217
218     segments = 8;
219
220     vx=vx*width*0.5;
221     vy=vy*width*0.5;
222
223     xx = x2+vx;
224     yy = y2+vy;
225     add_line(dev, x1+vx, y1+vy, xx, yy);
226     lastx = xx;
227     lasty = yy;
228     for(t=1;t<segments;t++) {
229         double s = sin(t*PI/segments);
230         double c = cos(t*PI/segments);
231         xx = (x2 + vx*c - vy*s);
232         yy = (y2 + vx*s + vy*c);
233         add_line(dev, lastx, lasty, xx, yy);
234         lastx = xx;
235         lasty = yy;
236     }
237     
238     xx = (x2-vx);
239     yy = (y2-vy);
240     add_line(dev, lastx, lasty, xx, yy);
241     lastx = xx;
242     lasty = yy;
243     xx = (x1-vx);
244     yy = (y1-vy);
245     add_line(dev, lastx, lasty, xx, yy);
246     lastx = xx;
247     lasty = yy;
248     for(t=1;t<segments;t++) {
249         double s = sin(t*PI/segments);
250         double c = cos(t*PI/segments);
251         xx = (x1 - vx*c + vy*s);
252         yy = (y1 - vx*s - vy*c);
253         add_line(dev, lastx, lasty, xx, yy);
254         lastx = xx;
255         lasty = yy;
256     }
257     add_line(dev, lastx, lasty, (x1+vx), (y1+vy));
258 }
259
260 static int compare_renderpoints(const void * _a, const void * _b)
261 {
262     renderpoint_t*a = (renderpoint_t*)_a;
263     renderpoint_t*b = (renderpoint_t*)_b;
264     if(a->x < b->x) return -1;
265     if(a->x > b->x) return 1;
266     return 0;
267 }
268
269 static void fill_line_solid(RGBA*line, U32*z, int y, int x1, int x2, RGBA col)
270 {
271     int x = x1;
272
273     U32 bit = 1<<(x1&31);
274     int bitpos = (x1/32);
275
276     if(col.a!=255) {
277         int ainv = 255-col.a;
278         col.r = (col.r*col.a)>>8;
279         col.g = (col.g*col.a)>>8;
280         col.b = (col.b*col.a)>>8;
281         do {
282             if(z[bitpos]&bit) {
283                 line[x].r = ((line[x].r*ainv)>>8)+col.r;
284                 line[x].g = ((line[x].g*ainv)>>8)+col.g;
285                 line[x].b = ((line[x].b*ainv)>>8)+col.b;
286                 //line[x].a = 255;
287                 line[x].a = ((line[x].a*ainv)>>8)+col.a;
288             }
289             bit <<= 1;
290             if(!bit) {
291                 bit = 1;bitpos++;
292             }
293         } while(++x<x2);
294     } else {
295         do {
296             if(z[bitpos]&bit) {
297                 line[x] = col;
298             }
299             bit <<= 1;
300             if(!bit) {
301                 bit = 1;bitpos++;
302             }
303         } while(++x<x2);
304     }
305 }
306
307 static void fill_line_bitmap(RGBA*line, U32*z, int y, int x1, int x2, fillinfo_t*info)
308 {
309     int x = x1;
310
311     gfxmatrix_t*m = info->matrix;
312     gfximage_t*b = info->image;
313     
314     if(!b || !b->width || !b->height) {
315         gfxcolor_t red = {255,255,0,0};
316         fill_line_solid(line, z, y, x1, x2, red);
317         return;
318     }
319     
320     double det = m->m00*m->m11 - m->m01*m->m10;
321     if(fabs(det) < 0.0005) { 
322         /* x direction equals y direction- the image is invisible */
323         return;
324     }
325     det = 1.0/det;
326     double xx1 =  (  (-m->tx) * m->m11 - (y - m->ty) * m->m10) * det;
327     double yy1 =  (- (-m->tx) * m->m01 + (y - m->ty) * m->m00) * det;
328     double xinc1 = m->m11 * det;
329     double yinc1 = m->m01 * det;
330     
331     U32 bit = 1<<(x1&31);
332     int bitpos = (x1/32);
333
334     do {
335         if(z[bitpos]&bit) {
336             RGBA col;
337             int xx = (int)(xx1 + x * xinc1);
338             int yy = (int)(yy1 - x * yinc1);
339             int ainv;
340
341             if(info->clip_or_radial) {
342                 if(xx<0) xx=0;
343                 if(xx>=b->width) xx = b->width-1;
344                 if(yy<0) yy=0;
345                 if(yy>=b->height) yy = b->height-1;
346             } else {
347                 xx %= b->width;
348                 yy %= b->height;
349                 if(xx<0) xx += b->width;
350                 if(yy<0) yy += b->height;
351             }
352
353             col = b->data[yy*b->width+xx];
354             ainv = 255-col.a;
355
356             /* needs bitmap with premultiplied alpha */
357             line[x].r = ((line[x].r*ainv)>>8)+col.r;
358             line[x].g = ((line[x].g*ainv)>>8)+col.g;
359             line[x].b = ((line[x].b*ainv)>>8)+col.b;
360             line[x].a = 255;
361         }
362         bit <<= 1;
363         if(!bit) {
364             bit = 1;bitpos++;
365         }
366     } while(++x<x2);
367 }
368
369 static void fill_line_gradient(RGBA*line, U32*z, int y, int x1, int x2, fillinfo_t*info)
370 {
371     int x = x1;
372
373     gfxmatrix_t*m = info->matrix;
374     RGBA*g= info->gradient;
375     
376     double det = m->m00*m->m11 - m->m01*m->m10;
377     if(fabs(det) < 0.0005) { 
378         /* x direction equals y direction */
379         return;
380     }
381     det = 1.0/det;
382     double xx1 =  (  (-m->tx) * m->m11 - (y - m->ty) * m->m10) * det;
383     double yy1 =  (- (-m->tx) * m->m01 + (y - m->ty) * m->m00) * det;
384     double xinc1 = m->m11 * det;
385     double yinc1 = m->m01 * det;
386     
387     U32 bit = 1<<(x1&31);
388     int bitpos = (x1/32);
389
390     do {
391         if(z[bitpos]&bit) {
392             RGBA col;
393             int ainv;
394
395             int pos = 0;
396             if(info->clip_or_radial) {
397                 double xx = xx1 + x * xinc1;
398                 double yy = yy1 + y * yinc1;
399                 double r = sqrt(xx*xx + yy*yy);
400                 if(r>1) r = 1;
401                 pos = (int)(r*255.999);
402             } else {
403                 double r = xx1 + x * xinc1;
404                 if(r>1) r = 1;
405                 if(r<-1) r = -1;
406                 pos = (int)((r+1)*127.999);
407             }
408             col = g[pos];
409             ainv = 255-col.a;
410
411             /* needs bitmap with premultiplied alpha */
412             line[x].r = ((line[x].r*ainv)>>8)+col.r;
413             line[x].g = ((line[x].g*ainv)>>8)+col.g;
414             line[x].b = ((line[x].b*ainv)>>8)+col.b;
415             line[x].a = 255;
416         }
417         bit <<= 1;
418         if(!bit) {
419             bit = 1;bitpos++;
420         }
421     } while(++x<x2);
422 }
423
424 static void fill_line_clip(RGBA*line, U32*z, int y, int x1, int x2)
425 {
426     int x = x1;
427
428     U32 bit = 1<<(x1&31);
429     int bitpos = (x1/32);
430
431     do {
432         z[bitpos]|=bit;
433         bit <<= 1;
434         if(!bit) {
435             bit = 1;bitpos++;
436         }
437     } while(++x<x2);
438 }
439
440 void fill_line(gfxdevice_t*dev, RGBA*line, U32*zline, int y, int startx, int endx, fillinfo_t*fill)
441 {
442     if(fill->type == filltype_solid)
443         fill_line_solid(line, zline, y, startx, endx, *fill->color);
444     else if(fill->type == filltype_clip)
445         fill_line_clip(line, zline, y, startx, endx);
446     else if(fill->type == filltype_bitmap)
447         fill_line_bitmap(line, zline, y, startx, endx, fill);
448     else if(fill->type == filltype_gradient)
449         fill_line_gradient(line, zline, y, startx, endx, fill);
450 }
451
452 void fill(gfxdevice_t*dev, fillinfo_t*fill)
453 {
454     internal_t*i = (internal_t*)dev->internal;
455     int y;
456     U32 clipdepth = 0;
457     for(y=i->ymin;y<=i->ymax;y++) {
458         renderpoint_t*points = i->lines[y].points;
459         RGBA*line = &i->img[i->width2*y];
460         U32*zline = &i->clipbuf->data[i->bitwidth*y];
461
462         int n;
463         int num = i->lines[y].num;
464         int lastx;
465         qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
466
467         for(n=0;n<num;n++) {
468             renderpoint_t*p = &points[n];
469             renderpoint_t*next= n<num-1?&points[n+1]:0;
470             int startx = p->x;
471             int endx = next?next->x:i->width2;
472             if(endx > i->width2)
473                 endx = i->width2;
474             if(startx < 0)
475                 startx = 0;
476             if(endx < 0)
477                 endx = 0;
478
479             if(!(n&1))
480                 fill_line(dev, line, zline, y, startx, endx, fill);
481
482             lastx = endx;
483             if(endx == i->width2)
484                 break;
485         }
486         if(fill->type == filltype_clip) {
487             if(i->clipbuf->next) {
488                 U32*line2 = &i->clipbuf->next->data[i->bitwidth*y];
489                 int x;
490                 for(x=0;x<i->bitwidth;x++)
491                     zline[x] &= line2[x];
492             }
493         }
494
495         i->lines[y].num = 0;
496     }
497 }
498
499 void fill_solid(gfxdevice_t*dev, gfxcolor_t* color)
500 {
501     fillinfo_t info;
502     memset(&info, 0, sizeof(info));
503     info.type = filltype_solid;
504     info.color = color;
505     fill(dev, &info);
506 }
507
508 int render_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
509 {
510     internal_t*i = (internal_t*)dev->internal;
511     if(!strcmp(key, "antialize") || !strcmp(key, "antialise")) {
512         i->antialize = atoi(value);
513         i->zoom = i->antialize * i->multiply;
514         return 1;
515     } else if(!strcmp(key, "multiply")) {
516         i->multiply = atoi(value);
517         i->zoom = i->antialize * i->multiply;
518         fprintf(stderr, "Warning: multiply not implemented yet\n");
519         return 1;
520     } else if(!strcmp(key, "fillwhite")) {
521         i->fillwhite = atoi(value);
522         return 1;
523     } else if(!strcmp(key, "palette")) {
524         i->palette = atoi(value);
525         return 1;
526     }
527     return 0;
528 }
529
530 void newclip(struct _gfxdevice*dev)
531 {
532     internal_t*i = (internal_t*)dev->internal;
533     
534     clipbuffer_t*c = (clipbuffer_t*)rfx_calloc(sizeof(clipbuffer_t));
535     c->data = (U32*)rfx_calloc(sizeof(U32) * i->bitwidth * i->height2);
536     c->next = i->clipbuf;
537     i->clipbuf = c;
538     if(c->next)
539         memcpy(c->data, c->next->data, i->bitwidth*i->height2);
540     else
541         memset(c->data, 0, sizeof(U32)*i->bitwidth*i->height2);
542 }
543
544 void endclip(struct _gfxdevice*dev, char removelast)
545 {
546     internal_t*i = (internal_t*)dev->internal;
547    
548     /* test for at least one cliplevel (the one we created ourselves) */
549     if(!i->clipbuf || (!i->clipbuf->next && !removelast)) {
550         fprintf(stderr, "endclip without any active clip buffers\n");
551         return;
552     }
553
554     clipbuffer_t*c = i->clipbuf;
555     i->clipbuf = i->clipbuf->next;
556     c->next = 0;
557     free(c->data);c->data = 0;
558     free(c);
559 }
560
561 void render_stroke(struct _gfxdevice*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
562 {
563     internal_t*i = (internal_t*)dev->internal;
564     double x,y;
565     
566     /*if(cap_style != gfx_capRound || joint_style != gfx_joinRound) {
567         fprintf(stderr, "Warning: cap/joint style != round not yet supported\n");
568     }*/
569
570     while(line) {
571         if(line->type == gfx_moveTo) {
572         } else if(line->type == gfx_lineTo) {
573             double x1=x*i->zoom,y1=y*i->zoom;
574             double x3=line->x*i->zoom,y3=line->y*i->zoom;
575             add_solidline(dev, x1, y1, x3, y3, width * i->zoom);
576             fill_solid(dev, color);
577         } else if(line->type == gfx_splineTo) {
578             int t,parts;
579             double xx,yy;
580            
581             double x1=x*i->zoom,y1=y*i->zoom;
582             double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
583             double x3=line->x*i->zoom,y3=line->y*i->zoom;
584             
585             double c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
586             xx=x1;
587             yy=y1;
588
589             parts = (int)(sqrt(c)/3);
590             if(!parts) parts = 1;
591
592             for(t=1;t<=parts;t++) {
593                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
594                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
595                 
596                 add_solidline(dev, xx, yy, nx, ny, width * i->zoom);
597                 fill_solid(dev, color);
598                 xx = nx;
599                 yy = ny;
600             }
601         }
602         x = line->x;
603         y = line->y;
604         line = line->next;
605     }
606 }
607
608 static void draw_line(gfxdevice_t*dev, gfxline_t*line)
609 {
610     internal_t*i = (internal_t*)dev->internal;
611     double x,y;
612
613     while(line)
614     {
615         int x1,y1,x2,y2,x3,y3;
616
617         if(line->type == gfx_moveTo) {
618         } else if(line->type == gfx_lineTo) {
619             double x1=x*i->zoom,y1=y*i->zoom;
620             double x3=line->x*i->zoom,y3=line->y*i->zoom;
621             
622             add_line(dev, x1, y1, x3, y3);
623         } else if(line->type == gfx_splineTo) {
624             int c,t,parts,qparts;
625             double xx,yy;
626             
627             double x1=x*i->zoom,y1=y*i->zoom;
628             double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
629             double x3=line->x*i->zoom,y3=line->y*i->zoom;
630             
631             c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
632             xx=x1;
633             yy=y1;
634
635             parts = (int)(sqrt(c));
636             if(!parts) parts = 1;
637
638             for(t=1;t<=parts;t++) {
639                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
640                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
641                 
642                 add_line(dev, xx, yy, nx, ny);
643                 xx = nx;
644                 yy = ny;
645             }
646         }
647         x = line->x;
648         y = line->y;
649         line = line->next;
650     }
651 }
652
653 void render_startclip(struct _gfxdevice*dev, gfxline_t*line)
654 {
655     internal_t*i = (internal_t*)dev->internal;
656     fillinfo_t info;
657     memset(&info, 0, sizeof(info));
658     newclip(dev);
659     info.type = filltype_clip;
660     draw_line(dev, line);
661     fill(dev, &info);
662 }
663
664 void render_endclip(struct _gfxdevice*dev)
665 {
666     internal_t*i = (internal_t*)dev->internal;
667     endclip(dev, 0);
668 }
669
670 void render_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
671 {
672     internal_t*i = (internal_t*)dev->internal;
673
674     draw_line(dev, line);
675     fill_solid(dev, color);
676 }
677
678 void render_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
679 {
680     internal_t*i = (internal_t*)dev->internal;
681
682     gfxmatrix_t m2 = *matrix;
683
684     draw_line(dev, line);
685
686     fillinfo_t info;
687     memset(&info, 0, sizeof(info));
688     info.type = filltype_bitmap;
689     info.image = img;
690     info.matrix = &m2;
691     info.cxform = cxform;
692
693     m2.m00 *= i->zoom; m2.m01 *= i->zoom; m2.tx *= i->zoom;
694     m2.m10 *= i->zoom; m2.m11 *= i->zoom; m2.ty *= i->zoom;
695
696     fill(dev, &info);
697 }
698
699 void render_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
700 {
701     internal_t*i = (internal_t*)dev->internal;
702     
703     gfxmatrix_t m2 = *matrix;
704
705     draw_line(dev, line);
706
707     RGBA g[256];
708     fillinfo_t info;
709     memset(&info, 0, sizeof(info));
710     info.type = filltype_gradient;
711     info.gradient = g;
712     info.matrix = &m2;
713
714     m2.m00 *= i->zoom; m2.m01 *= i->zoom; m2.tx *= i->zoom;
715     m2.m10 *= i->zoom; m2.m11 *= i->zoom; m2.ty *= i->zoom;
716
717     info.clip_or_radial = type == gfxgradient_radial;
718
719     int pos = 0;
720     gfxcolor_t color = {0,0,0,0};
721     pos=0;
722     while(gradient) {
723         int nextpos = gradient->pos*256;
724         int t;
725         if(nextpos>256) {
726             msg("<error> Invalid gradient- contains values > 1.0");
727             return;
728         }
729         
730         gfxcolor_t nextcolor = gradient->color;
731         if(nextpos!=pos) {
732             double p0 = 1.0;
733             double p1 = 0.0;
734             double step = 1.0/(nextpos-pos);
735             int t;
736             for(t=pos;t<nextpos;t++) {
737                 g[t].r = color.r*p0 + nextcolor.r*p1;
738                 g[t].g = color.g*p0 + nextcolor.g*p1;
739                 g[t].b = color.b*p0 + nextcolor.b*p1;
740                 g[t].a = color.a*p0 + nextcolor.a*p1;
741                 p0 -= step;
742                 p1 += step;
743             }
744         }
745         color=nextcolor;
746
747         pos = nextpos;
748         gradient = gradient->next;
749     }
750     if(pos!=256) {
751         msg("<error> Invalid gradient- doesn't end with 1.0");
752     }
753
754     fill(dev, &info);
755 }
756
757 void render_addfont(struct _gfxdevice*dev, gfxfont_t*font)
758 {
759 }
760
761 void render_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
762 {
763     internal_t*i = (internal_t*)dev->internal;
764     if(!font)
765         return;
766
767     /* align characters to whole pixels */
768     matrix->tx = (int)(matrix->tx * i->antialize) / i->antialize;
769     matrix->ty = (int)(matrix->ty * i->antialize) / i->antialize;
770
771     gfxglyph_t*glyph = &font->glyphs[glyphnr];
772     gfxline_t*line2 = gfxline_clone(glyph->line);
773     gfxline_transform(line2, matrix);
774     draw_line(dev, line2);
775     fill_solid(dev, color);
776     gfxline_free(line2);
777     
778     return;
779 }
780
781 void render_result_write(gfxresult_t*r, int filedesc)
782 {
783     internal_result_t*i= (internal_result_t*)r->internal;
784 }
785 int render_result_save(gfxresult_t*r, const char*filename)
786 {
787     internal_result_t*i= (internal_result_t*)r->internal;
788     if(!i) {
789         return 0; // no pages drawn
790     }
791     if(i->next) {
792         int nr=0;
793         char filenamebuf[256];
794         char*origname = strdup(filename);
795         int l = strlen(origname);
796         if(l>3 && strchr("gG",origname[l-1]) && strchr("nN",filename[l-2]) &&
797                 strchr("pP",origname[l-3]) && filename[l-4]=='.') {
798             origname[l-4] = 0;
799         }
800         while(i->next) {
801             sprintf(filenamebuf, "%s.%d.png", origname, nr);
802             if(!i->palette) {
803                 writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
804             } else {
805                 writePalettePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
806             }
807             nr++;
808         }
809         free(origname);
810     } else {
811         writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
812     }
813     return 1;
814 }
815 char*gfximage_asXPM(gfximage_t*img, int depth)
816 {
817     int d= 256/depth;
818     char*str = (char*)malloc(img->width*img->height*4 + 500 + 16*depth*depth*depth);
819     char*p = str;
820     p+= sprintf(p, "static char *noname[] = {\n\"%d %d 262144 3\",\n");
821     int r,g,b;
822     for(r=0;r<depth;r++)
823     for(g=0;g<depth;g++)
824     for(b=0;b<depth;b++) {
825         p += sprintf(p, "\"%c%c%c c #%02x%02x%02x\",\n", r+32,g+32,b+32, r*d,g*d,b*d);
826     }
827     int y;
828     for(y=0;y<img->height;y++)  {
829         p+=sprintf(p, "\"");
830         gfxcolor_t*col = &img->data[y*img->height];
831         int x;
832         for(x=0;x<img->width;x++) {
833             p+=sprintf(p, "%c%c%c", 32+(col->r/d), 32+(col->g/d), 32+(col->b/d));
834         }
835         p+=sprintf(p, "\",\n");
836     }
837     *p = 0;
838     return p;
839 }
840 void*render_result_get(gfxresult_t*r, const char*name)
841 {
842     internal_result_t*i= (internal_result_t*)r->internal;
843     if(!strncmp(name,"xpm",3)) {
844         int pagenr = atoi(&name[3]);
845         if(pagenr<0)
846             pagenr=0;
847         while(pagenr>0) {
848             i = i->next;
849             if(!i)
850                 return 0;
851             pagenr--;
852         }
853         return gfximage_asXPM(&i->img, 64);
854     } else if(!strncmp(name,"page",4)) {
855         int pagenr = atoi(&name[4]);
856         if(pagenr<0)
857             pagenr=0;
858         while(pagenr>0) {
859             i = i->next;
860             if(!i)
861                 return 0;
862             pagenr--;
863         }
864         return &i->img;
865     }
866     return 0;
867 }
868 void render_result_destroy(gfxresult_t*r)
869 {
870     internal_result_t*i= (internal_result_t*)r->internal;
871     r->internal = 0;
872     while(i) {
873         internal_result_t*next = i->next;
874         free(i->img.data);i->img.data = 0;
875
876         /* FIXME memleak
877            the following rfx_free causes a segfault on WIN32 machines,
878            if executed */
879         //rfx_free(i);
880
881         i = next;
882     }
883     rfx_free(r);
884 }
885
886 gfxresult_t* render_finish(struct _gfxdevice*dev)
887 {
888     internal_t*i = (internal_t*)dev->internal;
889     
890     gfxresult_t* res = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
891     
892     res->internal = i->results;i->results = 0;
893     res->write = render_result_write;
894     res->save = render_result_save;
895     res->get = render_result_get;
896     res->destroy = render_result_destroy;
897
898     free(dev->internal); dev->internal = 0; i = 0;
899
900     return res;
901 }
902
903 void render_startpage(struct _gfxdevice*dev, int width, int height)
904 {
905     internal_t*i = (internal_t*)dev->internal;
906     int y;
907
908     if(i->width2 || i->height2) {
909         fprintf(stderr, "Error: startpage() called twice (no endpage()?)\n");
910         exit(1);
911     }
912     
913     i->width = width*i->multiply;
914     i->height = height*i->multiply;
915     i->width2 = width*i->zoom;
916     i->height2 = height*i->zoom;
917     i->bitwidth = (i->width2+31)/32;
918
919     i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
920     for(y=0;y<i->height2;y++) {
921         memset(&i->lines[y], 0, sizeof(renderline_t));
922         i->lines[y].points = 0;
923         i->lines[y].num = 0;
924     }
925     i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
926     if(i->fillwhite) {
927         memset(i->img, 0xff, sizeof(RGBA)*i->width2*i->height2);
928     }
929
930     i->ymin = 0x7fffffff;
931     i->ymax = -0x80000000;
932
933
934     /* initialize initial clipping field, which doesn't clip anything yet */
935     newclip(dev);
936     memset(i->clipbuf->data, 255, sizeof(U32)*i->bitwidth*i->height2);
937 }
938
939 static void store_image(internal_t*i, internal_result_t*ir)
940 {
941     ir->img.data = (gfxcolor_t*)malloc(i->width*i->height*sizeof(gfxcolor_t));
942     ir->img.width = i->width;
943     ir->img.height = i->height;
944
945     gfxcolor_t*dest = ir->img.data;
946
947     if(i->antialize <= 1) /* no antializing */ {
948         int y;
949         for(y=0;y<i->height;y++) {
950             RGBA*line = &i->img[y*i->width];
951             memcpy(&dest[y*i->width], line, sizeof(RGBA)*i->width);
952         }
953     } else {
954         RGBA**lines = (RGBA**)rfx_calloc(sizeof(RGBA*)*i->antialize);
955         int q = i->antialize*i->antialize;
956         int ypos = 0;
957         int y;
958         int y2=0;
959         for(y=0;y<i->height2;y++) {
960             int n;
961             ypos = y % i->antialize;
962             lines[ypos] = &i->img[y*i->width2];
963             if(ypos == i->antialize-1) {
964                 RGBA*out = &dest[(y2++)*i->width];
965                 int x;
966                 int r,g,b,a;
967                 for(x=0;x<i->width;x++) {
968                     int xpos = x*i->antialize;
969                     int yp;
970                     U32 r=0,g=0,b=0,a=0;
971                     for(yp=0;yp<i->antialize;yp++) {
972                         RGBA*lp = &lines[yp][xpos];
973                         int xp;
974                         for(xp=0;xp<i->antialize;xp++) {
975                             RGBA*p = &lp[xp];
976                             r += p->r;
977                             g += p->g;
978                             b += p->b;
979                             a += p->a;
980                         }
981                     }
982                     out[x].r = r / q;
983                     out[x].g = g / q;
984                     out[x].b = b / q;
985                     out[x].a = a / q;
986                 }
987             }
988         }
989         rfx_free(lines);
990     }
991 }
992
993 void render_endpage(struct _gfxdevice*dev)
994 {
995     internal_t*i = (internal_t*)dev->internal;
996     
997     if(!i->width2 || !i->height2) {
998         fprintf(stderr, "Error: endpage() called without corresponding startpage()\n");
999         exit(1);
1000     }
1001
1002     endclip(dev, 1);
1003     int unclosed = 0;
1004     while(i->clipbuf) {
1005         endclip(dev, 1);
1006         unclosed++;
1007     }
1008
1009     if(unclosed) {
1010         fprintf(stderr, "Warning: %d unclosed clip(s) while processing endpage()\n", unclosed);
1011     }
1012     
1013     internal_result_t*ir= (internal_result_t*)rfx_calloc(sizeof(internal_result_t));
1014     ir->palette = i->palette;
1015
1016     int y,x;
1017
1018     store_image(i, ir);
1019
1020     ir->next = 0;
1021     if(i->result_next) {
1022         i->result_next->next = ir;
1023     }
1024     if(!i->results) {
1025         i->results = ir;
1026     }
1027     i->result_next = ir;
1028
1029     for(y=0;y<i->height2;y++) {
1030         rfx_free(i->lines[y].points); i->lines[y].points = 0;
1031     }
1032     rfx_free(i->lines);i->lines=0;
1033
1034     if(i->img) {rfx_free(i->img);i->img = 0;}
1035
1036     i->width2 = 0;
1037     i->height2 = 0;
1038 }
1039
1040 void render_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
1041 {
1042     /* not supported for this output device */
1043 }
1044
1045 void gfxdevice_render_init(gfxdevice_t*dev)
1046 {
1047     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
1048     memset(dev, 0, sizeof(gfxdevice_t));
1049     
1050     dev->name = "render";
1051
1052     dev->internal = i;
1053     
1054     i->width = 0;
1055     i->width2 = 0;
1056     i->height = 0;
1057     i->height2 = 0;
1058     i->antialize = 1;
1059     i->multiply = 1;
1060     i->zoom = 1;
1061
1062     dev->setparameter = render_setparameter;
1063     dev->startpage = render_startpage;
1064     dev->startclip = render_startclip;
1065     dev->endclip = render_endclip;
1066     dev->stroke = render_stroke;
1067     dev->fill = render_fill;
1068     dev->fillbitmap = render_fillbitmap;
1069     dev->fillgradient = render_fillgradient;
1070     dev->addfont = render_addfont;
1071     dev->drawchar = render_drawchar;
1072     dev->drawlink = render_drawlink;
1073     dev->endpage = render_endpage;
1074     dev->finish = render_finish;
1075 }
1076
1077
1078 gfxdevice_t* gfxdevice_render_new()
1079 {
1080     gfxdevice_t* d = (gfxdevice_t*)malloc(sizeof(gfxdevice_t));
1081     gfxdevice_render_init(d);
1082     return d;
1083 }