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