1 #include <string.h> /* memcpy, memset */
5 #include <gdk-pixbuf/gdk-pixbuf.h> /* includes glib.h */
6 #include <glib/gprintf.h>
10 * The width and height of the viewport that we'll render the SVG
11 * into. The final "picture" may not actually be this size; based on
12 * the height, width, viewBox, and preserveAspectRatio attributes in
13 * the SVG itself, libsvgtiny may scale, stretch, offset, etc. the
14 * paths to make them fit nicely into the viewport.
16 #define VIEWPORT_WIDTH 512
17 #define VIEWPORT_HEIGHT 512
19 /* The start of an XInclude that was inserted by
20 * gtk-encode-symbolic-svg */
21 #define XI_SIGNATURE "<xi:include href=\"data:text/xml;base64,"
24 /* Convenient typedefs for libsvgtiny */
25 typedef struct svgtiny_diagram diagram_t
;
26 typedef struct svgtiny_shape shape_t
;
30 GdkPixbufModuleUpdatedFunc updated_func
;
31 GdkPixbufModulePreparedFunc prepared_func
;
32 GdkPixbufModuleSizeFunc size_func
;
35 /* The SVG "file" that we're building in memory. */
38 /* How far into svg_data are we? This should always point to the
39 next empty byte. If (for example) svg_data_size is 2, then
40 svg_data[0] and svg_data[1] are used, but svg_data[2] is free. */
47 * @brief Render an svgtiny path using cairo.
50 * A pointer to a valid cairo context.
53 * A pointer to an svgtiny shape that will be rendered on the
54 * cairo context's target surface.
56 static void render_path(cairo_t
* cr
, shape_t
* path
) {
60 for (j
= 0; j
!= path
->path_length
; ) {
61 switch ((int) path
->path
[j
]) {
62 case svgtiny_PATH_MOVE
:
68 case svgtiny_PATH_CLOSE
:
72 case svgtiny_PATH_LINE
:
78 case svgtiny_PATH_BEZIER
:
89 if (path
->fill
!= svgtiny_TRANSPARENT
) {
90 cairo_set_source_rgba(cr
,
91 svgtiny_RED(path
->fill
) / 255.0,
92 svgtiny_GREEN(path
->fill
) / 255.0,
93 svgtiny_BLUE(path
->fill
) / 255.0,
95 cairo_fill_preserve(cr
);
97 if (path
->stroke
!= svgtiny_TRANSPARENT
) {
98 cairo_set_source_rgba(cr
,
99 svgtiny_RED(path
->stroke
) / 255.0,
100 svgtiny_GREEN(path
->stroke
) / 255.0,
101 svgtiny_BLUE(path
->stroke
) / 255.0,
103 cairo_set_line_width(cr
, path
->stroke_width
);
104 cairo_stroke_preserve(cr
);
109 * @brief Parse a buffer of SVG data into a diagram_t structure.
112 * The buffer containing the SVG document.
115 * The number of bytes in @c buffer.
117 * @return If successful, a pointer to a @c diagram_t structure is
118 * returned; if not, @c NULL is returned. You are expected to @c
119 * svgtiny_free the result if it is valid.
121 static diagram_t
* svgtiny_diagram_from_buffer(const gchar
* buffer
,
129 diagram
= svgtiny_create();
131 g_set_error_literal(error
,
134 "out of memory in svgtiny_create()");
138 g_assert((int)width
>= 0);
139 g_assert((int)height
>= 0);
140 code
= svgtiny_parse(diagram
,
148 /* The one success case. */
150 case svgtiny_OUT_OF_MEMORY
:
151 g_set_error_literal(error
,
154 "out of memory in svgtiny_parse()");
156 case svgtiny_LIBDOM_ERROR
:
157 g_set_error_literal(error
,
159 GDK_PIXBUF_ERROR_CORRUPT_IMAGE
,
160 "invalid XML DOM in svgtiny_parse()");
162 case svgtiny_NOT_SVG
:
163 g_set_error_literal(error
,
165 GDK_PIXBUF_ERROR_CORRUPT_IMAGE
,
166 "missing <svg> element in svgtiny_parse()");
168 case svgtiny_SVG_ERROR
:
171 GDK_PIXBUF_ERROR_CORRUPT_IMAGE
,
172 "SVG format error in svgtiny_parse() on line %i: %s",
174 diagram
->error_message
);
178 /* All other cases above are failure */
183 * @brief Create a cairo context from a libsvgtiny diagram.
186 * A pointer to a valid libsvgtiny diagram.
188 * @return If successful, a pointer to a @c cairo_t context structure
189 * is returned; if not, @c NULL is returned. You are expected to @c
190 * cairo_destroy the result if it is valid.
192 static cairo_t
* cairo_context_from_diagram(const diagram_t
* diagram
) {
194 cairo_surface_t
* surface
;
198 surface
= cairo_image_surface_create(CAIRO_FORMAT_ARGB32
,
202 crs
= cairo_surface_status(surface
);
203 if (crs
!= CAIRO_STATUS_SUCCESS
) {
205 "cairo_image_surface_create failed: %s\n",
206 cairo_status_to_string(crs
));
207 cairo_surface_destroy(surface
);
211 cr
= cairo_create(surface
);
212 crs
= cairo_status(cr
);
214 /* Immediately destroy the surface which is now accessible as
216 cairo_surface_destroy(surface
);
218 if (crs
!= CAIRO_STATUS_SUCCESS
) {
220 "cairo_create failed: %s\n",
221 cairo_status_to_string(crs
));
226 cairo_set_source_rgba(cr
, 0, 0, 0, 0);
229 /* Loop through the shapes in the diagram... */
230 for (i
= 0; i
!= diagram
->shape_count
; i
++) {
232 /* If this shape is a path, just render it. */
233 if (diagram
->shape
[i
].path
) {
234 render_path(cr
, &diagram
->shape
[i
]);
237 /* If this shape is text... */
238 if (diagram
->shape
[i
].text
) {
239 /* Figure out what color to use from the R/G/B components of the
241 cairo_set_source_rgba(cr
,
242 svgtiny_RED(diagram
->shape
[i
].stroke
) / 255.0,
243 svgtiny_GREEN(diagram
->shape
[i
].stroke
) / 255.0,
244 svgtiny_BLUE(diagram
->shape
[i
].stroke
) / 255.0,
246 /* Then move to the actual position of the text within the
249 diagram
->shape
[i
].text_x
,
250 diagram
->shape
[i
].text_y
);
253 cairo_show_text(cr
, diagram
->shape
[i
].text
);
258 /* Check the status again just for good measure? */
259 crs
= cairo_status(cr
);
260 if (crs
!= CAIRO_STATUS_SUCCESS
) {
263 cairo_status_to_string(crs
));
272 * @brief Create a GdkPixbuf from a buffer of SVG data.
275 * The buffer containing the SVG document.
278 * The number of bytes in @c buffer.
281 * The address of a @c GError pointer that we use to return errors.
283 * @return If successful, a valid pointer to a @c GdkPixbuf is
284 * returned; if not, @c NULL is returned and @c error is populated.
286 static GdkPixbuf
* gdk_pixbuf_from_svg_buffer(const gchar
* buffer
,
292 GError
* sub_error
= NULL
;
294 diagram
= svgtiny_diagram_from_buffer(buffer
,
300 g_propagate_error(error
, sub_error
);
304 cr
= cairo_context_from_diagram(diagram
);
306 svgtiny_free(diagram
);
307 g_set_error_literal(error
,
309 GDK_PIXBUF_ERROR_CORRUPT_IMAGE
,
310 "could not create Cairo surface from SVG diagram");
315 /* I've gone back and forth on this about five times: we use the
316 * diagram width and height, and not the viewport width and height.
317 * This can ultimately render an image that's larger than the
318 * viewport size, but I think GDK will resize the final pixbuf
319 * anyway. More importantly, rendering small icons at a larger
320 * (viewport) size seems to make the whole thing go ape-shit.
321 * So for now I'm back in the diagram camp.
323 pb
= gdk_pixbuf_get_from_surface(cairo_get_target(cr
),
331 g_set_error_literal(error
,
333 GDK_PIXBUF_ERROR_FAILED
,
334 "failed to obtain a GdkPixbuf from Cairo surface");
341 static gpointer
gdk_pixbuf_begin_load(GdkPixbufModuleSizeFunc size_func
,
342 GdkPixbufModulePreparedFunc prep_func
,
343 GdkPixbufModuleUpdatedFunc updated_func
,
347 SvgTinyContext
* context
= g_new(SvgTinyContext
, 1);
349 context
->size_func
= size_func
;
350 context
->prepared_func
= prep_func
;
351 context
->updated_func
= updated_func
;
352 context
->user_data
= user_data
;
354 context
->svg_data
= NULL
;
355 context
->svg_data_size
= 0;
360 static gboolean
gdk_pixbuf_load_increment(gpointer data
,
364 SvgTinyContext
* context
= (SvgTinyContext
*)data
;
370 context
->svg_data
= g_realloc(context
->svg_data
,
371 context
->svg_data_size
+ buf_size
);
372 memcpy(context
->svg_data
+ context
->svg_data_size
, buf
, buf_size
);
373 context
->svg_data_size
+= buf_size
;
378 static void emit_updated(SvgTinyContext
* context
, GdkPixbuf
* pixbuf
) {
379 if (context
->updated_func
!= NULL
) {
380 (*context
->updated_func
)(pixbuf
,
383 gdk_pixbuf_get_width(pixbuf
),
384 gdk_pixbuf_get_height(pixbuf
),
389 static void emit_prepared(SvgTinyContext
* context
, GdkPixbuf
* pixbuf
) {
390 if (context
->prepared_func
!= NULL
) {
391 (*context
->prepared_func
)(pixbuf
, NULL
, context
->user_data
);
397 * @brief Process certain <xi:include> elements in an SVG buffer.
399 * GTK is very cute. Its gtk-encode-symbolic-svg tool wraps your SVG
400 * in its own boilerplate, but then rather than including your SVG
401 * data verbatim, it includes it via a sketchy XInclude that looks
404 * <xi:include href="data:text/xml;base64,PD94bWwgd..."/>
406 * Librsvg knows how to parse that, but libxml2 doesn't (the latter
407 * can handle an XInclude, just not a base64-encoded data reference).
408 * Fortunately, you can read the source to gtk-encode-symbolic-svg,
409 * and just see what the format of that line will be. Here we're going
410 * to parse out the base64 data, decode it, strip out its opening
411 * <xml> and <svg> tags, and then replace the original <xi:include>
412 * element with the result.
415 * A buffer containing SVG file data.
418 * The size of @c buffer (which may not be NULL-terminated).
421 * A pointer to the size of the new buffer, valid only if the
422 * return value is non-NULL.
424 * @return A pointer to a buffer where the <xi:include> has been
425 * processed. If no replacements were made, the result will be @c
426 * NULL; otherwise, you are expected to @c free it when you are done.
428 static gchar
* process_gtk_symbolic_svg_xinclude(const gchar
* buffer
,
434 gchar
* after_xi_element
;
436 xi_start
= g_strstr_len(buffer
, buf_size
, XI_SIGNATURE
);
437 if (xi_start
== NULL
) {
441 xi
= xi_start
+ strlen(XI_SIGNATURE
);
442 xi_stop
= g_strstr_len(xi
, (buffer
+ buf_size
) - xi
, "\"");
444 if(xi_stop
== NULL
) {
445 /* We found the start of an XInclude, but not the end of its
446 base64-encoded data? Play it safe and do nothing. */
450 /* g_base64_decode needs a NULL-terminated string, so let's make
455 /* All files are ASCII, right? In GTK's gdkpixbufutils.c, our base64
456 * data is encoded from a binary file stream, i.e. bytes, without
457 * any regard for what the text inside represents. Elsewhere we are
458 * pretending that gchar is a reasonable data type to use for the
459 * contents of an SVG file; here we are saying that again out loud.
461 gchar
* decoded
= (gchar
*)g_base64_decode(xi
, &decoded_size
);
464 /* We need another round of processing to strip the <xml> and <svg>
465 * elements out of "decoded", but it's simpler to just overwrite
466 * them with spaces before we proceed. We'll wind up with a document
467 * that has a conspicuous chunk of whitespace in the middle of it,
468 * but whatever. Note that we don't need to worry about the <xml>
469 * element so much, because if one exists, it has to come before the
470 * <svg>. As a result, we just need to strip everything up to the
471 * leading <svg> tag. */
472 gchar
* svg_open_start
= g_strstr_len(decoded
, decoded_size
, "<svg ");
473 if (svg_open_start
== NULL
) {
474 /* The decoded data is not what we were expecting. Give up. */
479 gchar
* svg_open_end
= g_strstr_len(svg_open_start
,
480 (decoded
+decoded_size
) - svg_open_start
,
482 if (svg_open_end
== NULL
) {
483 /* The decoded data is not what we were expecting. Give up. */
488 /* Keep in mind that we want to wipe everything up to and
489 including the <svg> tag; we'll usually overwrite an <xml> tag
491 memset(decoded
, ' ', (1 + (svg_open_end
- decoded
)));
493 gchar
* svg_close_start
= g_strstr_len(svg_open_end
,
494 (decoded
+decoded_size
)-svg_open_end
,
496 if (svg_close_start
== NULL
) {
497 /* The decoded data is not what we were expecting. Give up. */
501 memset(svg_close_start
, ' ', 6);
503 /* We're going to keep everything up to xi_start. If the <xi:include
504 * started at, say, position three, then this would compute a size
505 * of three. Which is correct: we want to retain buffer[0],
506 * buffer[1], and buffer[2]. */
507 gsize keep_before_size
= xi_start
- buffer
;
509 /* We're also going to keep everything after the XInclude element. */
510 after_xi_element
= xi_stop
+ 3; /* They all end with "/> */
511 if (after_xi_element
>= buffer
+buf_size
) {
512 /* The document ends right after the XInclude (with no closing
513 </svg> tag or anything)? Bail. */
518 gsize keep_after_size
= (buffer
+buf_size
) - after_xi_element
;
520 *new_size
= keep_before_size
+ decoded_size
+ keep_after_size
;
521 gchar
* result
= g_malloc(*new_size
);
522 memcpy(result
, buffer
, keep_before_size
);
523 memcpy(result
+keep_before_size
, decoded
, decoded_size
);
524 memcpy(result
+keep_before_size
+decoded_size
,
532 static gboolean
gdk_pixbuf_stop_load(gpointer data
, GError
**error
) {
533 SvgTinyContext
* context
= (SvgTinyContext
*)data
;
534 GdkPixbuf
* pixbuf
= NULL
;
535 GError
* sub_error
= NULL
;
537 g_assert(context
!= NULL
);
538 if (context
->svg_data
== NULL
|| context
->svg_data_size
== 0) {
539 /* Is it possible to begin/stop with no increments in between?
540 * I sure don't know. Let's play it safe. */
544 /* If we're inside of gtk-encode-symbolic-svg right now, we need to
545 process the insane librsvg-specific XInclude directive it hands
546 us before proceeding. */
548 gchar
* newdata
= process_gtk_symbolic_svg_xinclude(context
->svg_data
,
549 context
->svg_data_size
,
551 if (newdata
!= NULL
) {
552 g_free(context
->svg_data
);
553 context
->svg_data
= newdata
;
554 context
->svg_data_size
= newsize
;
557 /* OK, we've got an SVG with no XIncludes now. */
558 pixbuf
= gdk_pixbuf_from_svg_buffer(context
->svg_data
,
559 context
->svg_data_size
,
562 if (pixbuf
!= NULL
) {
563 emit_prepared(context
, pixbuf
);
564 emit_updated(context
, pixbuf
);
565 g_object_unref(pixbuf
);
568 g_propagate_error(error
, sub_error
);
571 g_free(context
->svg_data
);
578 G_MODULE_EXPORT
void fill_vtable(GdkPixbufModule
* module);
579 void fill_vtable(GdkPixbufModule
* module) {
580 module->begin_load
= gdk_pixbuf_begin_load
;
581 module->load_increment
= gdk_pixbuf_load_increment
;
582 module->stop_load
= gdk_pixbuf_stop_load
;
585 G_MODULE_EXPORT
void fill_info(GdkPixbufFormat
*info
);
586 void fill_info(GdkPixbufFormat
* info
) {
587 /* Borrowed from librsvg-2.40.21 */
588 static const GdkPixbufModulePattern signature
[] = {
589 { " <svg", "* ", 100 },
590 { " <!DOCTYPE svg", "* ", 100 },
594 /* I'm not sure if we should support gzipped svg here? */
595 static const gchar
*mime_types
[] = {
599 "image/vnd.adobe.svg+xml",
601 "image/svg+xml-compressed",
605 static const gchar
*extensions
[] = {
613 info
->signature
= (GdkPixbufModulePattern
*)signature
;
614 info
->description
= "Scalable Vector Graphics";
615 info
->mime_types
= (gchar
**)mime_types
;
616 info
->extensions
= (gchar
**)extensions
;
617 info
->flags
= GDK_PIXBUF_FORMAT_SCALABLE
;
618 info
->license
= "AGPL3";
622 int main(int argc
, char** argv
) {
628 /* Parse arguments, and maybe print usage */
630 g_printf("Usage: %s INPUT OUTPUT\n", argv
[0]);
631 g_printf("Convert an SVG file (INPUT) to a PNG file (OUTPUT)\n");
638 pb
= gdk_pixbuf_new_from_file(svgpath
, &err
);
641 "Error %d in gdk_pixbuf_new_from_file: %s\n",
648 gdk_pixbuf_save(pb
, pngpath
, "png", NULL
, NULL
);