X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=blobdiff_plain;f=lib%2Fdevices%2Frecord.c;h=48b57f659a698031f58a1fdd4d249b9bd0c27e7b;hp=e9451a61ba732f5c2faf8dbe7966901e01a5debf;hb=f32de5188d6ec5a3b70ced18669e27e0b250bf50;hpb=5a1c08bd237c780e4ccd6cdac0fadbf215b3cde6 diff --git a/lib/devices/record.c b/lib/devices/record.c index e9451a6..48b57f6 100644 --- a/lib/devices/record.c +++ b/lib/devices/record.c @@ -21,19 +21,63 @@ #include #include #include +#include "../../config.h" +#ifdef HAVE_UNISTD_H #include +#endif #include +#ifdef HAVE_IO_H +#include +#endif +#include +#include +#include #include "../gfxdevice.h" #include "../gfxtools.h" +#include "../gfxfont.h" #include "../types.h" #include "../bitio.h" +#include "../log.h" +#include "../os.h" +#include "../png.h" +#ifdef HAVE_FASTLZ +#include "../fastlz.h" +#endif +#include "record.h" + +//#define STATS +#define COMPRESS_IMAGES +//#define FILTER_IMAGES + +typedef struct _state { + char*last_string[16]; + gfxcolor_t last_color[16]; + gfxmatrix_t last_matrix[16]; + +#ifdef STATS + int size_matrices; + int size_positions; + int size_images; + int size_lines; + int size_colors; + int size_fonts; + int size_chars; +#endif +} state_t; typedef struct _internal { gfxfontlist_t* fontlist; + state_t state; + writer_t w; + int cliplevel; + char use_tempfile; + char*filename; } internal_t; typedef struct _internal_result { + char use_tempfile; + char*filename; void*data; int length; } internal_result_t; @@ -53,64 +97,72 @@ typedef struct _internal_result { #define OP_ENDPAGE 0x0c #define OP_FINISH 0x0d -#define OP_MOVETO 0x0e -#define OP_LINETO 0x0f -#define OP_SPLINETO 0x10 +#define FLAG_SAME_AS_LAST 0x10 +#define FLAG_ZERO_FONT 0x20 -int record_setparameter(struct _gfxdevice*dev, const char*key, const char*value) -{ - internal_t*i = (internal_t*)dev->internal; - writer_writeU8(&i->w, OP_SETPARAM); - writer_writeString(&i->w, key); - writer_writeString(&i->w, value); - return 1; -} +#define LINE_MOVETO 0x0e +#define LINE_LINETO 0x0f +#define LINE_SPLINETO 0x10 + +/* ----------------- reading/writing of low level primitives -------------- */ -void dumpLine(writer_t*w, gfxline_t*line) +static void dumpLine(writer_t*w, state_t*state, gfxline_t*line) { while(line) { if(line->type == gfx_moveTo) { - writer_writeU8(w, OP_MOVETO); + writer_writeU8(w, LINE_MOVETO); writer_writeDouble(w, line->x); writer_writeDouble(w, line->y); +#ifdef STATS + state->size_lines += 1+8+8; +#endif } else if(line->type == gfx_lineTo) { - writer_writeU8(w, OP_LINETO); + writer_writeU8(w, LINE_LINETO); writer_writeDouble(w, line->x); writer_writeDouble(w, line->y); +#ifdef STATS + state->size_lines += 1+8+8; +#endif } else if(line->type == gfx_splineTo) { - writer_writeU8(w, OP_SPLINETO); + writer_writeU8(w, LINE_SPLINETO); writer_writeDouble(w, line->x); writer_writeDouble(w, line->y); writer_writeDouble(w, line->sx); writer_writeDouble(w, line->sy); +#ifdef STATS + state->size_lines += 1+8+8+8+8; +#endif } line = line->next; } writer_writeU8(w, OP_END); +#ifdef STATS + state->size_lines += 1; +#endif } -gfxline_t* readLine(reader_t*r) +static gfxline_t* readLine(reader_t*r, state_t*s) { gfxline_t*start = 0, *pos = 0; while(1) { unsigned char op = reader_readU8(r); if(op == OP_END) break; - gfxline_t*line = rfx_calloc(sizeof(gfxline_t)); + gfxline_t*line = (gfxline_t*)rfx_calloc(sizeof(gfxline_t)); if(!start) { start = pos = line; } else { pos->next = line; pos = line; } - if(op == OP_MOVETO) { + if(op == LINE_MOVETO) { line->type = gfx_moveTo; line->x = reader_readDouble(r); line->y = reader_readDouble(r); - } else if(op == OP_LINETO) { + } else if(op == LINE_LINETO) { line->type = gfx_lineTo; line->x = reader_readDouble(r); line->y = reader_readDouble(r); - } else if(op == OP_SPLINETO) { + } else if(op == LINE_SPLINETO) { line->type = gfx_splineTo; line->x = reader_readDouble(r); line->y = reader_readDouble(r); @@ -120,16 +172,114 @@ gfxline_t* readLine(reader_t*r) } return start; } -gfximage_t readImage(reader_t*r) + +static void dumpImage(writer_t*w, state_t*state, gfximage_t*img) +{ + int oldpos = w->pos; + writer_writeU16(w, img->width); + writer_writeU16(w, img->height); +#ifdef COMPRESS_IMAGES + //35.3% images (2027305 bytes) (with filter, Z_BEST_COMPRESSION) + //39.9% images (2458904 bytes) (with filter, Z_BEST_SPEED) + //45.2% images (3055340 bytes) (without filter) + //45.9% images (3149247 bytes) (without filter, 5) + //48.0% images (3480495 bytes) (with filter, fastlz) + //48.0% images (3488650 bytes) (without filter, Z_BEST_SPEED) + //55.3% images (4665889 bytes) (without filter, fastlz level 2) + //55.6% images (4726334 bytes) (without filter, fastlz level 1) + //83.0% images (18091804 bytes) (no compression) + + gfxcolor_t*image; +#ifdef FILTER_IMAGES + unsigned char*filter = malloc(img->height); + int y; + image = malloc(img->width*img->height*sizeof(gfxcolor_t)); + for(y=0;yheight;y++) { + filter[y] = png_apply_filter_32( + (void*)&image[y*img->width], + (void*)&img->data[y*img->width], img->width, y); + } +#else + image = img->data; +#endif + int size = img->width*img->height; + uLongf compressdata_size = compressBound(size*sizeof(gfxcolor_t)); + void*compressdata = malloc(compressdata_size); + +#ifdef HAVE_FASTLZ + compressdata_size = fastlz_compress_level(2, (void*)image, size*sizeof(gfxcolor_t), compressdata); +#else + compress2(compressdata, &compressdata_size, (void*)image, sizeof(gfxcolor_t)*size, Z_BEST_SPEED); +#endif + + writer_writeU32(w, compressdata_size); +#ifdef FILTER_IMAGES + w->write(w, filter, img->height); + free(filter); + free(image); +#endif + w->write(w, compressdata, compressdata_size); +#else + w->write(w, img->data, img->width*img->height*sizeof(gfxcolor_t)); +#endif +#ifdef STATS + state->size_images += w->pos - oldpos; +#endif +} +static gfximage_t readImage(reader_t*r, state_t*state) { gfximage_t img; img.width = reader_readU16(r); img.height = reader_readU16(r); - img.data = rfx_alloc(img.width*img.height*4); - r->read(r, img.data, img.width*img.height*4); + uLongf size = img.width*img.height*sizeof(gfxcolor_t); + img.data = malloc(size); +#ifdef COMPRESS_IMAGES + uLongf compressdata_size = reader_readU32(r); + void*compressdata = malloc(compressdata_size); +# ifdef FILTER_IMAGES + unsigned char*filter = malloc(img.height); + r->read(r, filter, img.height); +# endif + r->read(r, compressdata, compressdata_size); + +# ifdef HAVE_FASTLZ + fastlz_decompress(compressdata, compressdata_size, (void*)img.data, size); +# else + uncompress((void*)img.data, &size, compressdata, compressdata_size); +# endif + +# ifdef FILTER_IMAGES + int y; + unsigned char*line = malloc(img.width*sizeof(gfxcolor_t)); + for(y=0;yread(r, img.data, size); +#endif return img; } -gfxmatrix_t readMatrix(reader_t*r) + +static void dumpMatrix(writer_t*w, state_t*state, gfxmatrix_t*matrix) +{ + writer_writeDouble(w, matrix->m00); + writer_writeDouble(w, matrix->m01); + writer_writeDouble(w, matrix->m10); + writer_writeDouble(w, matrix->m11); + writer_writeDouble(w, matrix->tx); + writer_writeDouble(w, matrix->ty); +#ifdef STATS + state->size_matrices += 6*8; +#endif +} +static gfxmatrix_t readMatrix(reader_t*r, state_t*state) { gfxmatrix_t matrix; matrix.m00 = reader_readDouble(r); @@ -140,7 +290,31 @@ gfxmatrix_t readMatrix(reader_t*r) matrix.ty = reader_readDouble(r); return matrix; } -gfxcolor_t readColor(reader_t*r) +static void dumpXY(writer_t*w, state_t*state, gfxmatrix_t*matrix) +{ + writer_writeDouble(w, matrix->tx); + writer_writeDouble(w, matrix->ty); +#ifdef STATS + state->size_positions += 2*8; +#endif +} +static void readXY(reader_t*r, state_t*state, gfxmatrix_t*m) +{ + m->tx = reader_readDouble(r); + m->ty = reader_readDouble(r); +} + +static void dumpColor(writer_t*w, state_t*state, gfxcolor_t*color) +{ + writer_writeU8(w, color->r); + writer_writeU8(w, color->g); + writer_writeU8(w, color->b); + writer_writeU8(w, color->a); +#ifdef STATS + state->size_colors += 4; +#endif +} +static gfxcolor_t readColor(reader_t*r, state_t*state) { gfxcolor_t col; col.r = reader_readU8(r); @@ -149,71 +323,38 @@ gfxcolor_t readColor(reader_t*r) col.a = reader_readU8(r); return col; } -gfxgradient_t* readGradient(reader_t*r) + +static void dumpGradient(writer_t*w, state_t*state, gfxgradient_t*gradient) +{ + while(gradient) { + writer_writeU8(w, 1); + dumpColor(w, state, &gradient->color); + writer_writeFloat(w, gradient->pos); + gradient = gradient->next; + } + writer_writeU8(w, 0); +} +static gfxgradient_t* readGradient(reader_t*r, state_t*state) { gfxgradient_t*start = 0, *pos = 0; while(1) { U8 op = reader_readU8(r); if(!op) break; - gfxgradient_t*g = rfx_calloc(sizeof(gfxgradient_t)); + gfxgradient_t*g = (gfxgradient_t*)rfx_calloc(sizeof(gfxgradient_t)); if(!start) { start = pos = g; } else { pos->next = g; pos = g; } - g->color = readColor(r); + g->color = readColor(r, state); g->pos = reader_readFloat(r); } return start; } -gfxcxform_t* readCXForm(reader_t*r) -{ - U8 type = reader_readU8(r); - if(!type) - return 0; - gfxcxform_t* c = rfx_calloc(sizeof(gfxcxform_t)); - c->rr = reader_readFloat(r); c->rg = reader_readFloat(r); c->rb = reader_readFloat(r); c->ra = reader_readFloat(r); - c->gr = reader_readFloat(r); c->gg = reader_readFloat(r); c->gb = reader_readFloat(r); c->ga = reader_readFloat(r); - c->br = reader_readFloat(r); c->bg = reader_readFloat(r); c->bb = reader_readFloat(r); c->ba = reader_readFloat(r); - c->ar = reader_readFloat(r); c->ag = reader_readFloat(r); c->ab = reader_readFloat(r); c->aa = reader_readFloat(r); - return c; -} -void dumpColor(writer_t*w, gfxcolor_t*color) -{ - writer_writeU8(w, color->r); - writer_writeU8(w, color->g); - writer_writeU8(w, color->b); - writer_writeU8(w, color->a); -} -void dumpMatrix(writer_t*w, gfxmatrix_t*matrix) -{ - writer_writeDouble(w, matrix->m00); - writer_writeDouble(w, matrix->m01); - writer_writeDouble(w, matrix->m10); - writer_writeDouble(w, matrix->m11); - writer_writeDouble(w, matrix->tx); - writer_writeDouble(w, matrix->ty); -} -void dumpGradient(writer_t*w, gfxgradient_t*gradient) -{ - while(gradient) { - writer_writeU8(w, 1); - dumpColor(w, &gradient->color); - writer_writeFloat(w, gradient->pos); - gradient = gradient->next; - } - writer_writeU8(w, 0); -} -void dumpImage(writer_t*w, gfximage_t*image) -{ - writer_writeU16(w, image->width); - writer_writeU16(w, image->height); - w->write(w, image->data, image->width*image->height*4); -} -void dumpCXForm(writer_t*w, gfxcxform_t*c) +static void dumpCXForm(writer_t*w, state_t*state, gfxcxform_t*c) { if(!c) { writer_writeU8(w, 0); @@ -225,14 +366,33 @@ void dumpCXForm(writer_t*w, gfxcxform_t*c) writer_writeFloat(w, c->ar); writer_writeFloat(w, c->ag); writer_writeFloat(w, c->ab); writer_writeFloat(w, c->aa); } } -void dumpFont(writer_t*w, gfxfont_t*font) +static gfxcxform_t* readCXForm(reader_t*r, state_t*state) { + U8 type = reader_readU8(r); + if(!type) + return 0; + gfxcxform_t* c = (gfxcxform_t*)rfx_calloc(sizeof(gfxcxform_t)); + c->rr = reader_readFloat(r); c->rg = reader_readFloat(r); c->rb = reader_readFloat(r); c->ra = reader_readFloat(r); + c->gr = reader_readFloat(r); c->gg = reader_readFloat(r); c->gb = reader_readFloat(r); c->ga = reader_readFloat(r); + c->br = reader_readFloat(r); c->bg = reader_readFloat(r); c->bb = reader_readFloat(r); c->ba = reader_readFloat(r); + c->ar = reader_readFloat(r); c->ag = reader_readFloat(r); c->ab = reader_readFloat(r); c->aa = reader_readFloat(r); + return c; +} + +static void dumpFont(writer_t*w, state_t*state, gfxfont_t*font) +{ + int oldpos = w->pos; +#ifdef STATS + int old_size_lines = state->size_lines; +#endif writer_writeString(w, font->id); writer_writeU32(w, font->num_glyphs); writer_writeU32(w, font->max_unicode); + writer_writeDouble(w, font->ascent); + writer_writeDouble(w, font->descent); int t; for(t=0;tnum_glyphs;t++) { - dumpLine(w, font->glyphs[t].line); + dumpLine(w, state, font->glyphs[t].line); writer_writeDouble(w, font->glyphs[t].advance); writer_writeU32(w, font->glyphs[t].unicode); if(font->glyphs[t].name) { @@ -244,255 +404,473 @@ void dumpFont(writer_t*w, gfxfont_t*font) for(t=0;tmax_unicode;t++) { writer_writeU32(w, font->unicode2glyph[t]); } + writer_writeU32(w, font->kerning_size); + for(t=0;tkerning_size;t++) { + writer_writeU32(w, font->kerning[t].c1); + writer_writeU32(w, font->kerning[t].c2); + writer_writeU32(w, font->kerning[t].advance); + } +#ifdef STATS + state->size_lines = old_size_lines; + state->size_fonts += w->pos - oldpos; +#endif } -gfxfont_t*readFont(reader_t*r) +static gfxfont_t*readFont(reader_t*r, state_t*state) { - gfxfont_t* font = rfx_calloc(sizeof(gfxfont_t)); + gfxfont_t* font = (gfxfont_t*)rfx_calloc(sizeof(gfxfont_t)); font->id = reader_readString(r); font->num_glyphs = reader_readU32(r); font->max_unicode = reader_readU32(r); - font->glyphs = rfx_calloc(sizeof(gfxglyph_t)*font->num_glyphs); - font->unicode2glyph = rfx_calloc(sizeof(font->unicode2glyph[0])*font->max_unicode); + font->ascent = reader_readDouble(r); + font->descent = reader_readDouble(r); + font->glyphs = (gfxglyph_t*)rfx_calloc(sizeof(gfxglyph_t)*font->num_glyphs); + font->unicode2glyph = (int*)rfx_calloc(sizeof(font->unicode2glyph[0])*font->max_unicode); int t; for(t=0;tnum_glyphs;t++) { - font->glyphs[t].line = readLine(r); + font->glyphs[t].line = readLine(r, state); font->glyphs[t].advance = reader_readDouble(r); font->glyphs[t].unicode = reader_readU32(r); font->glyphs[t].name = reader_readString(r); if(!font->glyphs[t].name[0]) { - free(font->glyphs[t].name); + free((void*)(font->glyphs[t].name)); font->glyphs[t].name = 0; } } for(t=0;tmax_unicode;t++) { font->unicode2glyph[t] = reader_readU32(r); } + font->kerning_size = reader_readU32(r); + if(font->kerning_size) { + font->kerning = malloc(sizeof(gfxkerning_t)*font->kerning_size); + for(t=0;tkerning_size;t++) { + font->kerning[t].c1 = reader_readU32(r); + font->kerning[t].c2 = reader_readU32(r); + font->kerning[t].advance = reader_readU32(r); + } + } return font; } -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) +/* ----------------- reading/writing of primitives with caching -------------- */ + +void state_clear(state_t*state) +{ + int t; + for(t=0;tlast_string)/sizeof(state->last_string[0]);t++) { + if(state->last_string[t]) { + free(state->last_string[t]); + state->last_string[t] = 0; + } + } +} + +static char* read_string(reader_t*r, state_t*state, U8 id, U8 flags) +{ + assert(id>=0 && id<16); + if(flags&FLAG_SAME_AS_LAST) { + assert(state->last_string[id]); + return strdup(state->last_string[id]); + } + char*s = reader_readString(r); + if(state->last_string[id]) { + free(state->last_string[id]); + } + state->last_string[id] = strdup(s); + return s; +} +static gfxcolor_t read_color(reader_t*r, state_t*state, U8 id, U8 flags) +{ + assert(id>=0 && id<16); + if(flags&FLAG_SAME_AS_LAST) + return state->last_color[id]; + gfxcolor_t c = readColor(r, state); + state->last_color[id] = c; + return c; +} +static gfxmatrix_t read_matrix(reader_t*r, state_t*state, U8 id, U8 flags) +{ + assert(id>=0 && id<16); + if(flags&FLAG_SAME_AS_LAST) { + gfxmatrix_t m = state->last_matrix[id]; + readXY(r, state, &m); + return m; + } + gfxmatrix_t m = readMatrix(r, state); + state->last_matrix[id] = m; + return m; +} + +/* --------------------------- record device operations ---------------------- */ + +static int record_setparameter(struct _gfxdevice*dev, const char*key, const char*value) +{ + internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x SETPARAM %s %s\n", dev, key, value); + writer_writeU8(&i->w, OP_SETPARAM); + writer_writeString(&i->w, key); + writer_writeString(&i->w, value); + return 1; +} + +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) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x STROKE\n", dev); writer_writeU8(&i->w, OP_STROKE); writer_writeDouble(&i->w, width); writer_writeDouble(&i->w, miterLimit); - dumpColor(&i->w, color); + dumpColor(&i->w, &i->state, color); writer_writeU8(&i->w, cap_style); writer_writeU8(&i->w, joint_style); - dumpLine(&i->w, line); + dumpLine(&i->w, &i->state, line); } -void record_startclip(struct _gfxdevice*dev, gfxline_t*line) +static void record_startclip(struct _gfxdevice*dev, gfxline_t*line) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x STARTCLIP\n", dev); writer_writeU8(&i->w, OP_STARTCLIP); - dumpLine(&i->w, line); + dumpLine(&i->w, &i->state, line); + i->cliplevel++; } -void record_endclip(struct _gfxdevice*dev) +static void record_endclip(struct _gfxdevice*dev) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x ENDCLIP\n", dev); writer_writeU8(&i->w, OP_ENDCLIP); + i->cliplevel--; + if(i->cliplevel<0) { + msg(" record: endclip() without startclip()"); + } } -void record_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color) +static void record_fill(struct _gfxdevice*dev, gfxline_t*line, gfxcolor_t*color) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x FILL\n", dev); writer_writeU8(&i->w, OP_FILL); - dumpColor(&i->w, color); - dumpLine(&i->w, line); + dumpColor(&i->w, &i->state, color); + dumpLine(&i->w, &i->state, line); } -void record_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) +static void record_fillbitmap(struct _gfxdevice*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x FILLBITMAP\n", dev); writer_writeU8(&i->w, OP_FILLBITMAP); - dumpImage(&i->w, img); - dumpMatrix(&i->w, matrix); - dumpLine(&i->w, line); - dumpCXForm(&i->w, cxform); + dumpImage(&i->w, &i->state, img); + dumpMatrix(&i->w, &i->state, matrix); + dumpLine(&i->w, &i->state, line); + dumpCXForm(&i->w, &i->state, cxform); } -void record_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) +static void record_fillgradient(struct _gfxdevice*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x FILLGRADIENT %08x\n", dev, gradient); writer_writeU8(&i->w, OP_FILLGRADIENT); writer_writeU8(&i->w, type); - dumpGradient(&i->w, gradient); - dumpMatrix(&i->w, matrix); - dumpLine(&i->w, line); + dumpGradient(&i->w, &i->state, gradient); + dumpMatrix(&i->w, &i->state, matrix); + dumpLine(&i->w, &i->state, line); } -void record_addfont(struct _gfxdevice*dev, gfxfont_t*font) +static void record_addfont(struct _gfxdevice*dev, gfxfont_t*font) { internal_t*i = (internal_t*)dev->internal; - writer_writeU8(&i->w, OP_ADDFONT); - dumpFont(&i->w, font); - i->fontlist = gfxfontlist_addfont(i->fontlist, font); + msg(" record: %08x ADDFONT %s\n", dev, font->id); + if(font && !gfxfontlist_hasfont(i->fontlist, font)) { + writer_writeU8(&i->w, OP_ADDFONT); + dumpFont(&i->w, &i->state, font); + i->fontlist = gfxfontlist_addfont(i->fontlist, font); + } } -void record_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) +static void record_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) { internal_t*i = (internal_t*)dev->internal; - if(!gfxfontlist_hasfont(i->fontlist, font)) + if(font && !gfxfontlist_hasfont(i->fontlist, font)) { record_addfont(dev, font); + } + + msg(" record: %08x DRAWCHAR %d\n", glyphnr, dev); + const char*font_id = (font&&font->id)?font->id:"*NULL*"; + + gfxmatrix_t*l = &i->state.last_matrix[OP_DRAWCHAR]; + + U8 flags = 0; + if(!font) + flags |= FLAG_ZERO_FONT; + + char same_font = i->state.last_string[OP_DRAWCHAR] && !strcmp(i->state.last_string[OP_DRAWCHAR], font_id); + char same_matrix = (l->m00 == matrix->m00) && (l->m01 == matrix->m01) && (l->m10 == matrix->m10) && (l->m11 == matrix->m11); + char same_color = !memcmp(color, &i->state.last_color[OP_DRAWCHAR], sizeof(gfxcolor_t)); - writer_writeU8(&i->w, OP_DRAWCHAR); - writer_writeString(&i->w, font->id); + /* FIXME + if(same_font && same_matrix && same_color) + flags |= FLAG_SAME_AS_LAST; + */ + + writer_writeU8(&i->w, OP_DRAWCHAR|flags); writer_writeU32(&i->w, glyphnr); - dumpColor(&i->w, color); - dumpMatrix(&i->w, matrix); +#ifdef STATS + i->state.size_chars += 5; +#endif + + if(!(flags&FLAG_SAME_AS_LAST)) { + if(!(flags&FLAG_ZERO_FONT)) + writer_writeString(&i->w, font_id); + dumpColor(&i->w, &i->state, color); + dumpMatrix(&i->w, &i->state, matrix); + + if(i->state.last_string[OP_DRAWCHAR]) + free(i->state.last_string[OP_DRAWCHAR]); + i->state.last_string[OP_DRAWCHAR] = strdup(font_id); + + i->state.last_color[OP_DRAWCHAR] = *color; + i->state.last_matrix[OP_DRAWCHAR] = *matrix; + } else { + dumpXY(&i->w, &i->state, matrix); + } } -void record_startpage(struct _gfxdevice*dev, int width, int height) +static void record_startpage(struct _gfxdevice*dev, int width, int height) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x STARTPAGE\n", dev); writer_writeU8(&i->w, OP_STARTPAGE); writer_writeU16(&i->w, width); writer_writeU16(&i->w, height); } -void record_endpage(struct _gfxdevice*dev) +static void record_endpage(struct _gfxdevice*dev) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x ENDPAGE\n", dev); writer_writeU8(&i->w, OP_ENDPAGE); } -void record_drawlink(struct _gfxdevice*dev, gfxline_t*line, char*action) +static void record_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x DRAWLINK\n", dev); writer_writeU8(&i->w, OP_DRAWLINK); - dumpLine(&i->w, line); + dumpLine(&i->w, &i->state, line); writer_writeString(&i->w, action); } -void gfxresult_record_replay(gfxresult_t*result, gfxdevice_t*device) +/* ------------------------------- replaying --------------------------------- */ + +static void replay(struct _gfxdevice*dev, gfxdevice_t*out, reader_t*r, gfxfontlist_t**fontlist) { - internal_result_t*i = (internal_result_t*)result->internal; - reader_t r2; - reader_t*r = &r2; - reader_init_memreader(r, i->data, i->length); - gfxfontlist_t* fontlist = gfxfontlist_create(); + internal_t*i = 0; + if(dev) { + i = (internal_t*)dev->internal; + } + gfxfontlist_t*_fontlist=0; + if(!fontlist) { + fontlist = &_fontlist; + } + + state_t state; + memset(&state, 0, sizeof(state)); while(1) { - unsigned char op = reader_readU8(r); + unsigned char op; + if(r->read(r, &op, 1)!=1) + break; + unsigned char flags = op&0xf0; + op&=0x0f; + switch(op) { case OP_END: - return; + goto finish; case OP_SETPARAM: { + msg(" replay: SETPARAM"); char*key; char*value; key = reader_readString(r); value = reader_readString(r); - device->setparameter(device, key, value); + out->setparameter(out, key, value); free(key); free(value); break; } case OP_STARTPAGE: { + msg(" replay: STARTPAGE"); U16 width = reader_readU16(r); U16 height = reader_readU16(r); - device->startpage(device, width, height); + out->startpage(out, width, height); break; } case OP_ENDPAGE: { + msg(" replay: ENDPAGE"); + out->endpage(out); break; } case OP_FINISH: { + msg(" replay: FINISH"); break; } case OP_STROKE: { + msg(" replay: STROKE"); double width = reader_readDouble(r); double miterlimit = reader_readDouble(r); - gfxcolor_t color = readColor(r); - gfx_capType captype = reader_readU8(r); - gfx_joinType jointtype = reader_readU8(r); - gfxline_t* line = readLine(r); - device->stroke(device, line, width, &color, captype, jointtype,miterlimit); + gfxcolor_t color = readColor(r, &state); + gfx_capType captype; + int v = reader_readU8(r); + switch (v) { + case 0: captype = gfx_capButt; break; + case 1: captype = gfx_capRound; break; + case 2: captype = gfx_capSquare; break; + } + gfx_joinType jointtype; + v = reader_readU8(r); + switch (v) { + case 0: jointtype = gfx_joinMiter; break; + case 1: jointtype = gfx_joinRound; break; + case 2: jointtype = gfx_joinBevel; break; + } + gfxline_t* line = readLine(r, &state); + out->stroke(out, line, width, &color, captype, jointtype,miterlimit); gfxline_free(line); break; } case OP_STARTCLIP: { - gfxline_t* line = readLine(r); - device->startclip(device, line); + msg(" replay: STARTCLIP"); + gfxline_t* line = readLine(r, &state); + out->startclip(out, line); gfxline_free(line); break; } case OP_ENDCLIP: { - device->endclip(device); + msg(" replay: ENDCLIP"); + out->endclip(out); break; } case OP_FILL: { - gfxcolor_t color = readColor(r); - gfxline_t* line = readLine(r); - device->fill(device, line, &color); + msg(" replay: FILL"); + gfxcolor_t color = readColor(r, &state); + gfxline_t* line = readLine(r, &state); + out->fill(out, line, &color); gfxline_free(line); break; } case OP_FILLBITMAP: { - gfximage_t img = readImage(r); - gfxmatrix_t matrix = readMatrix(r); - gfxline_t* line = readLine(r); - gfxcxform_t* cxform = readCXForm(r); - device->fillbitmap(device, line, &img, &matrix, cxform); + msg(" replay: FILLBITMAP"); + gfximage_t img = readImage(r, &state); + gfxmatrix_t matrix = readMatrix(r, &state); + gfxline_t* line = readLine(r, &state); + gfxcxform_t* cxform = readCXForm(r, &state); + out->fillbitmap(out, line, &img, &matrix, cxform); + gfxline_free(line); if(cxform) free(cxform); + free(img.data);img.data=0; break; } case OP_FILLGRADIENT: { - gfxgradienttype_t type = reader_readU8(r); - gfxgradient_t*gradient = readGradient(r); - gfxmatrix_t matrix = readMatrix(r); - gfxline_t* line = readLine(r); - device->fillgradient(device, line, gradient, type, &matrix); + msg(" replay: FILLGRADIENT"); + gfxgradienttype_t type; + int v = reader_readU8(r); + switch (v) { + case 0: + type = gfxgradient_radial; break; + case 1: + type = gfxgradient_linear; break; + } + gfxgradient_t*gradient = readGradient(r, &state); + gfxmatrix_t matrix = readMatrix(r, &state); + gfxline_t* line = readLine(r, &state); + out->fillgradient(out, line, gradient, type, &matrix); break; } case OP_DRAWLINK: { - gfxline_t* line = readLine(r); + msg(" replay: DRAWLINK"); + gfxline_t* line = readLine(r, &state); char* s = reader_readString(r); - device->drawlink(device,line,s); + out->drawlink(out,line,s); gfxline_free(line); free(s); break; } case OP_ADDFONT: { - gfxfont_t*font = readFont(r); - fontlist = gfxfontlist_addfont(fontlist, font); - device->addfont(device, font); + msg(" replay: ADDFONT out=%08x(%s)", out, out->name); + gfxfont_t*font = readFont(r, &state); + if(!gfxfontlist_hasfont(*fontlist, font)) { + *fontlist = gfxfontlist_addfont(*fontlist, font); + out->addfont(out, font); + } else { + gfxfont_free(font); + } break; } case OP_DRAWCHAR: { - char* id = reader_readString(r); - gfxfont_t*font = gfxfontlist_findfont(fontlist, id); U32 glyph = reader_readU32(r); - gfxcolor_t color = readColor(r); - gfxmatrix_t matrix = readMatrix(r); - device->drawchar(device, font, glyph, &color, &matrix); - free(id); + gfxmatrix_t m = {1,0,0, 0,1,0}; + char* id = 0; + if(!(flags&FLAG_ZERO_FONT)) + id = read_string(r, &state, op, flags); + gfxcolor_t color = read_color(r, &state, op, flags); + gfxmatrix_t matrix = read_matrix(r, &state, op, flags); + + gfxfont_t*font = id?gfxfontlist_findfont(*fontlist, id):0; + if(i && !font) { + font = gfxfontlist_findfont(i->fontlist, id); + } + msg(" replay: DRAWCHAR font=%s glyph=%d", id, glyph); + out->drawchar(out, font, glyph, &color, &matrix); + if(id) + free(id); break; } } } +finish: + state_clear(&state); + r->dealloc(r); + if(_fontlist) + gfxfontlist_free(_fontlist, 0); +} +void gfxresult_record_replay(gfxresult_t*result, gfxdevice_t*device, gfxfontlist_t**fontlist) +{ + internal_result_t*i = (internal_result_t*)result->internal; + + reader_t r; + if(i->use_tempfile) { + reader_init_filereader2(&r, i->filename); + } else { + reader_init_memreader(&r, i->data, i->length); + } + + replay(0, device, &r, fontlist); } -void record_result_write(gfxresult_t*r, int filedesc) +static void record_result_write(gfxresult_t*r, int filedesc) { internal_result_t*i = (internal_result_t*)r->internal; - write(filedesc, i->data, i->length); + if(i->data) { + write(filedesc, i->data, i->length); + } } -int record_result_save(gfxresult_t*r, char*filename) +static int record_result_save(gfxresult_t*r, const char*filename) { internal_result_t*i = (internal_result_t*)r->internal; - FILE*fi = fopen(filename, "wb"); - if(!fi) { - fprintf(stderr, "Couldn't open file %s for writing\n", filename); - return -1; + if(i->use_tempfile) { + move_file(i->filename, filename); + } else { + FILE*fi = fopen(filename, "wb"); + if(!fi) { + fprintf(stderr, "Couldn't open file %s for writing\n", filename); + return -1; + } + fwrite(i->data, i->length, 1, fi); + fclose(fi); } - fwrite(i->data, i->length, 1, fi); - fclose(fi); return 0; } -void*record_result_get(gfxresult_t*r, char*name) +static void*record_result_get(gfxresult_t*r, const char*name) { internal_result_t*i = (internal_result_t*)r->internal; if(!strcmp(name, "data")) { @@ -502,24 +880,104 @@ void*record_result_get(gfxresult_t*r, char*name) } return 0; } -void record_result_destroy(gfxresult_t*r) +static void record_result_destroy(gfxresult_t*r) { internal_result_t*i = (internal_result_t*)r->internal; - free(i->data);i->data = 0; + if(i->data) { + free(i->data);i->data = 0; + } + if(i->filename) { + unlink(i->filename); + free(i->filename); + } free(r->internal);r->internal = 0; free(r); } +static unsigned char printable(unsigned char a) +{ + if(a<32 || a==127) return '.'; + else return a; +} + +static void hexdumpMem(unsigned char*data, int len) +{ + int t; + char ascii[32]; + for(t=0;tinternal; + if(out) { + if(!i->use_tempfile) { + int len=0; + void*data = writer_growmemwrite_memptr(&i->w, &len); + reader_t r; + reader_init_memreader(&r, data, len); + replay(dev, out, &r, fontlist); + writer_growmemwrite_reset(&i->w); + } else { + msg(" Flushing not supported for file based record device"); + exit(1); + } + } +} -gfxresult_t* record_finish(struct _gfxdevice*dev) +static gfxresult_t* record_finish(struct _gfxdevice*dev) { internal_t*i = (internal_t*)dev->internal; + msg(" record: %08x END", dev); + + if(i->cliplevel) { + msg(" Warning: unclosed cliplevels"); + } + + state_clear(&i->state); + +#ifdef STATS + int total = i->w.pos; + if(total && i->use_tempfile) { + state_t*s = &i->state; + msg(" record device finished. stats:"); + msg(" %4.1f%% matrices (%d bytes)", s->size_matrices*100.0/total, s->size_matrices); + msg(" %4.1f%% positions (%d bytes)", s->size_positions*100.0/total, s->size_positions); + msg(" %4.1f%% colors (%d bytes)", s->size_colors*100.0/total, s->size_colors); + msg(" %4.1f%% lines (%d bytes)", s->size_lines*100.0/total, s->size_lines); + msg(" %4.1f%% fonts (%d bytes)", s->size_fonts*100.0/total, s->size_fonts); + msg(" %4.1f%% images (%d bytes)", s->size_images*100.0/total, s->size_images); + msg(" %4.1f%% characters (%d bytes)", s->size_chars*100.0/total, s->size_chars); + msg(" total: %d bytes", total); + } +#endif writer_writeU8(&i->w, OP_END); + + gfxfontlist_free(i->fontlist, 0); internal_result_t*ir = (internal_result_t*)rfx_calloc(sizeof(gfxresult_t)); - ir->data = writer_growmemwrite_getmem(&i->w); - ir->length = i->w.pos; + + ir->use_tempfile = i->use_tempfile; + if(i->use_tempfile) { + ir->filename = i->filename; + } else { + ir->data = writer_growmemwrite_getmem(&i->w); + ir->length = i->w.pos; + } + i->w.finish(&i->w); gfxresult_t*result= (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t)); result->save = record_result_save; @@ -531,7 +989,8 @@ gfxresult_t* record_finish(struct _gfxdevice*dev) return result; } -void gfxdevice_record_init(gfxdevice_t*dev) + +void gfxdevice_record_init(gfxdevice_t*dev, char use_tempfile) { internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t)); memset(dev, 0, sizeof(gfxdevice_t)); @@ -539,9 +998,17 @@ void gfxdevice_record_init(gfxdevice_t*dev) dev->name = "record"; dev->internal = i; - - writer_init_growingmemwriter(&i->w, 1048576); + + i->use_tempfile = use_tempfile; + if(!use_tempfile) { + writer_init_growingmemwriter(&i->w, 1048576); + } else { + char buffer[128]; + i->filename = strdup(mktempname(buffer, "gfx")); + writer_init_filewriter2(&i->w, i->filename); + } i->fontlist = gfxfontlist_create(); + i->cliplevel = 0; dev->setparameter = record_setparameter; dev->startpage = record_startpage;