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 "render.h"
  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     gfximage_t img;
  49     struct _internal_result*next;
  50 } internal_result_t;
  51
  52 typedef struct _clipbuffer {
  53     U32*data;
  54     struct _clipbuffer*next;
  55 } clipbuffer_t;
  56
  57 typedef struct _internal {
  58     int width;
  59     int height;
  60     int width2;
  61     int height2;
  62     int bitwidth;
  63     int multiply;
  64     int antialize;
  65     int zoom;
  66     int ymin, ymax;
  67     int fillwhite;
  68
  69     RGBA* img;
  70
  71     clipbuffer_t*clipbuf;
  72
  73     renderline_t*lines;
  74
  75     internal_result_t*results;
  76     internal_result_t*result_next;
  77 } internal_t;
  78
  79 typedef enum {filltype_solid,filltype_clip,filltype_bitmap} filltype_t;
  80
  81 typedef struct _fillinfo {
  82     filltype_t type; //0=solid,1=clip
  83     gfxcolor_t*color;
  84     gfximage_t*image;
  85     gfxmatrix_t*matrix;
  86     gfxcxform_t*cxform;
  87     char clip;
  88 } fillinfo_t;
  89
  90
  91 static inline void add_pixel(internal_t*i, float x, int y)
  92 {
  93     renderpoint_t p;
  94
  95     if(x >= i->width2 || y >= i->height2 || y<0) return;
  96     p.x = x;
  97     if(y<i->ymin) i->ymin = y;
  98     if(y>i->ymax) i->ymax = y;
  99
 100     renderline_t*l = &i->lines[y];
 101
 102     if(l->num == l->size) {
 103         l->size += 32;
 104         l->points = (renderpoint_t*)rfx_realloc(l->points, l->size * sizeof(renderpoint_t));
 105     }
 106     l->points[l->num] = p;
 107     l->num++;
 108 }
 109
 110 /* set this to 0.777777 or something if the "both fillstyles set while not inside shape"
 111    problem appears to often */
 112 #define CUT 0.5
 113
 114 #define INT(x) ((int)((x)+16)-16)
 115
 116 static void add_line(gfxdevice_t*dev , double x1, double y1, double x2, double y2)
 117 {
 118     internal_t*i = (internal_t*)dev->internal;
 119     double diffx, diffy;
 120     double ny1, ny2, stepx;
 121 /*    if(DEBUG&4) {
 122         int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
 123         printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]\n", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
 124     }*/
 125
 126     if(y2 < y1) {
 127         double x;
 128         double y;
 129         x = x1;x1 = x2;x2=x;
 130         y = y1;y1 = y2;y2=y;
 131     }
 132
 133     diffx = x2 - x1;
 134     diffy = y2 - y1;
 135
 136     ny1 = INT(y1)+CUT;
 137     ny2 = INT(y2)+CUT;
 138
 139     if(ny1 < y1) {
 140         ny1 = INT(y1) + 1.0 + CUT;
 141     }
 142     if(ny2 >= y2) {
 143         ny2 = INT(y2) - 1.0 + CUT;
 144     }
 145
 146     if(ny1 > ny2)
 147         return;
 148
 149     stepx = diffx/diffy;
 150     x1 = x1 + (ny1-y1)*stepx;
 151     x2 = x2 + (ny2-y2)*stepx;
 152
 153     {
 154         int posy=INT(ny1);
 155         int endy=INT(ny2);
 156         double posx=0;
 157         double startx = x1;
 158
 159         while(posy<=endy) {
 160             float xx = (float)(startx + posx);
 161             add_pixel(i, xx ,posy);
 162             posx+=stepx;
 163             posy++;
 164         }
 165     }
 166 }
 167 #define PI 3.14159265358979
 168 static void add_solidline(gfxdevice_t*dev, double x1, double y1, double x2, double y2, double width)
 169 {
 170     /* TODO: handle cap styles */
 171
 172     internal_t*i = (internal_t*)dev->internal;
 173
 174     double dx = x2-x1;
 175     double dy = y2-y1;
 176     double sd;
 177     double d;
 178
 179     int t;
 180     int segments;
 181     double lastx,lasty;
 182     double vx,vy;
 183     double xx,yy;
 184
 185     /* Make sure the line is always at least one pixel wide */
 186 #ifdef LINEMODE1
 187     /* That's what Macromedia's Player does at least at zoom level >= 1.  */
 188     width += 1.0;
 189 #else
 190     /* That's what Macromedia's Player seems to do at zoom level 0.  */
 191     /* TODO: needs testing */
 192
 193     /* TODO: how does this interact with scaling? */
 194     if(width * i->multiply < 1.0)
 195         width = 1.0 / i->multiply;
 196 #endif
 197
 198     sd = (double)dx*(double)dx+(double)dy*(double)dy;
 199     d = sqrt(sd);
 200
 201     if(!dx && !dy) {
 202         vx = 1;
 203         vy = 0;
 204     } else {
 205         vx = ( dy/d);
 206         vy = (-dx/d);
 207     }
 208
 209     segments = width/2;
 210     if(segments < 2)
 211         segments = 2;
 212
 213     segments = 8;
 214
 215     vx=vx*width*0.5;
 216     vy=vy*width*0.5;
 217
 218     xx = x2+vx;
 219     yy = y2+vy;
 220     add_line(dev, x1+vx, y1+vy, xx, yy);
 221     lastx = xx;
 222     lasty = yy;
 223     for(t=1;t<segments;t++) {
 224         double s = sin(t*PI/segments);
 225         double c = cos(t*PI/segments);
 226         xx = (x2 + vx*c - vy*s);
 227         yy = (y2 + vx*s + vy*c);
 228         add_line(dev, lastx, lasty, xx, yy);
 229         lastx = xx;
 230         lasty = yy;
 231     }
 232
 233     xx = (x2-vx);
 234     yy = (y2-vy);
 235     add_line(dev, lastx, lasty, xx, yy);
 236     lastx = xx;
 237     lasty = yy;
 238     xx = (x1-vx);
 239     yy = (y1-vy);
 240     add_line(dev, lastx, lasty, xx, yy);
 241     lastx = xx;
 242     lasty = yy;
 243     for(t=1;t<segments;t++) {
 244         double s = sin(t*PI/segments);
 245         double c = cos(t*PI/segments);
 246         xx = (x1 - vx*c + vy*s);
 247         yy = (y1 - vx*s - vy*c);
 248         add_line(dev, lastx, lasty, xx, yy);
 249         lastx = xx;
 250         lasty = yy;
 251     }
 252     add_line(dev, lastx, lasty, (x1+vx), (y1+vy));
 253 }
 254
 255 static int compare_renderpoints(const void * _a, const void * _b)
 256 {
 257     renderpoint_t*a = (renderpoint_t*)_a;
 258     renderpoint_t*b = (renderpoint_t*)_b;
 259     if(a->x < b->x) return -1;
 260     if(a->x > b->x) return 1;
 261     return 0;
 262 }
 263
 264 static void fill_line_solid(RGBA*line, U32*z, int y, int x1, int x2, RGBA col)
 265 {
 266     int x = x1;
 267
 268     U32 bit = 1<<(x1&31);
 269     int bitpos = (x1/32);
 270
 271     if(col.a!=255) {
 272         int ainv = 255-col.a;
 273         col.r = (col.r*col.a)>>8;
 274         col.g = (col.g*col.a)>>8;
 275         col.b = (col.b*col.a)>>8;
 276         do {
 277             if(z[bitpos]&bit) {
 278                 line[x].r = ((line[x].r*ainv)>>8)+col.r;
 279                 line[x].g = ((line[x].g*ainv)>>8)+col.g;
 280                 line[x].b = ((line[x].b*ainv)>>8)+col.b;
 281                 //line[x].a = 255;
 282                 line[x].a = ((line[x].a*ainv)>>8)+col.a;
 283             }
 284             bit <<= 1;
 285             if(!bit) {
 286                 bit = 1;bitpos++;
 287             }
 288         } while(++x<x2);
 289     } else {
 290         do {
 291             if(z[bitpos]&bit) {
 292                 line[x] = col;
 293             }
 294             bit <<= 1;
 295             if(!bit) {
 296                 bit = 1;bitpos++;
 297             }
 298         } while(++x<x2);
 299     }
 300 }
 301
 302 static void fill_line_bitmap(RGBA*line, U32*z, int y, int x1, int x2, fillinfo_t*info)
 303 {
 304     int x = x1;
 305
 306     gfxmatrix_t*m = info->matrix;
 307     gfximage_t*b = info->image;
 308
 309     if(!b->width || !b->height) {
 310         gfxcolor_t red = {255,255,0,0};
 311         fill_line_solid(line, z, y, x1, x2, red);
 312         return;
 313     }
 314
 315     double det = m->m00*m->m11 - m->m01*m->m10;
 316     if(fabs(det) < 0.0005) {
 317         /* x direction equals y direction- the image is invisible */
 318         return;
 319     }
 320     det = 1.0/det;
 321     double xx1 =  (  (-m->tx) * m->m11 - (y - m->ty) * m->m10) * det;
 322     double yy1 =  (- (-m->tx) * m->m01 + (y - m->ty) * m->m00) * det;
 323     double xinc1 = m->m11 * det;
 324     double yinc1 = m->m01 * det;
 325
 326     U32 bit = 1<<(x1&31);
 327     int bitpos = (x1/32);
 328
 329     do {
 330         if(z[bitpos]&bit) {
 331             RGBA col;
 332             int xx = (int)(xx1 + x * xinc1);
 333             int yy = (int)(yy1 - x * yinc1);
 334             int ainv;
 335
 336             if(info->clip) {
 337                 if(xx<0) xx=0;
 338                 if(xx>=b->width) xx = b->width-1;
 339                 if(yy<0) yy=0;
 340                 if(yy>=b->height) yy = b->height-1;
 341             } else {
 342                 xx %= b->width;
 343                 yy %= b->height;
 344                 if(xx<0) xx += b->width;
 345                 if(yy<0) yy += b->height;
 346             }
 347
 348             col = b->data[yy*b->width+xx];
 349             ainv = 255-col.a;
 350
 351             /* needs bitmap with premultiplied alpha */
 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         U32*zline = &i->clipbuf->data[i->bitwidth*y];
 400
 401         int n;
 402         int num = i->lines[y].num;
 403         int lastx;
 404         qsort(points, num, sizeof(renderpoint_t), compare_renderpoints);
 405
 406         for(n=0;n<num;n++) {
 407             renderpoint_t*p = &points[n];
 408             renderpoint_t*next= n<num-1?&points[n+1]:0;
 409             int startx = p->x;
 410             int endx = next?next->x:i->width2;
 411             if(endx > i->width2)
 412                 endx = i->width2;
 413             if(startx < 0)
 414                 startx = 0;
 415             if(endx < 0)
 416                 endx = 0;
 417
 418             if(!(n&1))
 419                 fill_line(dev, line, zline, y, startx, endx, fill);
 420
 421             lastx = endx;
 422             if(endx == i->width2)
 423                 break;
 424         }
 425         if(fill->type == filltype_clip) {
 426             if(i->clipbuf->next) {
 427                 U32*line2 = &i->clipbuf->next->data[i->bitwidth*y];
 428                 int x;
 429                 for(x=0;x<i->bitwidth;x++)
 430                     zline[x] &= line2[x];
 431             }
 432         }
 433
 434         i->lines[y].num = 0;
 435     }
 436 }
 437
 438 void fill_solid(gfxdevice_t*dev, gfxcolor_t* color)
 439 {
 440     fillinfo_t info;
 441     info.type = filltype_solid;
 442     info.color = color;
 443     fill(dev, &info);
 444 }
 445
 446 int render_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
 447 {
 448     internal_t*i = (internal_t*)dev->internal;
 449     if(!strcmp(key, "antialize") || !strcmp(key, "antialise")) {
 450         i->antialize = atoi(value);
 451         i->zoom = i->antialize * i->multiply;
 452         return 1;
 453     } else if(!strcmp(key, "multiply")) {
 454         i->multiply = atoi(value);
 455         i->zoom = i->antialize * i->multiply;
 456         fprintf(stderr, "Warning: multiply not implemented yet\n");
 457         return 1;
 458     } else if(!strcmp(key, "fillwhite")) {
 459         i->fillwhite = atoi(value);
 460         return 1;
 461     }
 462     return 0;
 463 }
 464
 465 void newclip(struct _gfxdevice*dev)
 466 {
 467     internal_t*i = (internal_t*)dev->internal;
 468
 469     clipbuffer_t*c = (clipbuffer_t*)rfx_calloc(sizeof(clipbuffer_t));
 470     c->data = (U32*)rfx_calloc(sizeof(U32) * i->bitwidth * i->height2);
 471     c->next = i->clipbuf;
 472     i->clipbuf = c;
 473     if(c->next)
 474         memcpy(c->data, c->next->data, i->bitwidth*i->height2);
 475     else
 476         memset(c->data, 0, sizeof(U32)*i->bitwidth*i->height2);
 477 }
 478
 479 void endclip(struct _gfxdevice*dev)
 480 {
 481     internal_t*i = (internal_t*)dev->internal;
 482
 483     if(!i->clipbuf) {
 484         fprintf(stderr, "endclip without any active clip buffers");
 485         return;
 486     }
 487
 488     clipbuffer_t*c = i->clipbuf;
 489     i->clipbuf = i->clipbuf->next;
 490     c->next = 0;
 491     free(c->data);c->data = 0;
 492     free(c);
 493 }
 494
 495 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)
 496 {
 497     internal_t*i = (internal_t*)dev->internal;
 498     double x,y;
 499
 500     /*if(cap_style != gfx_capRound || joint_style != gfx_joinRound) {
 501         fprintf(stderr, "Warning: cap/joint style != round not yet supported\n");
 502     }*/
 503
 504     while(line) {
 505         if(line->type == gfx_moveTo) {
 506         } else if(line->type == gfx_lineTo) {
 507             double x1=x*i->zoom,y1=y*i->zoom;
 508             double x3=line->x*i->zoom,y3=line->y*i->zoom;
 509             add_solidline(dev, x1, y1, x3, y3, width * i->multiply);
 510             fill_solid(dev, color);
 511         } else if(line->type == gfx_splineTo) {
 512             int t,parts;
 513             double xx,yy;
 514
 515             double x1=x*i->zoom,y1=y*i->zoom;
 516             double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
 517             double x3=line->x*i->zoom,y3=line->y*i->zoom;
 518
 519             double c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
 520             xx=x1;
 521             yy=y1;
 522
 523             parts = (int)(sqrt(c)/3);
 524             if(!parts) parts = 1;
 525
 526             for(t=1;t<=parts;t++) {
 527                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
 528                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
 529
 530                 add_solidline(dev, xx, yy, nx, ny, width * i->multiply);
 531                 fill_solid(dev, color);
 532                 xx = nx;
 533                 yy = ny;
 534             }
 535         }
 536         x = line->x;
 537         y = line->y;
 538         line = line->next;
 539     }
 540 }
 541
 542 static void draw_line(gfxdevice_t*dev, gfxline_t*line)
 543 {
 544     internal_t*i = (internal_t*)dev->internal;
 545     double x,y;
 546
 547     while(line)
 548     {
 549         int x1,y1,x2,y2,x3,y3;
 550
 551         if(line->type == gfx_moveTo) {
 552         } else if(line->type == gfx_lineTo) {
 553             double x1=x*i->zoom,y1=y*i->zoom;
 554             double x3=line->x*i->zoom,y3=line->y*i->zoom;
 555
 556             add_line(dev, x1, y1, x3, y3);
 557         } else if(line->type == gfx_splineTo) {
 558             int c,t,parts,qparts;
 559             double xx,yy;
 560
 561             double x1=x*i->zoom,y1=y*i->zoom;
 562             double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
 563             double x3=line->x*i->zoom,y3=line->y*i->zoom;
 564
 565             c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
 566             xx=x1;
 567             yy=y1;
 568
 569             parts = (int)(sqrt(c)/3);
 570             if(!parts) parts = 1;
 571
 572             for(t=1;t<=parts;t++) {
 573                 double nx = (double)(t*t*x3 + 2*t*(parts-t)*x2 + (parts-t)*(parts-t)*x1)/(double)(parts*parts);
 574                 double ny = (double)(t*t*y3 + 2*t*(parts-t)*y2 + (parts-t)*(parts-t)*y1)/(double)(parts*parts);
 575
 576                 add_line(dev, xx, yy, nx, ny);
 577                 xx = nx;
 578                 yy = ny;
 579             }
 580         }
 581         x = line->x;
 582         y = line->y;
 583         line = line->next;
 584     }
 585 }
 586
 587 void render_startclip(struct _gfxdevice*dev, gfxline_t*line)
 588 {
 589     internal_t*i = (internal_t*)dev->internal;
 590     fillinfo_t info;
 591     newclip(dev);
 592     info.type = filltype_clip;
 593     draw_line(dev, line);
 594     fill(dev, &info);
 595 }
 596
 597 void render_endclip(struct _gfxdevice*dev)
 598 {
 599     internal_t*i = (internal_t*)dev->internal;
 600     endclip(dev);
 601 }
 602
 603 void render_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
 604 {
 605     internal_t*i = (internal_t*)dev->internal;
 606
 607     draw_line(dev, line);
 608     fill_solid(dev, color);
 609 }
 610
 611 void render_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
 612 {
 613     internal_t*i = (internal_t*)dev->internal;
 614
 615     gfxcolor_t black = {255,0,0,0};
 616
 617     gfxmatrix_t m2 = *matrix;
 618
 619     draw_line(dev, line);
 620
 621     fillinfo_t info;
 622     info.type = filltype_bitmap;
 623     info.image = img;
 624     info.matrix = &m2;
 625     info.cxform = cxform;
 626
 627     m2.m00 *= i->zoom; m2.m01 *= i->zoom; m2.tx *= i->zoom;
 628     m2.m10 *= i->zoom; m2.m11 *= i->zoom; m2.ty *= i->zoom;
 629
 630     fill(dev, &info);
 631 }
 632
 633 void render_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
 634 {
 635     internal_t*i = (internal_t*)dev->internal;
 636
 637     gfxcolor_t black = {255,0,0,0};
 638
 639     draw_line(dev, line);
 640     fill_solid(dev, &black);
 641 }
 642
 643 void render_addfont(struct _gfxdevice*dev, gfxfont_t*font)
 644 {
 645 }
 646
 647 void render_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
 648 {
 649     internal_t*i = (internal_t*)dev->internal;
 650     if(!font)
 651         return;
 652
 653     /* align characters to whole pixels */
 654     matrix->tx = (int)(matrix->tx * i->antialize) / i->antialize;
 655     matrix->ty = (int)(matrix->ty * i->antialize) / i->antialize;
 656
 657     gfxglyph_t*glyph = &font->glyphs[glyphnr];
 658     gfxline_t*line2 = gfxline_clone(glyph->line);
 659     gfxline_transform(line2, matrix);
 660     draw_line(dev, line2);
 661     fill_solid(dev, color);
 662     gfxline_free(line2);
 663
 664     return;
 665 }
 666
 667 void render_result_write(gfxresult_t*r, int filedesc)
 668 {
 669     internal_result_t*i= (internal_result_t*)r->internal;
 670 }
 671 int render_result_save(gfxresult_t*r, const char*filename)
 672 {
 673     internal_result_t*i= (internal_result_t*)r->internal;
 674     if(!i) {
 675         return 0; // no pages drawn
 676     }
 677     if(i->next) {
 678         int nr=0;
 679         char filenamebuf[256];
 680         char*origname = strdup(filename);
 681         int l = strlen(origname);
 682         if(l>3 && strchr("gG",origname[l-1]) && strchr("nN",filename[l-2]) &&
 683                 strchr("pP",origname[l-3]) && filename[l-4]=='.') {
 684             origname[l-4] = 0;
 685         }
 686         while(i->next) {
 687             sprintf(filenamebuf, "%s.%d.png", origname, nr);
 688             writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
 689             nr++;
 690         }
 691         free(origname);
 692     } else {
 693         writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
 694     }
 695     return 1;
 696 }
 697 char*gfximage_asXPM(gfximage_t*img, int depth)
 698 {
 699     int d= 256/depth;
 700     char*str = (char*)malloc(img->width*img->height*4 + 500 + 16*depth*depth*depth);
 701     char*p = str;
 702     p+= sprintf(p, "static char *noname[] = {\n\"%d %d 262144 3\",\n");
 703     int r,g,b;
 704     for(r=0;r<depth;r++)
 705     for(g=0;g<depth;g++)
 706     for(b=0;b<depth;b++) {
 707         p += sprintf(p, "\"%c%c%c c #%02x%02x%02x\",\n", r+32,g+32,b+32, r*d,g*d,b*d);
 708     }
 709     int y;
 710     for(y=0;y<img->height;y++)  {
 711         p+=sprintf(p, "\"");
 712         gfxcolor_t*col = &img->data[y*img->height];
 713         int x;
 714         for(x=0;x<img->width;x++) {
 715             p+=sprintf(p, "%c%c%c", 32+(col->r/d), 32+(col->g/d), 32+(col->b/d));
 716         }
 717         p+=sprintf(p, "\",\n");
 718     }
 719     *p = 0;
 720     return p;
 721 }
 722 void*render_result_get(gfxresult_t*r, const char*name)
 723 {
 724     internal_result_t*i= (internal_result_t*)r->internal;
 725     if(!strncmp(name,"xpm",3)) {
 726         int pagenr = atoi(&name[3]);
 727         if(pagenr<0)
 728             pagenr=0;
 729         while(pagenr>0) {
 730             i = i->next;
 731             if(!i)
 732                 return 0;
 733         }
 734         return gfximage_asXPM(&i->img, 64);
 735     } else if(!strncmp(name,"page",4)) {
 736         int pagenr = atoi(&name[4]);
 737         if(pagenr<0)
 738             pagenr=0;
 739         while(pagenr>0) {
 740             i = i->next;
 741             if(!i)
 742                 return 0;
 743         }
 744         return &i->img;
 745     }
 746     return 0;
 747 }
 748 void render_result_destroy(gfxresult_t*r)
 749 {
 750     internal_result_t*i= (internal_result_t*)r->internal;
 751     r->internal = 0;
 752     while(i) {
 753         internal_result_t*next = i->next;
 754         free(i->img.data);i->img.data = 0;
 755
 756         /* FIXME memleak
 757            the following rfx_free causes a segfault on WIN32 machines,
 758            if executed */
 759         //rfx_free(i);
 760
 761         i = next;
 762     }
 763     rfx_free(r);
 764 }
 765
 766 gfxresult_t* render_finish(struct _gfxdevice*dev)
 767 {
 768     internal_t*i = (internal_t*)dev->internal;
 769
 770     gfxresult_t* res = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
 771
 772     res->internal = i->results;i->results = 0;
 773     res->write = render_result_write;
 774     res->save = render_result_save;
 775     res->get = render_result_get;
 776     res->destroy = render_result_destroy;
 777
 778     free(dev->internal); dev->internal = 0; i = 0;
 779
 780     return res;
 781 }
 782
 783 void render_startpage(struct _gfxdevice*dev, int width, int height)
 784 {
 785     internal_t*i = (internal_t*)dev->internal;
 786     int y;
 787
 788     if(i->width2 || i->height2) {
 789         fprintf(stderr, "Error: startpage() called twice (no endpage()?)\n");
 790         exit(1);
 791     }
 792
 793     i->width = width*i->multiply;
 794     i->height = height*i->multiply;
 795     i->width2 = width*i->zoom;
 796     i->height2 = height*i->zoom;
 797     i->bitwidth = (i->width2+31)/32;
 798
 799     i->lines = (renderline_t*)rfx_alloc(i->height2*sizeof(renderline_t));
 800     for(y=0;y<i->height2;y++) {
 801         memset(&i->lines[y], 0, sizeof(renderline_t));
 802         i->lines[y].points = 0;
 803         i->lines[y].num = 0;
 804     }
 805     i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
 806     if(i->fillwhite) {
 807         memset(i->img, 0xff, sizeof(RGBA)*i->width2*i->height2);
 808     }
 809
 810     i->ymin = 0x7fffffff;
 811     i->ymax = -0x80000000;
 812
 813
 814     /* initialize initial clipping field, which doesn't clip anything yet */
 815     newclip(dev);
 816     memset(i->clipbuf->data, 255, sizeof(U32)*i->bitwidth*i->height2);
 817 }
 818
 819 static void store_image(internal_t*i, internal_result_t*ir)
 820 {
 821     ir->img.data = (gfxcolor_t*)malloc(i->width*i->height*sizeof(gfxcolor_t));
 822     ir->img.width = i->width;
 823     ir->img.height = i->height;
 824
 825     gfxcolor_t*dest = ir->img.data;
 826
 827     if(i->antialize <= 1) /* no antializing */ {
 828         int y;
 829         for(y=0;y<i->height;y++) {
 830             RGBA*line = &i->img[y*i->width];
 831             memcpy(&dest[y*i->width], line, sizeof(RGBA)*i->width);
 832         }
 833     } else {
 834         RGBA**lines = (RGBA**)rfx_calloc(sizeof(RGBA*)*i->antialize);
 835         int q = i->antialize*i->antialize;
 836         int ypos = 0;
 837         int y;
 838         int y2=0;
 839         for(y=0;y<i->height2;y++) {
 840             int n;
 841             ypos = y % i->antialize;
 842             lines[ypos] = &i->img[y*i->width2];
 843             if(ypos == i->antialize-1) {
 844                 RGBA*out = &dest[(y2++)*i->width];
 845                 int x;
 846                 int r,g,b,a;
 847                 for(x=0;x<i->width;x++) {
 848                     int xpos = x*i->antialize;
 849                     int yp;
 850                     U32 r=0,g=0,b=0,a=0;
 851                     for(yp=0;yp<i->antialize;yp++) {
 852                         RGBA*lp = &lines[yp][xpos];
 853                         int xp;
 854                         for(xp=0;xp<i->antialize;xp++) {
 855                             RGBA*p = &lp[xp];
 856                             r += p->r;
 857                             g += p->g;
 858                             b += p->b;
 859                             a += p->a;
 860                         }
 861                     }
 862                     out[x].r = r / q;
 863                     out[x].g = g / q;
 864                     out[x].b = b / q;
 865                     out[x].a = a / q;
 866                 }
 867             }
 868         }
 869         rfx_free(lines);
 870     }
 871 }
 872
 873 void render_endpage(struct _gfxdevice*dev)
 874 {
 875     internal_t*i = (internal_t*)dev->internal;
 876
 877     if(!i->width2 || !i->height2) {
 878         fprintf(stderr, "Error: endpage() called without corresponding startpage()\n");
 879         exit(1);
 880     }
 881
 882     endclip(dev);
 883     while(i->clipbuf) {
 884         fprintf(stderr, "Warning: unclosed clip while processing endpage()\n");
 885         endclip(dev);
 886     }
 887
 888     internal_result_t*ir= (internal_result_t*)rfx_calloc(sizeof(internal_result_t));
 889
 890     int y,x;
 891
 892     store_image(i, ir);
 893
 894     ir->next = 0;
 895     if(i->result_next) {
 896         i->result_next->next = ir;
 897     }
 898     if(!i->results) {
 899         i->results = ir;
 900     }
 901     i->result_next = ir;
 902
 903     for(y=0;y<i->height2;y++) {
 904         rfx_free(i->lines[y].points); i->lines[y].points = 0;
 905     }
 906     rfx_free(i->lines);i->lines=0;
 907
 908     if(i->img) {rfx_free(i->img);i->img = 0;}
 909
 910     i->width2 = 0;
 911     i->height2 = 0;
 912 }
 913
 914 void render_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
 915 {
 916     /* not supported for this output device */
 917 }
 918
 919 void gfxdevice_render_init(gfxdevice_t*dev)
 920 {
 921     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
 922     memset(dev, 0, sizeof(gfxdevice_t));
 923
 924     dev->name = "render";
 925
 926     dev->internal = i;
 927
 928     i->width = 0;
 929     i->width2 = 0;
 930     i->height = 0;
 931     i->height2 = 0;
 932     i->antialize = 1;
 933     i->multiply = 1;
 934     i->zoom = 1;
 935
 936     dev->setparameter = render_setparameter;
 937     dev->startpage = render_startpage;
 938     dev->startclip = render_startclip;
 939     dev->endclip = render_endclip;
 940     dev->stroke = render_stroke;
 941     dev->fill = render_fill;
 942     dev->fillbitmap = render_fillbitmap;
 943     dev->fillgradient = render_fillgradient;
 944     dev->addfont = render_addfont;
 945     dev->drawchar = render_drawchar;
 946     dev->drawlink = render_drawlink;
 947     dev->endpage = render_endpage;
 948     dev->finish = render_finish;
 949 }
 950