3 Part of the swftools package.
5 Copyright (c) 2005 Matthias Kramm <kramm@quiss.org>
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.
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.
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 */
24 #include "../../config.h"
33 #include "../gfxdevice.h"
34 #include "../gfxtools.h"
40 typedef struct _internal {
41 gfxfontlist_t* fontlist;
46 typedef struct _internal_result {
52 #define OP_SETPARAM 0x01
53 #define OP_STROKE 0x02
54 #define OP_STARTCLIP 0x03
55 #define OP_ENDCLIP 0x04
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
66 #define OP_MOVETO 0x0e
67 #define OP_LINETO 0x0f
68 #define OP_SPLINETO 0x10
70 static int record_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
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);
80 static void dumpLine(writer_t*w, gfxline_t*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);
100 writer_writeU8(w, OP_END);
102 static gfxline_t* readLine(reader_t*r)
104 gfxline_t*start = 0, *pos = 0;
106 unsigned char op = reader_readU8(r);
109 gfxline_t*line = (gfxline_t*)rfx_calloc(sizeof(gfxline_t));
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);
134 static gfximage_t readImage(reader_t*r)
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);
143 static gfxmatrix_t readMatrix(reader_t*r)
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);
154 static gfxcolor_t readColor(reader_t*r)
157 col.r = reader_readU8(r);
158 col.g = reader_readU8(r);
159 col.b = reader_readU8(r);
160 col.a = reader_readU8(r);
163 static gfxgradient_t* readGradient(reader_t*r)
165 gfxgradient_t*start = 0, *pos = 0;
167 U8 op = reader_readU8(r);
170 gfxgradient_t*g = (gfxgradient_t*)rfx_calloc(sizeof(gfxgradient_t));
177 g->color = readColor(r);
178 g->pos = reader_readFloat(r);
182 static gfxcxform_t* readCXForm(reader_t*r)
184 U8 type = reader_readU8(r);
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);
195 static void dumpColor(writer_t*w, gfxcolor_t*color)
197 writer_writeU8(w, color->r);
198 writer_writeU8(w, color->g);
199 writer_writeU8(w, color->b);
200 writer_writeU8(w, color->a);
202 static void dumpMatrix(writer_t*w, gfxmatrix_t*matrix)
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);
211 static void dumpGradient(writer_t*w, gfxgradient_t*gradient)
214 writer_writeU8(w, 1);
215 dumpColor(w, &gradient->color);
216 writer_writeFloat(w, gradient->pos);
217 gradient = gradient->next;
219 writer_writeU8(w, 0);
221 static void dumpImage(writer_t*w, gfximage_t*image)
223 writer_writeU16(w, image->width);
224 writer_writeU16(w, image->height);
225 w->write(w, image->data, image->width*image->height*4);
227 static void dumpCXForm(writer_t*w, gfxcxform_t*c)
230 writer_writeU8(w, 0);
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);
239 static void dumpFont(writer_t*w, gfxfont_t*font)
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);
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);
257 for(t=0;t<font->max_unicode;t++) {
258 writer_writeU32(w, font->unicode2glyph[t]);
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);
267 static gfxfont_t*readFont(reader_t*r)
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);
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;
288 for(t=0;t<font->max_unicode;t++) {
289 font->unicode2glyph[t] = reader_readU32(r);
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);
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)
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);
316 static void record_startclip(struct _gfxdevice*dev, gfxline_t*line)
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);
325 static void record_endclip(struct _gfxdevice*dev)
327 internal_t*i = (internal_t*)dev->internal;
328 msg("<trace> record: %08x ENDCLIP\n", dev);
329 writer_writeU8(&i->w, OP_ENDCLIP);
332 msg("<error> record: endclip() without startclip()");
336 static void record_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color)
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);
345 static void record_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform)
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);
356 static void record_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix)
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);
367 static void record_addfont(struct _gfxdevice*dev, gfxfont_t*font)
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);
378 static void record_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
380 internal_t*i = (internal_t*)dev->internal;
381 if(font && !gfxfontlist_hasfont(i->fontlist, font)) {
382 record_addfont(dev, font);
385 msg("<trace> record: %08x DRAWCHAR %d\n", glyphnr, dev);
386 writer_writeU8(&i->w, OP_DRAWCHAR);
388 writer_writeString(&i->w, font->id);
390 writer_writeString(&i->w, "*NULL*");
391 writer_writeU32(&i->w, glyphnr);
392 dumpColor(&i->w, color);
393 dumpMatrix(&i->w, matrix);
396 static void record_startpage(struct _gfxdevice*dev, int width, int height)
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);
405 static void record_endpage(struct _gfxdevice*dev)
407 internal_t*i = (internal_t*)dev->internal;
408 msg("<trace> record: %08x ENDPAGE\n", dev);
409 writer_writeU8(&i->w, OP_ENDPAGE);
412 static void record_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
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);
421 static void replay(struct _gfxdevice*dev, gfxdevice_t*out, void*data, int length)
425 i = (internal_t*)dev->internal;
430 reader_init_memreader(r, data, length);
431 gfxfontlist_t* fontlist = gfxfontlist_create();
433 while(r->pos < length) {
434 unsigned char op = reader_readU8(r);
439 msg("<trace> replay: SETPARAM");
442 key = reader_readString(r);
443 value = reader_readString(r);
444 out->setparameter(out, key, value);
450 msg("<trace> replay: STARTPAGE");
451 U16 width = reader_readU16(r);
452 U16 height = reader_readU16(r);
453 out->startpage(out, width, height);
457 msg("<trace> replay: ENDPAGE");
461 msg("<trace> replay: FINISH");
465 msg("<trace> replay: STROKE");
466 double width = reader_readDouble(r);
467 double miterlimit = reader_readDouble(r);
468 gfxcolor_t color = readColor(r);
470 int v = reader_readU8(r);
472 case 0: captype = gfx_capButt; break;
473 case 1: captype = gfx_capRound; break;
474 case 2: captype = gfx_capSquare; break;
476 gfx_joinType jointtype;
477 v = reader_readU8(r);
479 case 0: jointtype = gfx_joinMiter; break;
480 case 1: jointtype = gfx_joinRound; break;
481 case 2: jointtype = gfx_joinBevel; break;
483 gfxline_t* line = readLine(r);
484 out->stroke(out, line, width, &color, captype, jointtype,miterlimit);
489 msg("<trace> replay: STARTCLIP");
490 gfxline_t* line = readLine(r);
491 out->startclip(out, line);
496 msg("<trace> replay: ENDCLIP");
501 msg("<trace> replay: FILL");
502 gfxcolor_t color = readColor(r);
503 gfxline_t* line = readLine(r);
504 out->fill(out, line, &color);
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);
518 free(img.data);img.data=0;
521 case OP_FILLGRADIENT: {
522 msg("<trace> replay: FILLGRADIENT");
523 gfxgradienttype_t type;
524 int v = reader_readU8(r);
527 type = gfxgradient_radial; break;
529 type = gfxgradient_linear; break;
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);
538 msg("<trace> replay: DRAWLINK");
539 gfxline_t* line = readLine(r);
540 char* s = reader_readString(r);
541 out->drawlink(out,line,s);
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);
554 char* id = reader_readString(r);
555 gfxfont_t*font = id?gfxfontlist_findfont(fontlist, id):0;
557 font = gfxfontlist_findfont(i->fontlist, id);
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);
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);
577 void gfxresult_record_replay(gfxresult_t*result, gfxdevice_t*device)
579 internal_result_t*i = (internal_result_t*)result->internal;
580 replay(0, device, i->data, i->length);
583 static void record_result_write(gfxresult_t*r, int filedesc)
585 internal_result_t*i = (internal_result_t*)r->internal;
586 write(filedesc, i->data, i->length);
588 static int record_result_save(gfxresult_t*r, const char*filename)
590 internal_result_t*i = (internal_result_t*)r->internal;
591 FILE*fi = fopen(filename, "wb");
593 fprintf(stderr, "Couldn't open file %s for writing\n", filename);
596 fwrite(i->data, i->length, 1, fi);
600 static void*record_result_get(gfxresult_t*r, const char*name)
602 internal_result_t*i = (internal_result_t*)r->internal;
603 if(!strcmp(name, "data")) {
605 } else if(!strcmp(name, "length")) {
610 static void record_result_destroy(gfxresult_t*r)
612 internal_result_t*i = (internal_result_t*)r->internal;
614 free(i->data);i->data = 0;
616 free(r->internal);r->internal = 0;
620 static unsigned char printable(unsigned char a)
622 if(a<32 || a==127) return '.';
626 static void hexdumpMem(unsigned char*data, int len)
631 printf("%02x ", data[t]);
632 ascii[t&15] = printable(data[t]);
633 if((t && ((t&15)==15)) || (t==len-1))
637 for(s=p-1;s<16;s++) {
640 printf(" %s\n", ascii);
645 void gfxdevice_record_flush(gfxdevice_t*dev, gfxdevice_t*out)
647 internal_t*i = (internal_t*)dev->internal;
650 void*data = writer_growmemwrite_memptr(&i->w, &len);
651 replay(dev, out, data, len);
653 writer_growmemwrite_reset(&i->w);
656 static gfxresult_t* record_finish(struct _gfxdevice*dev)
658 internal_t*i = (internal_t*)dev->internal;
659 msg("<trace> record: %08x END", dev);
662 msg("<error> Warning: unclosed cliplevels");
665 writer_writeU8(&i->w, OP_END);
667 gfxfontlist_free(i->fontlist, 0);
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;
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;
680 free(dev->internal);memset(dev, 0, sizeof(gfxdevice_t));
684 void gfxdevice_record_init(gfxdevice_t*dev)
686 internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
687 memset(dev, 0, sizeof(gfxdevice_t));
689 dev->name = "record";
693 writer_init_growingmemwriter(&i->w, 1048576);
694 i->fontlist = gfxfontlist_create();
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;