c73b2676917987f7ce01144aa224f85214021ee7
[swftools.git] / lib / devices / render.c
1 /* gfxdevice_bitmap.cc
2
3    Part of the swftools package.
4
5    Copyright (c) 2005 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 "../png.h"
28 #include "../mem.h"
29
30 typedef unsigned int U32;
31 typedef unsigned char U8;
32
33 typedef gfxcolor_t RGBA;
34
35 typedef struct _renderpoint
36 {
37     float x;
38 } renderpoint_t;
39
40 typedef struct _renderline
41 {
42     renderpoint_t*points;
43     int size;
44     int num;
45 } renderline_t;
46
47 typedef struct _internal_result {
48     int width;
49     int height;
50     RGBA* img;
51     struct _internal_result*next;
52 } internal_result_t;
53
54 typedef struct _clipbuffer {
55     U32*data;
56     int linesize;
57     struct _clipbuffer*prev;
58 } clipbuffer_t;
59
60 typedef struct _internal {
61     int width;
62     int height;
63     int width2;
64     int height2;
65     int multiply;
66     int antialize;
67     int ymin, ymax;
68
69     int depth;
70
71     RGBA* img;
72     int* zbuf; 
73
74     gfxfont_t*font;
75     char*fontid;
76     
77     clipbuffer_t*clipbufs;
78     clipbuffer_t*clipbuf;
79
80     renderline_t*lines;
81
82     internal_result_t*results;
83     internal_result_t*result_next;
84 } internal_t;
85
86 typedef enum {filltype_solid,filltype_clip,filltype_bitmap} filltype_t;
87
88 typedef struct _fillinfo {
89     filltype_t type; //0=solid,1=clip
90     gfxcolor_t*color;
91     gfximage_t*image;
92     gfxmatrix_t*matrix;
93     gfxcxform_t*cxform;
94     char clip;
95 } fillinfo_t;
96
97
98 static inline void add_pixel(internal_t*i, float x, int y)
99 {
100     renderpoint_t p;
101
102     if(x >= i->width2 || y >= i->height2 || y<0) return;
103     p.x = x;
104     if(y<i->ymin) i->ymin = y;
105     if(y>i->ymax) i->ymax = y;
106
107     renderline_t*l = &i->lines[y];
108
109     if(l->num == l->size) {
110         l->size += 32;
111         l->points = (renderpoint_t*)rfx_realloc(l->points, l->size * sizeof(renderpoint_t));
112     }
113     l->points[l->num] = p;
114     l->num++;
115 }
116
117 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
118    problem appears to often */
119 #define CUT 0.5
120
121 #define INT(x) ((int)((x)+16)-16)
122
123 static void add_line(gfxdevice_t*dev , double x1, double y1, double x2, double y2)
124 {
125     internal_t*i = (internal_t*)dev->internal;
126     double diffx, diffy;
127     double ny1, ny2, stepx;
128 /*    if(DEBUG&4) {
129         int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
130         printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
131     }*/
132
133     if(y2 < y1) {
134         double x;
135         double y;
136         x = x1;x1 = x2;x2=x;
137         y = y1;y1 = y2;y2=y;
138     }
139     
140     diffx = x2 - x1;
141     diffy = y2 - y1;
142     
143     ny1 = INT(y1)+CUT;
144     ny2 = INT(y2)+CUT;
145
146     if(ny1 < y1) {
147         ny1 = INT(y1) + 1.0 + CUT;
148     }
149     if(ny2 >= y2) {
150         ny2 = INT(y2) - 1.0 + CUT;
151     }
152
153     if(ny1 > ny2)
154         return;
155
156     stepx = diffx/diffy;
157     x1 = x1 + (ny1-y1)*stepx;
158     x2 = x2 + (ny2-y2)*stepx;
159
160     {
161         int posy=INT(ny1);
162         int endy=INT(ny2);
163         double posx=0;
164         double startx = x1;
165
166         while(posy<=endy) {
167             float xx = (float)(startx + posx);
168             add_pixel(i, xx ,posy);
169             posx+=stepx;
170             posy++;
171         }
172     }
173 }
174 #define PI 3.14159265358979
175 static void add_solidline(gfxdevice_t*dev, double x1, double y1, double x2, double y2, double width)
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         col.a = 255;
282         do {
283             if(z[bitpos]&bit) {
284                 line[x].r = ((line[x].r*ainv)>>8)+col.r;
285                 line[x].g = ((line[x].g*ainv)>>8)+col.g;
286                 line[x].b = ((line[x].b*ainv)>>8)+col.b;
287                 line[x].a = 255;
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     double det = m->m00*m->m11 - m->m01*m->m10;
315     if(fabs(det) < 0.0005) { 
316         /* x direction equals y direction- the image is invisible */
317         return;
318     }
319     det = 1.0/det;
320     
321     if(!b->width || !b->height) {
322         gfxcolor_t red = {255,255,0,0};
323         fill_line_solid(line, z, y, x1, x2, red);
324         return;
325     }
326
327     U32 bit = 1<<(x1&31);
328     int bitpos = (x1/32);
329
330     do {
331         if(z[bitpos]&bit) {
332             RGBA col;
333             int xx = (int)((  (x - m->tx) * m->m11 - (y - m->ty) * m->m10)*det);
334             int yy = (int)((- (x - m->tx) * m->m01 + (y - m->ty) * m->m00)*det);
335             int ainv;
336
337             if(info->clip) {
338                 if(xx<0) xx=0;
339                 if(xx>=b->width) xx = b->width-1;
340                 if(yy<0) yy=0;
341                 if(yy>=b->height) yy = b->height-1;
342             } else {
343                 xx %= b->width;
344                 yy %= b->height;
345                 if(xx<0) xx += b->width;
346                 if(yy<0) yy += b->height;
347             }
348
349             col = b->data[yy*b->width+xx];
350             ainv = 255-col.a;
351
352             line[x].r = ((line[x].r*ainv)>>8)+col.r;
353             line[x].g = ((line[x].g*ainv)>>8)+col.g;
354             line[x].b = ((line[x].b*ainv)>>8)+col.b;
355             line[x].a = 255;
356         }
357         bit <<= 1;
358         if(!bit) {
359             bit = 1;bitpos++;
360         }
361     } while(++x<x2);
362 }
363
364 static void fill_line_clip(RGBA*line, U32*z, int y, int x1, int x2)
365 {
366     int x = x1;
367
368     U32 bit = 1<<(x1&31);
369     int bitpos = (x1/32);
370
371     do {
372         z[bitpos]|=bit;
373         bit <<= 1;
374         if(!bit) {
375             bit = 1;bitpos++;
376         }
377     } while(++x<x2);
378 }
379
380 void fill_line(gfxdevice_t*dev, RGBA*line, U32*zline, int y, int startx, int endx, fillinfo_t*fill)
381 {
382     if(fill->type == filltype_solid)
383         fill_line_solid(line, zline, y, startx, endx, *fill->color);
384     else if(fill->type == filltype_clip)
385         fill_line_clip(line, zline, y, startx, endx);
386     else if(fill->type == filltype_bitmap)
387         fill_line_bitmap(line, zline, y, startx, endx, fill);
388     // etc.
389 }
390
391 void fill(gfxdevice_t*dev, fillinfo_t*fill)
392 {
393     internal_t*i = (internal_t*)dev->internal;
394     int y;
395     U32 clipdepth = 0;
396     for(y=i->ymin;y<=i->ymax;y++) {
397         renderpoint_t*points = i->lines[y].points;
398         RGBA*line = &i->img[i->width2*y];
399         int*zline = &i->zbuf[i->width2*y];
400         int n;
401         int num = i->lines[y].num;
402         int lastx;
403         qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
404
405         for(n=0;n<num;n++) {
406             renderpoint_t*p = &points[n];
407             renderpoint_t*next= n<num-1?&points[n+1]:0;
408             int startx = p->x;
409             int endx = next?next->x:i->width2;
410             if(endx > i->width2)
411                 endx = i->width2;
412             if(startx < 0)
413                 startx = 0;
414             if(endx < 0)
415                 endx = 0;
416
417             if(!(n&1))
418                 fill_line(dev, line, zline, y, startx, endx, fill);
419
420             lastx = endx;
421             if(endx == i->width2)
422                 break;
423         }
424         i->lines[y].num = 0;
425     }
426 }
427
428 void fill_solid(gfxdevice_t*dev, gfxcolor_t* color)
429 {
430     fillinfo_t info;
431     info.type = filltype_solid;
432     info.color = color;
433     fill(dev, &info);
434 }
435
436 int render_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
437 {
438     internal_t*i = (internal_t*)dev->internal;
439     if(!strcmp(key, "antialize")) {
440         i->antialize = atoi(value);
441     } else if(!strcmp(key, "multiply")) {
442         i->multiply = atoi(value);
443     }
444     return 0;
445 }
446
447 void newclip(struct _gfxdevice*dev)
448 {
449     internal_t*i = (internal_t*)dev->internal;
450     
451     clipbuffer_t*c = rfx_calloc(sizeof(clipbuffer_t));
452     c->linesize = ((i->width2+31) / 32);
453     c->data = rfx_calloc(c->linesize * i->height2);
454
455     if(!i->clipbufs) {
456         i->clipbufs = i->clipbuf = c;
457     } else {
458         clipbuffer_t*old = i->clipbuf;
459         i->clipbuf = c;
460         i->clipbuf->prev = old;
461     }
462 }
463
464 void endclip(struct _gfxdevice*dev)
465 {
466     internal_t*i = (internal_t*)dev->internal;
467     
468     if(!i->clipbufs) {
469         fprintf(stderr, "endclip without any active clip buffers");
470         return;
471     }
472     
473     clipbuffer_t*old = i->clipbuf;
474
475     if(i->clipbuf == i->clipbufs)
476         i->clipbufs = 0;
477
478     i->clipbuf = i->clipbuf->prev;
479
480     old->prev = 0;
481     free(old->data);old->data = 0;
482     free(old);
483 }
484
485 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)
486 {
487     internal_t*i = (internal_t*)dev->internal;
488     double x,y;
489     
490     if(cap_style != gfx_capRound || joint_style != gfx_joinRound) {
491         fprintf(stderr, "Warning: cap/joint style != round not yet supported\n");
492     }
493
494     while(line) {
495         int x1,y1,x2,y2,x3,y3;
496
497         if(line->type == gfx_moveTo) {
498         } else if(line->type == gfx_lineTo) {
499             double x1=x,y1=y;
500             double x3=line->x,y3=line->y;
501             add_solidline(dev, x1, y1, x3, y3, width * i->multiply);
502             fill_solid(dev, color);
503         } else if(line->type == gfx_splineTo) {
504             int c,t,parts,qparts;
505             double xx,yy;
506            
507             double x1=x,y1=y;
508             double x2=line->sx,y2=line->sy;
509             double x3=line->x,y3=line->y;
510             
511             c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
512             xx=x1;
513             yy=y1;
514
515             parts = (int)(sqrt(c)/3);
516             if(!parts) parts = 1;
517
518             for(t=1;t<=parts;t++) {
519                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
520                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
521                 
522                 add_solidline(dev, xx, yy, nx, ny, width * i->multiply);
523                 fill_solid(dev, color);
524                 xx = nx;
525                 yy = ny;
526             }
527         }
528         x = line->x;
529         y = line->y;
530         line = line->next;
531     }
532 }
533
534 static void draw_line(gfxdevice_t*dev, gfxline_t*line)
535 {
536     internal_t*i = (internal_t*)dev->internal;
537     double x,y;
538
539     while(line)
540     {
541         int x1,y1,x2,y2,x3,y3;
542
543         if(line->type == gfx_moveTo) {
544         } else if(line->type == gfx_lineTo) {
545             double x1=x,y1=y;
546             double x3=line->x,y3=line->y;
547             
548             add_line(dev, x1, y1, x3, y3);
549         } else if(line->type == gfx_splineTo) {
550             int c,t,parts,qparts;
551             double xx,yy;
552             
553             double x1=x,y1=y;
554             double x2=line->sx,y2=line->sy;
555             double x3=line->x,y3=line->y;
556             
557             c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
558             xx=x1;
559             yy=y1;
560
561             parts = (int)(sqrt(c)/3);
562             if(!parts) parts = 1;
563
564             for(t=1;t<=parts;t++) {
565                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
566                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
567                 
568                 add_line(dev, xx, yy, nx, ny);
569                 xx = nx;
570                 yy = ny;
571             }
572         }
573         x = line->x;
574         y = line->y;
575         line = line->next;
576     }
577 }
578
579 void render_startclip(struct _gfxdevice*dev, gfxline_t*line)
580 {
581     internal_t*i = (internal_t*)dev->internal;
582     fillinfo_t info;
583     newclip(dev);
584     info.type = filltype_clip;
585     draw_line(dev, line);
586     fill(dev, &info);
587 }
588
589 void render_endclip(struct _gfxdevice*dev)
590 {
591     internal_t*i = (internal_t*)dev->internal;
592     endclip(dev);
593 }
594
595 void render_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
596 {
597     internal_t*i = (internal_t*)dev->internal;
598
599     draw_line(dev, line);
600     fill_solid(dev, color);
601 }
602
603 void render_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
604 {
605     internal_t*i = (internal_t*)dev->internal;
606
607     gfxcolor_t black = {255,0,0,0};
608
609     draw_line(dev, line);
610
611     fillinfo_t info;
612     info.type = filltype_bitmap;
613     info.image = img;
614     info.matrix = matrix;
615     info.cxform = cxform;
616     fill(dev, &info);
617 }
618
619 void render_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
620 {
621     internal_t*i = (internal_t*)dev->internal;
622     
623     gfxcolor_t black = {255,0,0,0};
624
625     draw_line(dev, line);
626     fill_solid(dev, &black);
627 }
628
629 void render_addfont(struct _gfxdevice*dev, gfxfont_t*font)
630 {
631 }
632
633 void render_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
634 {
635     internal_t*i = (internal_t*)dev->internal;
636
637     gfxglyph_t*glyph = &font->glyphs[glyphnr];
638     gfxline_t*line2 = gfxline_clone(glyph->line);
639     gfxline_transform(line2, matrix);
640     draw_line(dev, line2);
641     fill_solid(dev, color);
642     gfxline_free(line2);
643     
644     return;
645 }
646
647 void render_result_write(gfxresult_t*r, int filedesc)
648 {
649     internal_result_t*i= (internal_result_t*)r->internal;
650 }
651 int  render_result_save(gfxresult_t*r, char*filename)
652 {
653     internal_result_t*i= (internal_result_t*)r->internal;
654     if(i->next) {
655         int nr=0;
656         while(i->next) {
657             writePNG(filename, (unsigned char*)i->img, i->width, i->height);
658             nr++;
659         }
660     } else {
661         writePNG(filename, (unsigned char*)i->img, i->width, i->height);
662     }
663     return 1;
664 }
665 void*render_result_get(gfxresult_t*r, char*name)
666 {
667     internal_result_t*i= (internal_result_t*)r->internal;
668     return 0;
669 }
670 void render_result_destroy(gfxresult_t*r)
671 {
672     internal_result_t*i= (internal_result_t*)r->internal;
673     free(i); r->internal = 0;
674     free(r);
675 }
676
677 gfxresult_t* render_finish(struct _gfxdevice*dev)
678 {
679     internal_t*i = (internal_t*)dev->internal;
680     
681     gfxresult_t* res = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
682     
683     res->internal = i->results;i->results = 0;
684     res->write = render_result_write;
685     res->save = render_result_save;
686     res->get = render_result_get;
687     res->destroy = render_result_destroy;
688
689     free(dev->internal); dev->internal = 0; i = 0;
690
691     /* TODO: free fonts */
692
693     return res;
694 }
695
696 void render_startpage(struct _gfxdevice*dev, int width, int height)
697 {
698     internal_t*i = (internal_t*)dev->internal;
699     int y;
700
701     if(i->width2 || i->height2) {
702         fprintf(stderr, "Error: startpage() called twice (no endpage()?)\n");
703         exit(1);
704     }
705     
706     i->width = width;
707     i->height = height;
708     i->width2 = width*i->antialize*i->multiply;
709     i->height2 = height*i->antialize*i->multiply;
710
711     i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
712     for(y=0;y<i->height2;y++) {
713         memset(&i->lines[y], 0, sizeof(renderline_t));
714         i->lines[y].points = 0;
715         i->lines[y].num = 0;
716     }
717     i->zbuf = (int*)rfx_calloc(sizeof(int)*i->width2*i->height2);
718     i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
719     i->ymin = 0x7fffffff;
720     i->ymax = -0x80000000;
721
722     newclip(dev);
723 }
724
725 void render_endpage(struct _gfxdevice*dev)
726 {
727     internal_t*i = (internal_t*)dev->internal;
728     
729     if(!i->width2 || !i->height2) {
730         fprintf(stderr, "Error: endpage() called without corresponding startpage()\n");
731         exit(1);
732     }
733
734     endclip(dev);
735     while(i->clipbufs) {
736         fprintf(stderr, "Warning: unclosed clip while processing endpage()\n");
737         endclip(dev);
738     }
739     
740     internal_result_t*ir= (internal_result_t*)rfx_calloc(sizeof(internal_result_t));
741     ir->width = i->width;
742     ir->height = i->height;
743     ir->img = i->img; i->img = 0;
744     ir->next = 0;
745     if(i->result_next) {
746         i->result_next->next = ir;
747     }
748     if(!i->results) {
749         i->results = ir;
750     }
751     i->result_next = ir;
752
753     rfx_free(i->lines);i->lines=0; //FIXME
754     rfx_free(i->zbuf);i->zbuf = 0;
755     if(i->img) {rfx_free(i->img);i->img = 0;}
756
757     i->width2 = 0;
758     i->height2 = 0;
759 }
760
761 void render_drawlink(struct _gfxdevice*dev, gfxline_t*line, char*action)
762 {
763     /* not supported for this output device */
764 }
765
766 void gfxdevice_render_init(gfxdevice_t*dev)
767 {
768     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
769     int y;
770     memset(dev, 0, sizeof(gfxdevice_t));
771     dev->internal = i;
772     
773     i->width = 0;
774     i->width2 = 0;
775     i->height = 0;
776     i->height2 = 0;
777     i->antialize = 1;
778     i->multiply = 1;
779
780     dev->setparameter = render_setparameter;
781     dev->startpage = render_startpage;
782     dev->startclip = render_startclip;
783     dev->endclip = render_endclip;
784     dev->stroke = render_stroke;
785     dev->fill = render_fill;
786     dev->fillbitmap = render_fillbitmap;
787     dev->fillgradient = render_fillgradient;
788     dev->addfont = render_addfont;
789     dev->drawchar = render_drawchar;
790     dev->drawlink = render_drawlink;
791     dev->endpage = render_endpage;
792     dev->finish = render_finish;
793 }
794