From d80869b6422fc0d3541b8f2750e2f8deaaf38f4e Mon Sep 17 00:00:00 2001 From: Robin Watts Date: Thu, 9 May 2013 20:07:42 +0100 Subject: svgwrite: First attempt at an SVG output device. No font support (just font names are sent through). No group support. No shading support. No image mask support. Line art, text position/size, bitmaps, clipping all seem to work though. --- apps/mudraw.c | 51 ++++- fitz/dev_svg.c | 620 ++++++++++++++++++++++++++++++++++++++++++++++++++ fitz/fitz.h | 2 + win32/libmupdf.vcproj | 4 + 4 files changed, 675 insertions(+), 2 deletions(-) create mode 100644 fitz/dev_svg.c diff --git a/apps/mudraw.c b/apps/mudraw.c index 0b99114d..efc06f25 100644 --- a/apps/mudraw.c +++ b/apps/mudraw.c @@ -12,7 +12,7 @@ enum { TEXT_PLAIN = 1, TEXT_HTML = 2, TEXT_XML = 3 }; -enum { OUT_PNG, OUT_PPM, OUT_PNM, OUT_PAM, OUT_PGM, OUT_PBM }; +enum { OUT_PNG, OUT_PPM, OUT_PNM, OUT_PAM, OUT_PGM, OUT_PBM, OUT_SVG }; typedef struct { @@ -28,6 +28,7 @@ static const suffix_t suffix_table[] = { ".pnm", OUT_PNM }, { ".pam", OUT_PAM }, { ".pbm", OUT_PBM }, + { ".svg", OUT_SVG }, }; /* @@ -423,7 +424,53 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) if (showmd5 || showtime) printf("page %s %d", filename, pagenum); - if (output || showmd5 || showtime) + if (output && output_format == OUT_SVG) + { + float zoom; + fz_matrix ctm; + fz_rect bounds, tbounds; + char buf[512]; + FILE *file; + fz_output *out; + + sprintf(buf, output, pagenum); + file = fopen(buf, "wb"); + if (file == NULL) + fz_throw(ctx, "cannot open file '%s': %s", buf, strerror(errno)); + out = fz_new_output_with_file(ctx, file); + + fz_bound_page(doc, page, &bounds); + zoom = resolution / 72; + fz_pre_rotate(fz_scale(&ctm, zoom, zoom), rotation); + tbounds = bounds; + fz_transform_rect(&tbounds, &ctm); + + fz_try(ctx) + { + dev = fz_new_svg_device(ctx, out, tbounds.x1-tbounds.x0, tbounds.y1-tbounds.y0); + if (list) + fz_run_display_list(list, dev, &ctm, &tbounds, &cookie); + else + fz_run_page(doc, page, dev, &ctm, &cookie); + fz_free_device(dev); + dev = NULL; + } + fz_always(ctx) + { + fz_free_device(dev); + dev = NULL; + fz_close_output(out); + fclose(file); + } + fz_catch(ctx) + { + fz_free_display_list(ctx, list); + fz_free_page(doc, page); + fz_rethrow(ctx); + } + } + + if ((output && output_format != OUT_SVG)|| showmd5 || showtime) { float zoom; fz_matrix ctm; diff --git a/fitz/dev_svg.c b/fitz/dev_svg.c new file mode 100644 index 00000000..1b71e576 --- /dev/null +++ b/fitz/dev_svg.c @@ -0,0 +1,620 @@ +#include "mupdf-internal.h" + +typedef struct svg_device_s svg_device; + +typedef struct tile_s tile; + +struct tile_s +{ + int pattern; + fz_matrix ctm; + fz_rect view; + fz_rect area; + fz_point step; +}; + +struct svg_device_s +{ + fz_context *ctx; + fz_output *out; + + int id; + + int num_tiles; + int max_tiles; + tile *tiles; +}; + +/* Helper functions */ + +static void +svg_dev_path(svg_device *sdev, fz_path *path) +{ + fz_output *out = sdev->out; + float x, y; + int i = 0; + fz_printf(out, " d=\""); + while (i < path->len) + { + switch (path->items[i++].k) + { + case FZ_MOVETO: + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "M %g %g ", x, y); + break; + case FZ_LINETO: + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "L %g %g ", x, y); + break; + case FZ_CURVETO: + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "C %g %g ", x, y); + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "%g %g ", x, y); + x = path->items[i++].v; + y = path->items[i++].v; + fz_printf(out, "%g %g ", x, y); + break; + case FZ_CLOSE_PATH: + fz_printf(out, "Z "); + break; + } + } + fz_printf(out, "\""); +} + +static void +svg_dev_ctm(svg_device *sdev, const fz_matrix *ctm) +{ + fz_output *out = sdev->out; + + if (ctm->a != 1.0 || ctm->b != 0 || ctm->c != 0 || ctm->d != 1.0 || ctm->e != 0 || ctm->f != 0) + { + fz_printf(out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", + ctm->a, ctm->b, ctm->c, ctm->d, ctm->e, ctm->f); + } +} + +static void +svg_dev_stroke_state(svg_device *sdev, fz_stroke_state *stroke_state) +{ + fz_output *out = sdev->out; + + fz_printf(out, " stroke-width=\"%g\"", stroke_state->linewidth); + fz_printf(out, " stroke-linecap=\"%s\"", + (stroke_state->start_cap == FZ_LINECAP_SQUARE ? "square" : + (stroke_state->start_cap == FZ_LINECAP_ROUND ? "round" : "butt"))); + if (stroke_state->dash_len != 0) + { + int i; + fz_printf(out, " stroke-dasharray="); + for (i = 0; i < stroke_state->dash_len; i++) + fz_printf(out, "%c%g", (i == 0 ? '\"' : ','), stroke_state->dash_list[i]); + fz_printf(out, "\""); + if (stroke_state->dash_phase != 0) + fz_printf(out, " stroke-dashoffset=\"%g\"", stroke_state->dash_phase); + } + if (stroke_state->linejoin == FZ_LINEJOIN_MITER || stroke_state->linejoin == FZ_LINEJOIN_MITER_XPS) + fz_printf(out, " stroke-miterlimit=\"%g\"", stroke_state->miterlimit); + fz_printf(out, " stroke-linejoin=\"%s\"", + (stroke_state->linejoin == FZ_LINEJOIN_BEVEL ? "bevel" : + (stroke_state->linejoin == FZ_LINEJOIN_ROUND ? "round" : "miter"))); +} + +static void +svg_dev_fill_color(svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) +{ + fz_context *ctx = sdev->ctx; + fz_output *out = sdev->out; + float rgb[FZ_MAX_COLORS]; + + if (colorspace != fz_device_rgb) + { + /* If it's not rgb, make it rgb */ + colorspace->to_rgb(ctx, colorspace, color, rgb); + color = rgb; + } + + if (color[0] == 0 && color[1] == 0 && color[2] == 0) + { + /* don't send a fill, as it will be assumed to be black */ + } + else + fz_printf(out, " fill=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); + if (alpha != 1) + fz_printf(out, " fill-opacity=\"%g\"", alpha); +} + +static void +svg_dev_stroke_color(svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) +{ + fz_context *ctx = sdev->ctx; + fz_output *out = sdev->out; + float rgb[FZ_MAX_COLORS]; + + if (colorspace != fz_device_rgb) + { + /* If it's not rgb, make it rgb */ + colorspace->to_rgb(ctx, colorspace, color, rgb); + color = rgb; + } + + fz_printf(out, " fill=\"none\" stroke=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); + if (alpha != 1) + fz_printf(out, " stroke-opacity=\"%g\"", alpha); +} + +static void +svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) +{ + fz_output *out = sdev->out; + int i; + fz_matrix inverse; + fz_matrix local_trm; + float size; + + /* Rely on the fact that trm.{e,f} == 0 */ + size = fz_matrix_expansion(&text->trm); + local_trm.a = text->trm.a / size; + local_trm.b = text->trm.b / size; + local_trm.c = -text->trm.c / size; + local_trm.d = -text->trm.d / size; + local_trm.e = 0; + local_trm.f = 0; + fz_invert_matrix(&inverse, &local_trm); + fz_concat(&local_trm, &local_trm, ctm); + + fz_printf(out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", + local_trm.a, local_trm.b, local_trm.c, local_trm.d, local_trm.e, local_trm.f); + fz_printf(out, " font-size=\"%g\"", size); + fz_printf(out, " font-family=\"%s\"", text->font->name); + + fz_printf(out, " x="); + for (i=0; i < text->len; i++) + { + fz_text_item *it = &text->items[i]; + fz_point p; + p.x = it->x; + p.y = it->y; + fz_transform_point(&p, &inverse); + fz_printf(out, "%c%g", i == 0 ? '\"' : ' ', p.x); + } + fz_printf(out, "\" y="); + for (i=0; i < text->len; i++) + { + fz_text_item *it = &text->items[i]; + fz_point p; + p.x = it->x; + p.y = it->y; + fz_transform_point(&p, &inverse); + fz_printf(out, "%c%g", i == 0 ? '\"' : ' ', p.y); + } + fz_printf(out, "\">\n"); + for (i=0; i < text->len; i++) + { + fz_text_item *it = &text->items[i]; + int c = it->ucs; + if (c >= 32 && c <= 127 && c != '<' && c != '&') + fz_printf(out, "%c", c); + else + fz_printf(out, "&#x%04x;", c); + } + fz_printf(out, "\n\n"); +} + + +/* Entry points */ + +static void +svg_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "\n"); +} + +static void +svg_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "\n"); +} + +static void +svg_dev_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + int num = sdev->id++; + + fz_printf(out, "\n", num); + fz_printf(out, "\n\n\n", num); +} + +static void +svg_dev_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_rect bounds; + int num = sdev->id++; + float white[3] = { 255, 255, 255 }; + + fz_bound_path(ctx, path, stroke, ctm, &bounds); + + fz_printf(out, "\n", + num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); + fz_printf(out, "\n\n\n", num); +} + +static void +svg_dev_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, + fz_colorspace *colorspace, float *color, float alpha) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "user; + fz_output *out = sdev->out; + + fz_printf(out, "user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_rect bounds; + int num = sdev->id++; + float white[3] = { 255, 255, 255 }; + + fz_bound_text(ctx, text, NULL, ctm, &bounds); + + fz_printf(out, "\n", + num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); + fz_printf(out, "\n\n", num); +} + +static void +svg_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_rect bounds; + int num = sdev->id++; + float white[3] = { 255, 255, 255 }; + + fz_bound_text(ctx, text, NULL, ctm, &bounds); + + fz_printf(out, "\n", + num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); + fz_printf(out, "\n\n", num); +} + +static void +svg_dev_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +{ +} + +static void +send_data_base64(fz_output *out, fz_buffer *buffer) +{ + int i, len; + static const char set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + + len = buffer->len/3; + for (i = 0; i < len; i++) + { + int c = buffer->data[3*i]; + int d = buffer->data[3*i+1]; + int e = buffer->data[3*i+2]; + if ((i & 15) == 0) + fz_printf(out, "\n"); + fz_printf(out, "%c%c%c%c", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)|(e>>6)], set[e & 63]); + } + i *= 3; + switch (buffer->len-i) + { + case 2: + { + int c = buffer->data[i]; + int d = buffer->data[i+1]; + fz_printf(out, "%c%c%c=", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)]); + break; + } + case 1: + { + int c = buffer->data[i]; + fz_printf(out, "%c%c==", set[c>>2], set[(c&3)<<4]); + break; + } + default: + case 0: + break; + } +} + +static void +svg_dev_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_context *ctx = dev->ctx; + fz_output *out = sdev->out; + fz_matrix local_ctm = *ctm; + fz_matrix scale = { 1.0f/image->w, 0, 0, 1.0f/image->h, 0, 0}; + + fz_concat(&local_ctm, &scale, ctm); + fz_printf(out, "w, image->h); + switch (image->buffer == NULL ? FZ_IMAGE_JPX : image->buffer->params.type) + { + case FZ_IMAGE_JPEG: + fz_printf(out, "image/jpeg;base64,"); + send_data_base64(out, image->buffer->buffer); + break; + case FZ_IMAGE_PNG: + fz_printf(out, "image/png;base64,"); + send_data_base64(out, image->buffer->buffer); + break; + default: + { + fz_buffer *buf = fz_image_as_png(ctx, image, image->w, image->h); + fz_printf(out, "image/png;base64,"); + send_data_base64(out, buf); + fz_drop_buffer(ctx, buf); + break; + } + } + fz_printf(out, "\"/>\n"); +} + +static void +svg_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +{ +} + +static void +svg_dev_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_colorspace *colorspace, float *color, float alpha) +{ +} + +static void +svg_dev_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +{ + svg_device *sdev = dev->user; + fz_output *out = sdev->out; + + fz_printf(out, "\n"); +} + +static void +svg_dev_pop_clip(fz_device *dev) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_output *out = sdev->out; + + /* FIXME */ + fz_printf(out, "\n"); +} + +static void +svg_dev_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) +{ +} + +static void +svg_dev_end_mask(fz_device *dev) +{ + +} + +static void +svg_dev_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) +{ + +} + +static void +svg_dev_end_group(fz_device *dev) +{ + +} + +static int +svg_dev_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_output *out = sdev->out; + fz_context *ctx = dev->ctx; + fz_matrix inverse; + int num; + tile *t; + + if (sdev->num_tiles == sdev->max_tiles) + { + int n = (sdev->num_tiles == 0 ? 4 : sdev->num_tiles * 2); + + sdev->tiles = fz_resize_array(ctx, sdev->tiles, n, sizeof(tile)); + sdev->max_tiles = n; + } + num = sdev->num_tiles++; + t = &sdev->tiles[num]; + t->area = *area; + t->view = *view; + t->ctm = *ctm; + t->pattern = sdev->id++; + t->step.x = xstep; + t->step.y = ystep; + + /* view = area of our reference tile in pattern space. + * area = area to tile into in pattern space. + * xstep/ystep = pattern repeat step in pattern space. + * All of these need to be transformed by ctm to get to device space. + * SVG only allows us to specify pattern tiles as axis aligned + * rectangles, so we send these through as is, and ensure that the + * correct matrix is used on the fill. + */ + + /* In svg, the reference tile is taken from (x,y) to (x+width,y+height) + * and is repeated at (x+n*width,y+m*height) for all integer n and m. + * This means that width and height correspond to xstep and ystep. */ + fz_printf(out, "pattern); + fz_printf(out, " x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\">\n", + view->x0, view->y0, xstep, ystep); + /* All the pattern contents will have their own ctm applied. Let's + * undo the current one to allow for this */ + fz_invert_matrix(&inverse, ctm); + fz_printf(out, "\n"); + + return 0; +} + +static void +svg_dev_end_tile(fz_device *dev) +{ + svg_device *sdev = (svg_device *)dev->user; + fz_output *out = sdev->out; + int num; + tile *t; + + if (sdev->num_tiles == 0) + return; + num = --sdev->num_tiles; + t = &sdev->tiles[num]; + + fz_printf(out, "\n\n"); + fz_printf(out, "ctm); + fz_printf(out, " fill=\"url(#pa%d)\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\"/>\n", + t->pattern, t->area.x0, t->area.y0, t->area.x1 - t->area.x0, t->area.y1 - t->area.y0); +} + +static void +svg_dev_free_user(fz_device *dev) +{ + svg_device *sdev = dev->user; + fz_context *ctx = sdev->ctx; + fz_output *out = sdev->out; + + fz_free(ctx, sdev->tiles); + + fz_printf(out, "\n"); + + fz_free(ctx, sdev); +} + +fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height) +{ + svg_device *sdev = fz_malloc_struct(ctx, svg_device); + fz_device *dev; + + fz_try(ctx) + { + sdev->ctx = ctx; + sdev->out = out; + sdev->id = 0; + + dev = fz_new_device(ctx, sdev); + } + fz_catch(ctx) + { + fz_free(ctx, sdev); + fz_rethrow(ctx); + } + + dev->free_user = svg_dev_free_user; + + dev->fill_path = svg_dev_fill_path; + dev->stroke_path = svg_dev_stroke_path; + dev->clip_path = svg_dev_clip_path; + dev->clip_stroke_path = svg_dev_clip_stroke_path; + + dev->fill_text = svg_dev_fill_text; + dev->stroke_text = svg_dev_stroke_text; + dev->clip_text = svg_dev_clip_text; + dev->clip_stroke_text = svg_dev_clip_stroke_text; + dev->ignore_text = svg_dev_ignore_text; + + dev->fill_shade = svg_dev_fill_shade; + dev->fill_image = svg_dev_fill_image; + dev->fill_image_mask = svg_dev_fill_image_mask; + dev->clip_image_mask = svg_dev_clip_image_mask; + + dev->pop_clip = svg_dev_pop_clip; + + dev->begin_mask = svg_dev_begin_mask; + dev->end_mask = svg_dev_end_mask; + dev->begin_group = svg_dev_begin_group; + dev->end_group = svg_dev_end_group; + + dev->begin_tile = svg_dev_begin_tile; + dev->end_tile = svg_dev_end_tile; + + fz_printf(out, "\n"); + fz_printf(out, "\n"); + fz_printf(out, "\n", + page_width*2.54/72, page_height*2.54/72, page_width, page_height); + + return dev; +} diff --git a/fitz/fitz.h b/fitz/fitz.h index 2cea5424..5eb570d0 100644 --- a/fitz/fitz.h +++ b/fitz/fitz.h @@ -1901,6 +1901,8 @@ fz_device *fz_new_draw_device(fz_context *ctx, fz_pixmap *dest); */ fz_device *fz_new_draw_device_with_bbox(fz_context *ctx, fz_pixmap *dest, const fz_irect *clip); +fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height); + /* fz_enable_device_hints : Enable hints in a device. diff --git a/win32/libmupdf.vcproj b/win32/libmupdf.vcproj index 1fa9886f..51fc0693 100644 --- a/win32/libmupdf.vcproj +++ b/win32/libmupdf.vcproj @@ -436,6 +436,10 @@ RelativePath="..\fitz\dev_null.c" > + + -- cgit v1.2.3