lib/devices/record.c

   1 /* gfxdevice_record.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 "../../config.h"
  25 #ifdef HAVE_UNISTD_H
  26 #include <unistd.h>
  27 #endif
  28 #include <memory.h>
  29 #ifdef HAVE_IO_H
  30 #include <io.h>
  31 #endif
  32 #include <string.h>
  33 #include "../gfxdevice.h"
  34 #include "../gfxtools.h"
  35 #include "../types.h"
  36 #include "../bitio.h"
  37 #include "../log.h"
  38 #include "record.h"
  39
  40 typedef struct _internal {
  41     gfxfontlist_t* fontlist;
  42     writer_t w;
  43     int cliplevel;
  44 } internal_t;
  45
  46 typedef struct _internal_result {
  47     void*data;
  48     int length;
  49 } internal_result_t;
  50
  51 #define OP_END 0x00
  52 #define OP_SETPARAM 0x01
  53 #define OP_STROKE 0x02
  54 #define OP_STARTCLIP 0x03
  55 #define OP_ENDCLIP 0x04
  56 #define OP_FILL 0x05
  57 #define OP_FILLBITMAP 0x06
  58 #define OP_FILLGRADIENT 0x07
  59 #define OP_ADDFONT 0x08
  60 #define OP_DRAWCHAR 0x09
  61 #define OP_DRAWLINK 0x0a
  62 #define OP_STARTPAGE 0x0b
  63 #define OP_ENDPAGE 0x0c
  64 #define OP_FINISH 0x0d
  65
  66 #define OP_MOVETO 0x0e
  67 #define OP_LINETO 0x0f
  68 #define OP_SPLINETO 0x10
  69
  70 static int record_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
  71 {
  72     internal_t*i = (internal_t*)dev->internal;
  73     msg("<trace> record: %08x SETPARAM %s %s\n", dev, key, value);
  74     writer_writeU8(&i->w, OP_SETPARAM);
  75     writer_writeString(&i->w, key);
  76     writer_writeString(&i->w, value);
  77     return 1;
  78 }
  79
  80 static void dumpLine(writer_t*w, gfxline_t*line)
  81 {
  82     while(line) {
  83         if(line->type == gfx_moveTo) {
  84             writer_writeU8(w, OP_MOVETO);
  85             writer_writeDouble(w, line->x);
  86             writer_writeDouble(w, line->y);
  87         } else if(line->type == gfx_lineTo) {
  88             writer_writeU8(w, OP_LINETO);
  89             writer_writeDouble(w, line->x);
  90             writer_writeDouble(w, line->y);
  91         } else if(line->type == gfx_splineTo) {
  92             writer_writeU8(w, OP_SPLINETO);
  93             writer_writeDouble(w, line->x);
  94             writer_writeDouble(w, line->y);
  95             writer_writeDouble(w, line->sx);
  96             writer_writeDouble(w, line->sy);
  97         }
  98         line = line->next;
  99     }
 100     writer_writeU8(w, OP_END);
 101 }
 102 static gfxline_t* readLine(reader_t*r)
 103 {
 104     gfxline_t*start = 0, *pos = 0;
 105     while(1) {
 106         unsigned char op = reader_readU8(r);
 107         if(op == OP_END)
 108             break;
 109         gfxline_t*line = (gfxline_t*)rfx_calloc(sizeof(gfxline_t));
 110         if(!start) {
 111             start = pos = line;
 112         } else {
 113             pos->next = line;
 114             pos = line;
 115         }
 116         if(op == OP_MOVETO) {
 117             line->type = gfx_moveTo;
 118             line->x = reader_readDouble(r);
 119             line->y = reader_readDouble(r);
 120         } else if(op == OP_LINETO) {
 121             line->type = gfx_lineTo;
 122             line->x = reader_readDouble(r);
 123             line->y = reader_readDouble(r);
 124         } else if(op == OP_SPLINETO) {
 125             line->type = gfx_splineTo;
 126             line->x = reader_readDouble(r);
 127             line->y = reader_readDouble(r);
 128             line->sx = reader_readDouble(r);
 129             line->sy = reader_readDouble(r);
 130         }
 131     }
 132     return start;
 133 }
 134 static gfximage_t readImage(reader_t*r)
 135 {
 136     gfximage_t img;
 137     img.width = reader_readU16(r);
 138     img.height = reader_readU16(r);
 139     img.data = (gfxcolor_t*)rfx_alloc(img.width*img.height*4);
 140     r->read(r, img.data, img.width*img.height*4);
 141     return img;
 142 }
 143 static gfxmatrix_t readMatrix(reader_t*r)
 144 {
 145     gfxmatrix_t matrix;
 146     matrix.m00 = reader_readDouble(r);
 147     matrix.m01 = reader_readDouble(r);
 148     matrix.m10 = reader_readDouble(r);
 149     matrix.m11 = reader_readDouble(r);
 150     matrix.tx = reader_readDouble(r);
 151     matrix.ty = reader_readDouble(r);
 152     return matrix;
 153 }
 154 static gfxcolor_t readColor(reader_t*r)
 155 {
 156     gfxcolor_t col;
 157     col.r = reader_readU8(r);
 158     col.g = reader_readU8(r);
 159     col.b = reader_readU8(r);
 160     col.a = reader_readU8(r);
 161     return col;
 162 }
 163 static gfxgradient_t* readGradient(reader_t*r)
 164 {
 165     gfxgradient_t*start = 0, *pos = 0;
 166     while(1) {
 167         U8 op = reader_readU8(r);
 168         if(!op)
 169             break;
 170         gfxgradient_t*g = (gfxgradient_t*)rfx_calloc(sizeof(gfxgradient_t));
 171         if(!start) {
 172             start = pos = g;
 173         } else {
 174             pos->next = g;
 175             pos = g;
 176         }
 177         g->color = readColor(r);
 178         g->pos = reader_readFloat(r);
 179     }
 180     return start;
 181 }
 182 static gfxcxform_t* readCXForm(reader_t*r)
 183 {
 184     U8 type = reader_readU8(r);
 185     if(!type)
 186         return 0;
 187     gfxcxform_t* c = (gfxcxform_t*)rfx_calloc(sizeof(gfxcxform_t));
 188     c->rr = reader_readFloat(r); c->rg = reader_readFloat(r); c->rb = reader_readFloat(r); c->ra = reader_readFloat(r);
 189     c->gr = reader_readFloat(r); c->gg = reader_readFloat(r); c->gb = reader_readFloat(r); c->ga = reader_readFloat(r);
 190     c->br = reader_readFloat(r); c->bg = reader_readFloat(r); c->bb = reader_readFloat(r); c->ba = reader_readFloat(r);
 191     c->ar = reader_readFloat(r); c->ag = reader_readFloat(r); c->ab = reader_readFloat(r); c->aa = reader_readFloat(r);
 192     return c;
 193 }
 194
 195 static void dumpColor(writer_t*w, gfxcolor_t*color)
 196 {
 197     writer_writeU8(w, color->r);
 198     writer_writeU8(w, color->g);
 199     writer_writeU8(w, color->b);
 200     writer_writeU8(w, color->a);
 201 }
 202 static void dumpMatrix(writer_t*w, gfxmatrix_t*matrix)
 203 {
 204     writer_writeDouble(w, matrix->m00);
 205     writer_writeDouble(w, matrix->m01);
 206     writer_writeDouble(w, matrix->m10);
 207     writer_writeDouble(w, matrix->m11);
 208     writer_writeDouble(w, matrix->tx);
 209     writer_writeDouble(w, matrix->ty);
 210 }
 211 static void dumpGradient(writer_t*w, gfxgradient_t*gradient)
 212 {
 213     while(gradient) {
 214         writer_writeU8(w, 1);
 215         dumpColor(w, &gradient->color);
 216         writer_writeFloat(w, gradient->pos);
 217         gradient = gradient->next;
 218     }
 219     writer_writeU8(w, 0);
 220 }
 221 static void dumpImage(writer_t*w, gfximage_t*image)
 222 {
 223     writer_writeU16(w, image->width);
 224     writer_writeU16(w, image->height);
 225     w->write(w, image->data, image->width*image->height*4);
 226 }
 227 static void dumpCXForm(writer_t*w, gfxcxform_t*c)
 228 {
 229     if(!c) {
 230         writer_writeU8(w, 0);
 231     } else {
 232         writer_writeU8(w, 1);
 233         writer_writeFloat(w, c->rr); writer_writeFloat(w, c->rg); writer_writeFloat(w, c->rb); writer_writeFloat(w, c->ra);
 234         writer_writeFloat(w, c->gr); writer_writeFloat(w, c->gg); writer_writeFloat(w, c->gb); writer_writeFloat(w, c->ga);
 235         writer_writeFloat(w, c->br); writer_writeFloat(w, c->bg); writer_writeFloat(w, c->bb); writer_writeFloat(w, c->ba);
 236         writer_writeFloat(w, c->ar); writer_writeFloat(w, c->ag); writer_writeFloat(w, c->ab); writer_writeFloat(w, c->aa);
 237     }
 238 }
 239 static void dumpFont(writer_t*w, gfxfont_t*font)
 240 {
 241     writer_writeString(w, font->id);
 242     writer_writeU32(w, font->num_glyphs);
 243     writer_writeU32(w, font->max_unicode);
 244     writer_writeDouble(w, font->ascent);
 245     writer_writeDouble(w, font->descent);
 246     int t;
 247     for(t=0;t<font->num_glyphs;t++) {
 248         dumpLine(w, font->glyphs[t].line);
 249         writer_writeDouble(w, font->glyphs[t].advance);
 250         writer_writeU32(w, font->glyphs[t].unicode);
 251         if(font->glyphs[t].name) {
 252             writer_writeString(w,font->glyphs[t].name);
 253         } else {
 254             writer_writeU8(w,0);
 255         }
 256     }
 257     for(t=0;t<font->max_unicode;t++) {
 258         writer_writeU32(w, font->unicode2glyph[t]);
 259     }
 260     writer_writeU32(w, font->kerning_size);
 261     for(t=0;t<font->kerning_size;t++) {
 262         writer_writeU32(w, font->kerning[t].c1);
 263         writer_writeU32(w, font->kerning[t].c2);
 264         writer_writeU32(w, font->kerning[t].advance);
 265     }
 266 }
 267 static gfxfont_t*readFont(reader_t*r)
 268 {
 269     gfxfont_t* font = (gfxfont_t*)rfx_calloc(sizeof(gfxfont_t));
 270     font->id = reader_readString(r);
 271     font->num_glyphs = reader_readU32(r);
 272     font->max_unicode = reader_readU32(r);
 273     font->ascent = reader_readDouble(r);
 274     font->descent = reader_readDouble(r);
 275     font->glyphs = (gfxglyph_t*)rfx_calloc(sizeof(gfxglyph_t)*font->num_glyphs);
 276     font->unicode2glyph = (int*)rfx_calloc(sizeof(font->unicode2glyph[0])*font->max_unicode);
 277     int t;
 278     for(t=0;t<font->num_glyphs;t++) {
 279         font->glyphs[t].line = readLine(r);
 280         font->glyphs[t].advance = reader_readDouble(r);
 281         font->glyphs[t].unicode = reader_readU32(r);
 282         font->glyphs[t].name = reader_readString(r);
 283         if(!font->glyphs[t].name[0]) {
 284             free((void*)(font->glyphs[t].name));
 285             font->glyphs[t].name = 0;
 286         }
 287     }
 288     for(t=0;t<font->max_unicode;t++) {
 289         font->unicode2glyph[t] = reader_readU32(r);
 290     }
 291     font->kerning_size = reader_readU32(r);
 292     if(font->kerning_size) {
 293         font->kerning = malloc(sizeof(gfxkerning_t)*font->kerning_size);
 294         for(t=0;t<font->kerning_size;t++) {
 295             font->kerning[t].c1 = reader_readU32(r);
 296             font->kerning[t].c2 = reader_readU32(r);
 297             font->kerning[t].advance = reader_readU32(r);
 298         }
 299     }
 300     return font;
 301 }
 302
 303 static void record_stroke(struct _gfxdevice*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit)
 304 {
 305     internal_t*i = (internal_t*)dev->internal;
 306     msg("<trace> record: %08x STROKE\n", dev);
 307     writer_writeU8(&i->w, OP_STROKE);
 308     writer_writeDouble(&i->w, width);
 309     writer_writeDouble(&i->w, miterLimit);
 310     dumpColor(&i->w, color);
 311     writer_writeU8(&i->w, cap_style);
 312     writer_writeU8(&i->w, joint_style);
 313     dumpLine(&i->w, line);
 314 }
 315
 316 static void record_startclip(struct _gfxdevice*dev, gfxline_t*line)
 317 {
 318     internal_t*i = (internal_t*)dev->internal;
 319     msg("<trace> record: %08x STARTCLIP\n", dev);
 320     writer_writeU8(&i->w, OP_STARTCLIP);
 321     dumpLine(&i->w, line);
 322     i->cliplevel++;
 323 }
 324
 325 static void record_endclip(struct _gfxdevice*dev)
 326 {
 327     internal_t*i = (internal_t*)dev->internal;
 328     msg("<trace> record: %08x ENDCLIP\n", dev);
 329     writer_writeU8(&i->w, OP_ENDCLIP);
 330     i->cliplevel--;
 331     if(i->cliplevel<0) {
 332         msg("<error> record: endclip() without startclip()");
 333     }
 334 }
 335
 336 static void record_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
 337 {
 338     internal_t*i = (internal_t*)dev->internal;
 339     msg("<trace> record: %08x FILL\n", dev);
 340     writer_writeU8(&i->w, OP_FILL);
 341     dumpColor(&i->w, color);
 342     dumpLine(&i->w, line);
 343 }
 344
 345 static void record_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
 346 {
 347     internal_t*i = (internal_t*)dev->internal;
 348     msg("<trace> record: %08x FILLBITMAP\n", dev);
 349     writer_writeU8(&i->w, OP_FILLBITMAP);
 350     dumpImage(&i->w, img);
 351     dumpMatrix(&i->w, matrix);
 352     dumpLine(&i->w, line);
 353     dumpCXForm(&i->w, cxform);
 354 }
 355
 356 static void record_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
 357 {
 358     internal_t*i = (internal_t*)dev->internal;
 359     msg("<trace> record: %08x FILLGRADIENT %08x\n", dev, gradient);
 360     writer_writeU8(&i->w, OP_FILLGRADIENT);
 361     writer_writeU8(&i->w, type);
 362     dumpGradient(&i->w, gradient);
 363     dumpMatrix(&i->w, matrix);
 364     dumpLine(&i->w, line);
 365 }
 366
 367 static void record_addfont(struct _gfxdevice*dev, gfxfont_t*font)
 368 {
 369     internal_t*i = (internal_t*)dev->internal;
 370     msg("<trace> record: %08x ADDFONT %s\n", dev, font->id);
 371     if(font && !gfxfontlist_hasfont(i->fontlist, font)) {
 372         writer_writeU8(&i->w, OP_ADDFONT);
 373         dumpFont(&i->w, font);
 374         i->fontlist = gfxfontlist_addfont(i->fontlist, font);
 375     }
 376 }
 377
 378 static void record_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
 379 {
 380     internal_t*i = (internal_t*)dev->internal;
 381     if(font && !gfxfontlist_hasfont(i->fontlist, font)) {
 382         record_addfont(dev, font);
 383     }
 384
 385     msg("<trace> record: %08x DRAWCHAR %d\n", glyphnr, dev);
 386     writer_writeU8(&i->w, OP_DRAWCHAR);
 387     if(font)
 388         writer_writeString(&i->w, font->id);
 389     else
 390         writer_writeString(&i->w, "*NULL*");
 391     writer_writeU32(&i->w, glyphnr);
 392     dumpColor(&i->w, color);
 393     dumpMatrix(&i->w, matrix);
 394 }
 395
 396 static void record_startpage(struct _gfxdevice*dev, int width, int height)
 397 {
 398     internal_t*i = (internal_t*)dev->internal;
 399     msg("<trace> record: %08x STARTPAGE\n", dev);
 400     writer_writeU8(&i->w, OP_STARTPAGE);
 401     writer_writeU16(&i->w, width);
 402     writer_writeU16(&i->w, height);
 403 }
 404
 405 static void record_endpage(struct _gfxdevice*dev)
 406 {
 407     internal_t*i = (internal_t*)dev->internal;
 408     msg("<trace> record: %08x ENDPAGE\n", dev);
 409     writer_writeU8(&i->w, OP_ENDPAGE);
 410 }
 411
 412 static void record_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
 413 {
 414     internal_t*i = (internal_t*)dev->internal;
 415     msg("<trace> record: %08x DRAWLINK\n", dev);
 416     writer_writeU8(&i->w, OP_DRAWLINK);
 417     dumpLine(&i->w, line);
 418     writer_writeString(&i->w, action);
 419 }
 420
 421 static void replay(struct _gfxdevice*dev, gfxdevice_t*out, void*data, int length)
 422 {
 423     internal_t*i = 0;
 424     if(dev) {
 425         i = (internal_t*)dev->internal;
 426     }
 427
 428     reader_t r2;
 429     reader_t*r = &r2;
 430     reader_init_memreader(r, data, length);
 431     gfxfontlist_t* fontlist = gfxfontlist_create();
 432
 433     while(r->pos < length) {
 434         unsigned char op = reader_readU8(r);
 435         switch(op) {
 436             case OP_END:
 437                 goto finish;
 438             case OP_SETPARAM: {
 439                 msg("<trace> replay: SETPARAM");
 440                 char*key;
 441                 char*value;
 442                 key = reader_readString(r);
 443                 value = reader_readString(r);
 444                 out->setparameter(out, key, value);
 445                 free(key);
 446                 free(value);
 447                 break;
 448             }
 449             case OP_STARTPAGE: {
 450                 msg("<trace> replay: STARTPAGE");
 451                 U16 width = reader_readU16(r);
 452                 U16 height = reader_readU16(r);
 453                 out->startpage(out, width, height);
 454                 break;
 455             }
 456             case OP_ENDPAGE: {
 457                 msg("<trace> replay: ENDPAGE");
 458                 break;
 459             }
 460             case OP_FINISH: {
 461                 msg("<trace> replay: FINISH");
 462                 break;
 463             }
 464             case OP_STROKE: {
 465                 msg("<trace> replay: STROKE");
 466                 double width = reader_readDouble(r);
 467                 double miterlimit = reader_readDouble(r);
 468                 gfxcolor_t color = readColor(r);
 469                 gfx_capType captype;
 470                 int v = reader_readU8(r);
 471                 switch (v) {
 472                     case 0: captype = gfx_capButt; break;
 473                     case 1: captype = gfx_capRound; break;
 474                     case 2: captype = gfx_capSquare; break;
 475                 }
 476                 gfx_joinType jointtype;
 477                 v = reader_readU8(r);
 478                 switch (v) {
 479                     case 0: jointtype = gfx_joinMiter; break;
 480                     case 1: jointtype = gfx_joinRound; break;
 481                     case 2: jointtype = gfx_joinBevel; break;
 482                 }
 483                 gfxline_t* line = readLine(r);
 484                 out->stroke(out, line, width, &color, captype, jointtype,miterlimit);
 485                 gfxline_free(line);
 486                 break;
 487             }
 488             case OP_STARTCLIP: {
 489                 msg("<trace> replay: STARTCLIP");
 490                 gfxline_t* line = readLine(r);
 491                 out->startclip(out, line);
 492                 gfxline_free(line);
 493                 break;
 494             }
 495             case OP_ENDCLIP: {
 496                 msg("<trace> replay: ENDCLIP");
 497                 out->endclip(out);
 498                 break;
 499             }
 500             case OP_FILL: {
 501                 msg("<trace> replay: FILL");
 502                 gfxcolor_t color = readColor(r);
 503                 gfxline_t* line = readLine(r);
 504                 out->fill(out, line, &color);
 505                 gfxline_free(line);
 506                 break;
 507             }
 508             case OP_FILLBITMAP: {
 509                 msg("<trace> replay: FILLBITMAP");
 510                 gfximage_t img = readImage(r);
 511                 gfxmatrix_t matrix = readMatrix(r);
 512                 gfxline_t* line = readLine(r);
 513                 gfxcxform_t* cxform = readCXForm(r);
 514                 out->fillbitmap(out, line, &img, &matrix, cxform);
 515                 gfxline_free(line);
 516                 if(cxform)
 517                     free(cxform);
 518                 free(img.data);img.data=0;
 519                 break;
 520             }
 521             case OP_FILLGRADIENT: {
 522                 msg("<trace> replay: FILLGRADIENT");
 523                 gfxgradienttype_t type;
 524                 int v = reader_readU8(r);
 525                 switch (v) {
 526                     case 0:
 527                       type = gfxgradient_radial; break;
 528                     case 1:
 529                       type = gfxgradient_linear; break;
 530                 }
 531                 gfxgradient_t*gradient = readGradient(r);
 532                 gfxmatrix_t matrix = readMatrix(r);
 533                 gfxline_t* line = readLine(r);
 534                 out->fillgradient(out, line, gradient, type, &matrix);
 535                 break;
 536             }
 537             case OP_DRAWLINK: {
 538                 msg("<trace> replay: DRAWLINK");
 539                 gfxline_t* line = readLine(r);
 540                 char* s = reader_readString(r);
 541                 out->drawlink(out,line,s);
 542                 gfxline_free(line);
 543                 free(s);
 544                 break;
 545             }
 546             case OP_ADDFONT: {
 547                 msg("<trace> replay: ADDFONT out=%08x(%s)", out, out->name);
 548                 gfxfont_t*font = readFont(r);
 549                 fontlist = gfxfontlist_addfont(fontlist, font);
 550                 out->addfont(out, font);
 551                 break;
 552             }
 553             case OP_DRAWCHAR: {
 554                 char* id = reader_readString(r);
 555                 gfxfont_t*font = id?gfxfontlist_findfont(fontlist, id):0;
 556                 if(i && !font) {
 557                     font = gfxfontlist_findfont(i->fontlist, id);
 558                 }
 559                 U32 glyph = reader_readU32(r);
 560                 msg("<trace> replay: DRAWCHAR font=%s glyph=%d", id, glyph);
 561                 gfxcolor_t color = readColor(r);
 562                 gfxmatrix_t matrix = readMatrix(r);
 563                 out->drawchar(out, font, glyph, &color, &matrix);
 564                 free(id);
 565                 break;
 566             }
 567         }
 568     }
 569 finish:
 570     r->dealloc(r);
 571     /* problem: if we just replayed into a device which stores the
 572        font for later use (the record device itself is a nice example),
 573        then we can't free it yet */
 574     //gfxfontlist_free(fontlist, 1);
 575     gfxfontlist_free(fontlist, 0);
 576 }
 577 void gfxresult_record_replay(gfxresult_t*result, gfxdevice_t*device)
 578 {
 579     internal_result_t*i = (internal_result_t*)result->internal;
 580     replay(0, device, i->data, i->length);
 581 }
 582
 583 static void record_result_write(gfxresult_t*r, int filedesc)
 584 {
 585     internal_result_t*i = (internal_result_t*)r->internal;
 586     write(filedesc, i->data, i->length);
 587 }
 588 static int record_result_save(gfxresult_t*r, const char*filename)
 589 {
 590     internal_result_t*i = (internal_result_t*)r->internal;
 591     FILE*fi = fopen(filename, "wb");
 592     if(!fi) {
 593         fprintf(stderr, "Couldn't open file %s for writing\n", filename);
 594         return -1;
 595     }
 596     fwrite(i->data, i->length, 1, fi);
 597     fclose(fi);
 598     return 0;
 599 }
 600 static void*record_result_get(gfxresult_t*r, const char*name)
 601 {
 602     internal_result_t*i = (internal_result_t*)r->internal;
 603     if(!strcmp(name, "data")) {
 604         return i->data;
 605     } else if(!strcmp(name, "length")) {
 606         return &i->length;
 607     }
 608     return 0;
 609 }
 610 static void record_result_destroy(gfxresult_t*r)
 611 {
 612     internal_result_t*i = (internal_result_t*)r->internal;
 613     if(i->data) {
 614         free(i->data);i->data = 0;
 615     }
 616     free(r->internal);r->internal = 0;
 617     free(r);
 618 }
 619
 620 static unsigned char printable(unsigned char a)
 621 {
 622     if(a<32 || a==127) return '.';
 623     else return a;
 624 }
 625
 626 static void hexdumpMem(unsigned char*data, int len)
 627 {
 628     int t;
 629     char ascii[32];
 630     for(t=0;t<len;t++) {
 631         printf("%02x ", data[t]);
 632         ascii[t&15] = printable(data[t]);
 633         if((t && ((t&15)==15)) || (t==len-1))
 634         {
 635             int s,p=((t)&15)+1;
 636             ascii[p] = 0;
 637             for(s=p-1;s<16;s++) {
 638                 printf("   ");
 639             }
 640             printf(" %s\n", ascii);
 641         }
 642     }
 643 }
 644
 645 void gfxdevice_record_flush(gfxdevice_t*dev, gfxdevice_t*out)
 646 {
 647     internal_t*i = (internal_t*)dev->internal;
 648     if(out) {
 649         int len=0;
 650         void*data = writer_growmemwrite_memptr(&i->w, &len);
 651         replay(dev, out, data, len);
 652     }
 653     writer_growmemwrite_reset(&i->w);
 654 }
 655
 656 static gfxresult_t* record_finish(struct _gfxdevice*dev)
 657 {
 658     internal_t*i = (internal_t*)dev->internal;
 659     msg("<trace> record: %08x END", dev);
 660
 661     if(i->cliplevel) {
 662         msg("<error> Warning: unclosed cliplevels");
 663     }
 664
 665     writer_writeU8(&i->w, OP_END);
 666
 667     gfxfontlist_free(i->fontlist, 0);
 668
 669     internal_result_t*ir = (internal_result_t*)rfx_calloc(sizeof(gfxresult_t));
 670     ir->data = writer_growmemwrite_getmem(&i->w);
 671     ir->length = i->w.pos;
 672     i->w.finish(&i->w);
 673
 674     gfxresult_t*result= (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
 675     result->save = record_result_save;
 676     result->get = record_result_get;
 677     result->destroy = record_result_destroy;
 678     result->internal = ir;
 679
 680     free(dev->internal);memset(dev, 0, sizeof(gfxdevice_t));
 681
 682     return result;
 683 }
 684 void gfxdevice_record_init(gfxdevice_t*dev)
 685 {
 686     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
 687     memset(dev, 0, sizeof(gfxdevice_t));
 688
 689     dev->name = "record";
 690
 691     dev->internal = i;
 692
 693     writer_init_growingmemwriter(&i->w, 1048576);
 694     i->fontlist = gfxfontlist_create();
 695     i->cliplevel = 0;
 696
 697     dev->setparameter = record_setparameter;
 698     dev->startpage = record_startpage;
 699     dev->startclip = record_startclip;
 700     dev->endclip = record_endclip;
 701     dev->stroke = record_stroke;
 702     dev->fill = record_fill;
 703     dev->fillbitmap = record_fillbitmap;
 704     dev->fillgradient = record_fillgradient;
 705     dev->addfont = record_addfont;
 706     dev->drawchar = record_drawchar;
 707     dev->drawlink = record_drawlink;
 708     dev->endpage = record_endpage;
 709     dev->finish = record_finish;
 710 }
 711