From: Matthias Kramm Date: Fri, 26 Feb 2010 02:43:16 +0000 (-0800) Subject: added two pass support and device filters to gfx library X-Git-Tag: version-0-9-1~132 X-Git-Url: http://git.asbjorn.biz/?p=swftools.git;a=commitdiff_plain;h=944d0b42a196bd412c12c6c06fd0e4f301d4a1c7 added two pass support and device filters to gfx library --- diff --git a/installer/mkarchive.c b/installer/mkarchive.c index 45b2a3d..7dab4e0 100644 --- a/installer/mkarchive.c +++ b/installer/mkarchive.c @@ -56,6 +56,10 @@ writer_t*writer_init_filewriter(char*filename) { writer_t*w = malloc(sizeof(writer_t)); FILE*fi = fopen(filename, "wb"); + if(!fi) { + perror(filename); + return 0; + } filewrite_t *mr = (filewrite_t *)malloc(sizeof(filewrite_t)); mr->fi = fi; memset(w, 0, sizeof(writer_t)); diff --git a/lib/Makefile.in b/lib/Makefile.in index bdd208d..e57e0ee 100644 --- a/lib/Makefile.in +++ b/lib/Makefile.in @@ -19,7 +19,7 @@ gfxpoly_objects = gfxpoly/active.$(O) gfxpoly/convert.$(O) gfxpoly/poly.$(O) gfx rfxswf_modules = modules/swfbits.c modules/swfaction.c modules/swfdump.c modules/swfcgi.c modules/swfbutton.c modules/swftext.c modules/swffont.c modules/swftools.c modules/swfsound.c modules/swfshape.c modules/swfobject.c modules/swfdraw.c modules/swffilter.c modules/swfrender.c h.263/swfvideo.c modules/swfalignzones.c base_objects=q.$(O) utf8.$(O) png.$(O) jpeg.$(O) wav.$(O) mp3.$(O) os.$(O) bitio.$(O) log.$(O) mem.$(O) MD5.$(O) xml.$(O) ttf.$(O) -gfx_objects=gfximage.$(O) gfxtools.$(O) gfxfont.$(O) devices/dummy.$(O) devices/file.$(O) devices/render.$(O) devices/text.$(O) devices/record.$(O) devices/ops.$(O) devices/polyops.$(O) devices/bbox.$(O) devices/rescale.$(O) @DEVICE_OPENGL@ @DEVICE_PDF@ +gfx_objects=gfximage.$(O) gfxtools.$(O) gfxfont.$(O) gfxfilter.$(O) devices/dummy.$(O) devices/file.$(O) devices/render.$(O) devices/text.$(O) devices/record.$(O) devices/ops.$(O) devices/polyops.$(O) devices/bbox.$(O) devices/rescale.$(O) @DEVICE_OPENGL@ @DEVICE_PDF@ rfxswf_objects=modules/swfaction.$(O) modules/swfbits.$(O) modules/swfbutton.$(O) modules/swfcgi.$(O) modules/swfdraw.$(O) modules/swfdump.$(O) modules/swffilter.$(O) modules/swffont.$(O) modules/swfobject.$(O) modules/swfrender.$(O) modules/swfshape.$(O) modules/swfsound.$(O) modules/swftext.$(O) modules/swftools.$(O) modules/swfalignzones.$(O) ocr_objects=gocr/box.$(O) gocr/database.$(O) gocr/detect.$(O) gocr/job.$(O) gocr/lines.$(O) gocr/list.$(O) gocr/ocr0.$(O) gocr/ocr0n.$(O) gocr/ocr1.$(O) gocr/otsu.$(O) gocr/output.$(O) gocr/pgm2asc.$(O) gocr/pixel.$(O) gocr/progress.$(O) gocr/remove.$(O) gocr/unicode.$(O) @@ -95,6 +95,8 @@ gfxtools.$(O): gfxtools.c gfxtools.h $(top_builddir)/config.h $(C) gfxtools.c -o $@ gfxfont.$(O): gfxfont.c gfxfont.h ttf.h $(top_builddir)/config.h $(C) gfxfont.c -o $@ +gfxfilter.$(O): gfxfilter.c gfxfilter.h ttf.h $(top_builddir)/config.h + $(C) gfxfilter.c -o $@ gfxwindow.$(O): gfxwindow_win32.c gfxwindow_unix.c gfxwindow.c gfxwindow.h $(C) gfxwindow.c -o $@ diff --git a/lib/devices/record.c b/lib/devices/record.c index cf04db6..ae493ee 100644 --- a/lib/devices/record.c +++ b/lib/devices/record.c @@ -35,15 +35,20 @@ #include "../types.h" #include "../bitio.h" #include "../log.h" +#include "../os.h" #include "record.h" typedef struct _internal { gfxfontlist_t* fontlist; 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; @@ -418,20 +423,20 @@ static void record_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*ac writer_writeString(&i->w, action); } -static void replay(struct _gfxdevice*dev, gfxdevice_t*out, void*data, int length) +static void replay(struct _gfxdevice*dev, gfxdevice_t*out, reader_t*r) { internal_t*i = 0; if(dev) { i = (internal_t*)dev->internal; } - reader_t r2; - reader_t*r = &r2; - reader_init_memreader(r, data, length); gfxfontlist_t* fontlist = gfxfontlist_create(); - while(r->pos < length) { - unsigned char op = reader_readU8(r); + while(1) { + unsigned char op; + if(r->read(r, &op, 1)!=1) + break; + switch(op) { case OP_END: goto finish; @@ -577,24 +582,38 @@ finish: void gfxresult_record_replay(gfxresult_t*result, gfxdevice_t*device) { internal_result_t*i = (internal_result_t*)result->internal; - replay(0, device, i->data, i->length); + + reader_t r; + if(i->filename) { + reader_init_filereader2(&r, i->filename); + } else { + reader_init_memreader(&r, i->data, i->length); + } + + replay(0, device, &r); } 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); + } } 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; } static void*record_result_get(gfxresult_t*r, const char*name) @@ -613,6 +632,9 @@ static void record_result_destroy(gfxresult_t*r) if(i->data) { free(i->data);i->data = 0; } + if(i->filename) { + free(i->filename); + } free(r->internal);r->internal = 0; free(r); } @@ -646,11 +668,17 @@ void gfxdevice_record_flush(gfxdevice_t*dev, gfxdevice_t*out) { internal_t*i = (internal_t*)dev->internal; if(out) { - int len=0; - void*data = writer_growmemwrite_memptr(&i->w, &len); - replay(dev, out, data, len); + 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); + writer_growmemwrite_reset(&i->w); + } else { + msg(" Flushing not supported for file based record device"); + } } - writer_growmemwrite_reset(&i->w); } static gfxresult_t* record_finish(struct _gfxdevice*dev) @@ -667,8 +695,14 @@ static gfxresult_t* record_finish(struct _gfxdevice*dev) 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->data = writer_growmemwrite_getmem(&i->w); + ir->length = i->w.pos; + } else { + ir->filename = i->filename; + } i->w.finish(&i->w); gfxresult_t*result= (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t)); @@ -681,7 +715,8 @@ static 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)); @@ -689,8 +724,15 @@ 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)); + writer_init_filewriter2(&i->w, i->filename); + } i->fontlist = gfxfontlist_create(); i->cliplevel = 0; diff --git a/lib/devices/record.h b/lib/devices/record.h index 651de5c..34fe1e4 100644 --- a/lib/devices/record.h +++ b/lib/devices/record.h @@ -29,7 +29,9 @@ extern "C" { #endif -void gfxdevice_record_init(gfxdevice_t*); +void gfxdevice_record_init(gfxdevice_t*, char use_tempfile); + +gfxdevice_t* gfxdevice_record_new(char*filename); void gfxdevice_record_flush(gfxdevice_t*, gfxdevice_t*); diff --git a/lib/gfxfilter.c b/lib/gfxfilter.c new file mode 100644 index 0000000..57d6180 --- /dev/null +++ b/lib/gfxfilter.c @@ -0,0 +1,301 @@ +#include +#include +#include +#include "mem.h" +#include "gfxfilter.h" +#include "devices/record.h" + +typedef struct _internal { + gfxfilter_t*filter; + gfxdevice_t*out; + gfxdevice_t*final_out; + + /* for two pass filters: */ + int pass; + int num_passes; + gfxdevice_t record; + gfxtwopassfilter_t*twopass; +} internal_t; + +static int filter_setparameter(gfxdevice_t*dev, const char*key, const char*value) +{ + internal_t*i = (internal_t*)dev->internal; + return i->filter->setparameter(i->filter, key, value, i->out); +} +static void filter_startpage(gfxdevice_t*dev, int width, int height) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->startpage(i->filter, width, height, i->out); +} +static void filter_startclip(gfxdevice_t*dev, gfxline_t*line) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->startclip(i->filter, line, i->out); +} +static void filter_endclip(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->endclip(i->filter, i->out); +} +static void filter_stroke(gfxdevice_t*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; + i->filter->stroke(i->filter, line, width, color, cap_style, joint_style, miterLimit, i->out); +} +static void filter_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->fill(i->filter, line, color, i->out); +} +static void filter_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->fillbitmap(i->filter, line, img, matrix, cxform, i->out); +} +static void filter_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->fillgradient(i->filter, line, gradient, type, matrix, i->out); +} +static void filter_addfont(gfxdevice_t*dev, gfxfont_t*font) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->addfont(i->filter, font, i->out); +} +static void filter_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->drawchar(i->filter, font, glyphnr, color, matrix, i->out); +} +static void filter_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->drawlink(i->filter, line, action, i->out); +} +static void filter_endpage(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + i->filter->endpage(i->filter, i->out); +} +static gfxresult_t* filter_finish(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + gfxresult_t*r = i->filter->finish(i->filter, i->out); + free(dev->internal);dev->internal=0;free(dev); + return r; +} + + +static int passthrough_setparameter(gfxdevice_t*dev, const char*key, const char*value) +{ + internal_t*i = (internal_t*)dev->internal; + return i->out->setparameter(i->out, key, value); +} +static void passthrough_startpage(gfxdevice_t*dev, int width, int height) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->startpage(i->out, width, height); +} +static void passthrough_startclip(gfxdevice_t*dev, gfxline_t*line) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->startclip(i->out, line); +} +static void passthrough_endclip(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->endclip(i->out); +} +static void passthrough_stroke(gfxdevice_t*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; + i->out->stroke(i->out, line, width, color, cap_style, joint_style, miterLimit); +} +static void passthrough_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->fill(i->out, line, color); +} +static void passthrough_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->fillbitmap(i->out, line, img, matrix, cxform); +} +static void passthrough_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->fillgradient(i->out, line, gradient, type, matrix); +} +static void passthrough_addfont(gfxdevice_t*dev, gfxfont_t*font) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->addfont(i->out, font); +} +static void passthrough_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->drawchar(i->out, font, glyphnr, color, matrix); +} +static void passthrough_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->drawlink(i->out, line, action); +} +static void passthrough_endpage(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + i->out->endpage(i->out); +} +gfxresult_t* passthrough_finish(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + gfxdevice_t*out = i->out; + free(dev->internal);dev->internal=0;free(dev); + return out->finish(out); +} + +int discard_setparameter(gfxdevice_t*dev, const char*key, const char*value) +{ + return 0; +} +static void discard_startpage(gfxdevice_t*dev, int width, int height) +{ +} +static void discard_startclip(gfxdevice_t*dev, gfxline_t*line) +{ +} +static void discard_endclip(gfxdevice_t*dev) +{ +} +static void discard_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit) +{ +} +static void discard_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) +{ +} +static void discard_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) +{ +} +static void discard_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) +{ +} +static void discard_addfont(gfxdevice_t*dev, gfxfont_t*font) +{ +} +static void discard_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) +{ +} +static void discard_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action) +{ +} +static void discard_endpage(gfxdevice_t*dev) +{ +} +static gfxresult_t* discard_finish(gfxdevice_t*dev) +{ + return 0; +} + +gfxdevice_t*gfxfilter_apply(gfxfilter_t*filter, gfxdevice_t*out) +{ + internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t)); + gfxdevice_t*dev = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t)); + + i->out = out; + i->filter = filter; + i->pass = 1; + + dev->internal = i; + dev->name = filter->name?filter->name:"filter"; + dev->setparameter = filter->setparameter?filter_setparameter:passthrough_setparameter; + dev->startpage = filter->startpage?filter_startpage:passthrough_startpage; + dev->startclip = filter->startclip?filter_startclip:passthrough_startclip; + dev->endclip = filter->endclip?filter_endclip:passthrough_endclip; + dev->stroke = filter->stroke?filter_stroke:passthrough_stroke; + dev->fill = filter->fill?filter_fill:passthrough_fill; + dev->fillbitmap = filter->fillbitmap?filter_fillbitmap:passthrough_fillbitmap; + dev->fillgradient = filter->fillgradient?filter_fillgradient:passthrough_fillgradient; + dev->addfont = filter->addfont?filter_addfont:passthrough_addfont; + dev->drawchar = filter->drawchar?filter_drawchar:passthrough_drawchar; + dev->drawlink = filter->drawlink?filter_drawlink:passthrough_drawlink; + dev->endpage = filter->endpage?filter_endpage:passthrough_endpage; + dev->finish = filter->finish?filter_finish:passthrough_finish; + return dev; +} + +static void setup_twopass(gfxdevice_t*, gfxfilter_t*filter, char passthrough); + +static gfxresult_t* twopass_finish(gfxdevice_t*dev) +{ + internal_t*i = (internal_t*)dev->internal; + + assert(!strcmp(i->out->name, "record")); + + gfxresult_t*r; + if(i->filter->finish) { + r = i->filter->finish(i->filter, i->out); + } else { + r = i->out->finish(i->out); + } + + if(i->pass == i->num_passes) { + /* this output device was not a record device, so we don't have + to do anything here (like cleanup) */ + return r; + } + + /* switch to next pass filter */ + i->filter = &i->twopass->pass2; + + if(i->pass == i->num_passes-1) { + /* we don't record in the final pass- we just stream out to the + next output device */ + i->out = i->final_out; + } else { + // this only happens for 3 passes or more + assert(i->num_passes>2); + gfxdevice_record_init(&i->record, /*use tempfile*/1); + i->out = &i->record; + } + + i->pass++; + gfxresult_record_replay(r, i->out); + r = i->out->finish(i->out); + + return r; +} + +gfxdevice_t*gfxtwopassfilter_apply(gfxtwopassfilter_t*twopass, gfxdevice_t*out) +{ + internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t)); + gfxdevice_t*dev = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t)); + + gfxdevice_record_init(&i->record, /*use tempfile*/1); + + i->out = &i->record; + i->final_out = out; + i->filter = &twopass->pass1; + i->twopass = twopass; + i->pass = 1; + i->num_passes = 2; + + dev->setparameter = i->filter->setparameter?filter_setparameter:passthrough_setparameter; + dev->startpage = i->filter->startpage?filter_startpage:passthrough_startpage; + dev->startclip = i->filter->startclip?filter_startclip:passthrough_startclip; + dev->endclip = i->filter->endclip?filter_endclip:passthrough_endclip; + dev->stroke = i->filter->stroke?filter_stroke:passthrough_stroke; + dev->fill = i->filter->fill?filter_fill:passthrough_fill; + dev->fillbitmap = i->filter->fillbitmap?filter_fillbitmap:passthrough_fillbitmap; + dev->fillgradient = i->filter->fillgradient?filter_fillgradient:passthrough_fillgradient; + dev->addfont = i->filter->addfont?filter_addfont:passthrough_addfont; + dev->drawchar = i->filter->drawchar?filter_drawchar:passthrough_drawchar; + dev->drawlink = i->filter->drawlink?filter_drawlink:passthrough_drawlink; + dev->endpage = i->filter->endpage?filter_endpage:passthrough_endpage; + dev->finish = twopass_finish; + + dev->internal = i; + dev->name = i->filter->name?i->filter->name:"filter"; + dev->finish = twopass_finish; + return dev; +} + diff --git a/lib/gfxfilter.h b/lib/gfxfilter.h new file mode 100644 index 0000000..a5d0a6c --- /dev/null +++ b/lib/gfxfilter.h @@ -0,0 +1,45 @@ +#ifndef __gfxfilter_h__ +#define __gfxfilter_h__ + +#include "gfxdevice.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _gfxfilter +{ + int num_passes; + const char*name; + int pass; + + int (*setparameter)(struct _gfxfilter*in, const char*key, const char*value, struct _gfxdevice*out); + void (*startpage)(struct _gfxfilter*in, int width, int height, struct _gfxdevice*out); + void (*startclip)(struct _gfxfilter*in, gfxline_t*line, struct _gfxdevice*out); + void (*endclip)(struct _gfxfilter*in, struct _gfxdevice*out); + void (*stroke)(struct _gfxfilter*in, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit, struct _gfxdevice*out); + void (*fill)(struct _gfxfilter*in, gfxline_t*line, gfxcolor_t*color, struct _gfxdevice*out); + void (*fillbitmap)(struct _gfxfilter*in, gfxline_t*line, gfximage_t*img, gfxmatrix_t*imgcoord2devcoord, gfxcxform_t*cxform, struct _gfxdevice*out); //cxform? tiling? + void (*fillgradient)(struct _gfxfilter*in, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*gradcoord2devcoord, struct _gfxdevice*out); //? + void (*addfont)(struct _gfxfilter*in, gfxfont_t*font, struct _gfxdevice*out); + void (*drawchar)(struct _gfxfilter*in, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix, struct _gfxdevice*out); + void (*drawlink)(struct _gfxfilter*in, gfxline_t*line, const char*action, struct _gfxdevice*out); + void (*endpage)(struct _gfxfilter*in, struct _gfxdevice*out); + gfxresult_t* (*finish)(struct _gfxfilter*in, struct _gfxdevice*out); + void* internal; +} gfxfilter_t; + +typedef struct _gfxtwopassfilter +{ + gfxfilter_t pass1; + gfxfilter_t pass2; +} gfxtwopassfilter_t; + +gfxdevice_t*gfxfilter_apply(gfxfilter_t*filter, gfxdevice_t*dev); +gfxdevice_t*gfxtwopassfilter_apply(gfxtwopassfilter_t*filter, gfxdevice_t*dev); + +#ifdef __cplusplus +} +#endif + +#endif //__gfxfilter_h__ diff --git a/lib/os.c b/lib/os.c index fddaee9..dacd580 100755 --- a/lib/os.c +++ b/lib/os.c @@ -274,3 +274,33 @@ void memfile_close(memfile_t*file) free(file); } +void move_file(const char*from, const char*to) +{ + int result = rename(from, to); + + if(result==0) return; //done! + + /* if we can't rename, for some reason, copy the file + manually */ + FILE*fi = fopen(from, "rb"); + if(!fi) { + perror(from); + return; + } + FILE*fo = fopen(to, "wb"); + if(!fo) { + perror(to); + return; + } + char buffer[16384]; + while(1) { + int bytes = fread(buffer, 16384, 1, fi); + if(bytes<=0) + return; + fwrite(buffer, bytes, 1, to); + } + + fclose(fo); + fclose(fi); +} + diff --git a/lib/os.h b/lib/os.h index d7cb2a2..532aea8 100755 --- a/lib/os.h +++ b/lib/os.h @@ -49,6 +49,8 @@ char* stripFilename(const char*filename, const char*newext); char* mktempname(char*buffer); +void move_file(const char*from, const char*to); + #ifdef __cplusplus } #endif diff --git a/lib/pdf/BitmapOutputDev.cc b/lib/pdf/BitmapOutputDev.cc index 25c4c81..1a735e3 100644 --- a/lib/pdf/BitmapOutputDev.cc +++ b/lib/pdf/BitmapOutputDev.cc @@ -75,7 +75,7 @@ BitmapOutputDev::BitmapOutputDev(InfoOutputDev*info, PDFDoc*doc) this->clip1dev->startDoc(this->xref); this->gfxoutput = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); - gfxdevice_record_init(this->gfxoutput); + gfxdevice_record_init(this->gfxoutput, 0); this->gfxdev->setDevice(this->gfxoutput); diff --git a/lib/pdf/GFXOutputDev.cc b/lib/pdf/GFXOutputDev.cc index c35cb39..bd6af40 100644 --- a/lib/pdf/GFXOutputDev.cc +++ b/lib/pdf/GFXOutputDev.cc @@ -2663,7 +2663,7 @@ void GFXOutputDev::beginTransparencyGroup(GfxState *state, double *bbox, this->device = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t)); dbg("this->device now %p (old: %p)", this->device, states[statepos].olddevice); - gfxdevice_record_init(this->device); + gfxdevice_record_init(this->device, 0); /*if(!forSoftMask) { ////??? state->setFillOpacity(0.0); @@ -2760,7 +2760,7 @@ void GFXOutputDev::setSoftMask(GfxState *state, double *bbox, GBool alpha, Funct } states[statepos].olddevice = this->device; this->device = (gfxdevice_t*)rfx_calloc(sizeof(gfxdevice_t)); - gfxdevice_record_init(this->device); + gfxdevice_record_init(this->device, 0); dbg("softmaskrecording is %p (dev=%p) at statepos %d\n", states[statepos].softmaskrecording, this->device, statepos); diff --git a/swfs/Makefile.in b/swfs/Makefile.in index a1c7f01..bf411ca 100644 --- a/swfs/Makefile.in +++ b/swfs/Makefile.in @@ -41,9 +41,9 @@ install: $(INSTALL_DATA) ./PreLoaderTemplate.swf $(pkgdatadir)/swfs/PreLoaderTemplate.swf $(INSTALL_DATA) ./tessel_loader.swf $(pkgdatadir)/swfs/tessel_loader.swf $(INSTALL_DATA) ./swft_loader.swf $(pkgdatadir)/swfs/swft_loader.swf - test -f $(pkgdatadir)/swfs/default_viewer.swf || \ + test -f $(pkgdatadir)/swfs/default_viewer.swf -o -L $(pkgdatadir)/swfs/default_viewer.swf || \ $(LN_S) $(pkgdatadir)/swfs/simple_viewer.swf $(pkgdatadir)/swfs/default_viewer.swf; - test -f $(pkgdatadir)/swfs/default_loader.swf || \ + test -f $(pkgdatadir)/swfs/default_loader.swf -o -L $(pkgdatadir)/swfs/default_loader.swf || \ $(LN_S) $(pkgdatadir)/swfs/tessel_loader.swf $(pkgdatadir)/swfs/default_loader.swf; uninstall: