io-svg.c

   1 #include <stdio.h> /* fopen, fprintf, fread, printf */
   2 #include <string.h> /* memcpy */
   3
   4 #include <cairo.h>
   5 #include <gdk/gdk.h>
   6 #include <gdk-pixbuf/gdk-pixbuf.h> /* includes glib.h */
   7 #include <svgtiny.h>
   8
   9 /*
  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.
  15  */
  16 #define VIEWPORT_WIDTH 512
  17 #define VIEWPORT_HEIGHT 512
  18
  19 #define SVG_BUFFER_INCREMENT (size_t)4194304
  20
  21 /* Convenient typedefs for libsvgtiny */
  22 typedef struct svgtiny_diagram diagram_t;
  23 typedef struct svgtiny_shape shape_t;
  24
  25
  26 typedef struct {
  27   GdkPixbufModuleUpdatedFunc  updated_func;
  28   GdkPixbufModulePreparedFunc prepared_func;
  29   GdkPixbufModuleSizeFunc     size_func;
  30   gpointer                    user_data;
  31
  32   /* The "file" */
  33   char*                       svg_data;
  34   size_t                      svg_data_size;
  35   size_t                      svg_data_max;
  36
  37 } SvgTinyContext;
  38
  39
  40 /**
  41  * @brief Render an svgtiny path using cairo.
  42  *
  43  * @param cr
  44  *   A pointer to a valid cairo context.
  45  *
  46  * @param path
  47  *   A pointer to an svgtiny shape that will be rendered on the
  48  *   cairo context's target surface.
  49  */
  50 static void render_path(cairo_t* cr, shape_t* path) {
  51   unsigned int j;
  52
  53   cairo_new_path(cr);
  54   for (j = 0; j != path->path_length; ) {
  55     switch ((int) path->path[j]) {
  56     case svgtiny_PATH_MOVE:
  57       cairo_move_to(cr,
  58                     path->path[j + 1],
  59                     path->path[j + 2]);
  60       j += 3;
  61       break;
  62     case svgtiny_PATH_CLOSE:
  63       cairo_close_path(cr);
  64       j += 1;
  65       break;
  66     case svgtiny_PATH_LINE:
  67       cairo_line_to(cr,
  68                     path->path[j + 1],
  69                     path->path[j + 2]);
  70       j += 3;
  71       break;
  72     case svgtiny_PATH_BEZIER:
  73       cairo_curve_to(cr,
  74                      path->path[j + 1],
  75                      path->path[j + 2],
  76                      path->path[j + 3],
  77                      path->path[j + 4],
  78                      path->path[j + 5],
  79                      path->path[j + 6]);
  80       j += 7;
  81     }
  82   }
  83   if (path->fill != svgtiny_TRANSPARENT) {
  84     cairo_set_source_rgba(cr,
  85                           svgtiny_RED(path->fill) / 255.0,
  86                           svgtiny_GREEN(path->fill) / 255.0,
  87                           svgtiny_BLUE(path->fill) / 255.0,
  88                           1);
  89     cairo_fill_preserve(cr);
  90   }
  91   if (path->stroke != svgtiny_TRANSPARENT) {
  92     cairo_set_source_rgba(cr,
  93                           svgtiny_RED(path->stroke) / 255.0,
  94                           svgtiny_GREEN(path->stroke) / 255.0,
  95                           svgtiny_BLUE(path->stroke) / 255.0,
  96                           1);
  97     cairo_set_line_width(cr, path->stroke_width);
  98     cairo_stroke_preserve(cr);
  99   }
 100 }
 101
 102 /**
 103  * @brief Parse a buffer of SVG data into a diagram_t structure.
 104  *
 105  * @param buffer
 106  *   The buffer containing the SVG document.
 107  *
 108  * @param bytecount
 109  *   The number of bytes in @c buffer.
 110  *
 111  * @return If successful, a pointer to a @c diagram_t structure is
 112  *   returned; if not, @c NULL is returned. You are expected to @c
 113  *   svgtiny_free the result if it is valid.
 114  */
 115 static diagram_t* svgtiny_diagram_from_buffer(char* buffer,
 116                                               size_t bytecount,
 117                                               int width,
 118                                               int height,
 119                                               GError** error) {
 120   diagram_t* diagram;
 121   svgtiny_code code;
 122
 123   diagram = svgtiny_create();
 124   if (!diagram) {
 125     g_set_error_literal(error,
 126                         GDK_PIXBUF_ERROR,
 127                         GDK_PIXBUF_ERROR_FAILED,
 128                         "svgtiny_create() failed");
 129     return NULL;
 130   }
 131
 132   code = svgtiny_parse(diagram, buffer, bytecount, "", width, height);
 133   free(buffer);
 134
 135   if (code != svgtiny_OK) {
 136     switch (code) {
 137     case svgtiny_OUT_OF_MEMORY:
 138       g_set_error_literal(error,
 139                           G_FILE_ERROR,
 140                           G_FILE_ERROR_NOMEM,
 141                           "out of memory in svgtiny_parse()");
 142       break;
 143     case svgtiny_LIBDOM_ERROR:
 144       g_set_error_literal(error,
 145                           GDK_PIXBUF_ERROR,
 146                           GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 147                           "libdom error in svgtiny_parse()");
 148       break;
 149     case svgtiny_NOT_SVG:
 150       g_set_error_literal(error,
 151                           GDK_PIXBUF_ERROR,
 152                           GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 153                           "encountered svgtiny_NOT_SVG in svgtiny_parse()");
 154       break;
 155     case svgtiny_SVG_ERROR:
 156       g_set_error(error,
 157                   GDK_PIXBUF_ERROR,
 158                   GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 159                   "SVG error in svgtiny_parse() on line %i: %s",
 160                   diagram->error_line,
 161                   diagram->error_message);
 162       break;
 163     }
 164     return NULL;
 165   }
 166
 167   return diagram;
 168 }
 169
 170 /**
 171  * @brief Create a cairo context from a libsvgtiny diagram.
 172  *
 173  * @param diagram
 174  *   A pointer to a valid libsvgtiny diagram.
 175  *
 176  * @return If successful, a pointer to a @c cairo_t context structure
 177  *   is returned; if not, @c NULL is returned. You are expected to @c
 178  *   cairo_destroy the result if it is valid.
 179  */
 180 static cairo_t* cairo_context_from_diagram(diagram_t* diagram) {
 181   cairo_t* cr;
 182   cairo_surface_t* surface;
 183   cairo_status_t crs;
 184   unsigned int i;
 185
 186   surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
 187                                        diagram->width,
 188                                        diagram->height);
 189
 190   crs = cairo_surface_status(surface);
 191   if (crs != CAIRO_STATUS_SUCCESS) {
 192     fprintf(stderr,
 193             "cairo_image_surface_create failed: %s\n",
 194             cairo_status_to_string(crs));
 195     cairo_surface_destroy(surface);
 196     return NULL;
 197   }
 198
 199   cr = cairo_create(surface);
 200   crs = cairo_status(cr);
 201
 202   /* Immediately destroy the surface which is now accessible as
 203      cr->target */
 204   cairo_surface_destroy(surface);
 205
 206   if (crs != CAIRO_STATUS_SUCCESS) {
 207     fprintf(stderr,
 208             "cairo_create failed: %s\n",
 209             cairo_status_to_string(crs));
 210     cairo_destroy(cr);
 211     return NULL;
 212   }
 213
 214   cairo_set_source_rgba(cr, 0, 0, 0, 0);
 215   cairo_paint(cr);
 216
 217   /* Loop through the shapes in the diagram... */
 218   for (i = 0; i != diagram->shape_count; i++) {
 219
 220     /* If this shape is a path, just render it. */
 221     if (diagram->shape[i].path) {
 222       render_path(cr, &diagram->shape[i]);
 223     }
 224
 225     /* If this shape is text... */
 226     if (diagram->shape[i].text) {
 227       /* Figure out what color to use from the R/G/B components of the
 228          shape's stroke. */
 229       cairo_set_source_rgba(cr,
 230                             svgtiny_RED(diagram->shape[i].stroke) / 255.0,
 231                             svgtiny_GREEN(diagram->shape[i].stroke) / 255.0,
 232                             svgtiny_BLUE(diagram->shape[i].stroke) / 255.0,
 233                             1);
 234       /* Then move to the actual position of the text within the
 235          shape... */
 236       cairo_move_to(cr,
 237                     diagram->shape[i].text_x,
 238                     diagram->shape[i].text_y);
 239
 240       /* and draw it. */
 241       cairo_show_text(cr, diagram->shape[i].text);
 242     }
 243   }
 244
 245
 246   /* Check the status again just for good measure? */
 247   crs = cairo_status(cr);
 248   if (crs != CAIRO_STATUS_SUCCESS) {
 249     fprintf(stderr,
 250             "cairo error: %s\n",
 251             cairo_status_to_string(crs));
 252     cairo_destroy(cr);
 253     return NULL;
 254   }
 255
 256   return cr;
 257 }
 258
 259 /**
 260  * @brief Create a GdkPixbuf from a buffer of SVG data.
 261  *
 262  * @param buffer
 263  *   The buffer containing the SVG document.
 264  *
 265  * @param bytecount
 266  *   The number of bytes in @c buffer.
 267  *
 268  * @param error
 269  *   The address of a @c GError pointer that we use to return errors.
 270  *
 271  * @return If successful, a valid pointer to a @c GdkPixbuf is
 272  *   returned; if not, @c NULL is returned and @c error is populated.
 273  */
 274 static GdkPixbuf* gdk_pixbuf_from_svg_buffer(char* buffer,
 275                                              size_t bytecount,
 276                                              GError** error) {
 277   diagram_t* diagram;
 278   cairo_t* cr = 0;
 279   GdkPixbuf* pb;
 280   GError* sub_error = NULL;
 281
 282   diagram = svgtiny_diagram_from_buffer(buffer,
 283                                         bytecount,
 284                                         VIEWPORT_WIDTH,
 285                                         VIEWPORT_HEIGHT,
 286                                         &sub_error);
 287   if (!diagram) {
 288     g_propagate_error(error, sub_error);
 289     return NULL;
 290   }
 291
 292   cr = cairo_context_from_diagram(diagram);
 293   if (!cr) {
 294     svgtiny_free(diagram);
 295     g_set_error_literal(error,
 296                         GDK_PIXBUF_ERROR,
 297                         GDK_PIXBUF_ERROR_CORRUPT_IMAGE,
 298                         "could not create Cairo surface from SVG diagram");
 299     return NULL;
 300   }
 301
 302
 303   /* We're using the viewport width and height and not the diagram
 304    * width/height for the image. The diagram can be of a different
 305    * size and aspect ratio than the viewport, and our main use case is
 306    * for icons that are generally square and reasonably sized. If the
 307    * diagram is "small," then we want to scale it up until it fits
 308    * nicely in the viewport before rendering it. That's as opposed to
 309    * rendering the image small, and letting GDK scale it up. Of course
 310    * this reasoning makes the assumption that the viewport is usually
 311    * larger than the diagram.
 312   */
 313   pb = gdk_pixbuf_get_from_surface(cairo_get_target(cr),
 314                                    0,
 315                                    0,
 316                                    VIEWPORT_WIDTH,
 317                                    VIEWPORT_HEIGHT);
 318
 319
 320   if (!pb) {
 321     g_set_error_literal(error,
 322                         GDK_PIXBUF_ERROR,
 323                         GDK_PIXBUF_ERROR_FAILED,
 324                         "failed to obtain a GdkPixbuf from Cairo surface");
 325   }
 326
 327   return pb;
 328 }
 329
 330
 331 /**
 332  * @brief Create a GdkPixbuf from an SVG filestream.
 333  *
 334  * This is essentially a wrapper around @gdk_pixbuf_from_svg_buffer
 335  * that reads a @c FILE pointer into a buffer.
 336  *
 337  * @param fp
 338  *   A pointer to a @c FILE containing the SVG document.
 339  *
 340  * @param error
 341  *   The address of a @c GError pointer that we use to return errors.
 342  *
 343  * @return If successful, a valid pointer to a @c GdkPixbuf is
 344  *   returned; if not, @c NULL is returned and @c error is populated.
 345  */
 346 static GdkPixbuf* gdk_pixbuf_from_svg_file_stream(FILE *fp, GError** error) {
 347   size_t bytecount, bytesread;
 348   char* buffer;
 349
 350   /* Find the size of the file stream */
 351   fseek(fp, 0L, SEEK_END);
 352   bytecount = ftell(fp);
 353   rewind(fp);
 354
 355   /* YOLO, no error checking */
 356   buffer = g_malloc(bytecount);
 357
 358   bytesread = fread(buffer, 1, bytecount, fp);
 359   if (bytesread != bytecount) {
 360     g_set_error(error,
 361                 G_FILE_ERROR,
 362                 G_FILE_ERROR_FAILED,
 363                 "read only %zd of %zd bytes from stream",
 364                 bytesread,
 365                 bytecount);
 366     return NULL;
 367   }
 368
 369   return gdk_pixbuf_from_svg_buffer(buffer, bytecount, error);
 370 }
 371
 372
 373 static gpointer gdk_pixbuf_begin_load(GdkPixbufModuleSizeFunc size_func,
 374                                       GdkPixbufModulePreparedFunc prep_func,
 375                                       GdkPixbufModuleUpdatedFunc updated_func,
 376                                       gpointer user_data,
 377                                       GError **error) {
 378
 379   SvgTinyContext* context = g_new(SvgTinyContext, 1);
 380
 381   context->size_func      = size_func;
 382   context->prepared_func  = prep_func;
 383   context->updated_func   = updated_func;
 384   context->user_data      = user_data;
 385
 386   /* YOLO, no error checking */
 387   context->svg_data       = g_malloc(SVG_BUFFER_INCREMENT);
 388   context->svg_data_size  = 0;
 389
 390   return context;
 391 }
 392
 393 static gboolean gdk_pixbuf_load_increment(gpointer data,
 394                                           const guchar* buf,
 395                                           guint size,
 396                                           GError** error) {
 397   size_t increment = 0;
 398   SvgTinyContext* context = (SvgTinyContext*)data;
 399
 400   if (context->svg_data_size + size > context->svg_data_max) {
 401     if (size > SVG_BUFFER_INCREMENT) {
 402       increment = size;
 403     }
 404     else {
 405       increment = SVG_BUFFER_INCREMENT;
 406     }
 407
 408     /* YOLO, no error checking */
 409     context->svg_data = g_realloc(context->svg_data,
 410                                   context->svg_data_max + increment);
 411
 412     context->svg_data_max += increment;
 413   }
 414
 415   memcpy(context->svg_data + context->svg_data_size, buf, size);
 416   context->svg_data_size += size;
 417
 418   return TRUE;
 419 }
 420
 421 static void emit_updated(SvgTinyContext* context, GdkPixbuf* pixbuf) {
 422   if (context->updated_func != NULL) {
 423     (*context->updated_func)(pixbuf,
 424                              0,
 425                              0,
 426                              gdk_pixbuf_get_width(pixbuf),
 427                              gdk_pixbuf_get_height(pixbuf),
 428                              context->user_data);
 429   }
 430 }
 431
 432 static void emit_prepared(SvgTinyContext* context, GdkPixbuf* pixbuf) {
 433   if (context->prepared_func != NULL) {
 434     (*context->prepared_func)(pixbuf, NULL, context->user_data);
 435   }
 436 }
 437
 438
 439 /*
 440 static void emit_size(SvgTinyContext* context, GdkPixbuf* pixbuf) {
 441   int w = gdk_pixbuf_get_width(pixbuf);
 442   int h = gdk_pixbuf_get_height(pixbuf);
 443   if (context->size_func != NULL) {
 444     (*context->size_func)(&w, &h, context->user_data);
 445   }
 446 }
 447 */
 448
 449
 450 static gboolean gdk_pixbuf_stop_load(gpointer data, GError **error) {
 451   SvgTinyContext* context = (SvgTinyContext*)data;
 452   GdkPixbuf* pixbuf = NULL;
 453   gboolean result = TRUE;
 454   GError* sub_error = NULL;
 455
 456   pixbuf = gdk_pixbuf_from_svg_buffer(context->svg_data,
 457                                       context->svg_data_size,
 458                                       &sub_error);
 459
 460   if (pixbuf != NULL) {
 461     /*emit_size(context, pixbuf);*/
 462     emit_prepared(context, pixbuf);
 463     emit_updated(context, pixbuf);
 464     g_object_unref(pixbuf);
 465   }
 466   else {
 467     g_propagate_error(error, sub_error);
 468     result = FALSE;
 469   }
 470   g_free(context);
 471
 472   return result;
 473 }
 474
 475
 476 G_MODULE_EXPORT void fill_vtable(GdkPixbufModule* module);
 477 void fill_vtable(GdkPixbufModule* module) {
 478   module->begin_load = gdk_pixbuf_begin_load;
 479   module->load_increment = gdk_pixbuf_load_increment;
 480   module->stop_load = gdk_pixbuf_stop_load;
 481   module->load = gdk_pixbuf_from_svg_file_stream;
 482 }
 483
 484 G_MODULE_EXPORT void fill_info(GdkPixbufFormat *info);
 485 void fill_info(GdkPixbufFormat* info) {
 486   /* Borrowed from librsvg-2.40.21 */
 487   static const GdkPixbufModulePattern signature[] = {
 488     {  " <svg",  "*    ", 100 },
 489     {  " <!DOCTYPE svg",  "*             ", 100 },
 490     { NULL, NULL, 0 }
 491   };
 492
 493   /* I'm not sure if we should support gzipped svg here? */
 494   static const gchar *mime_types[] = {
 495     "image/svg+xml",
 496     "image/svg",
 497     "image/svg-xml",
 498     "image/vnd.adobe.svg+xml",
 499     "text/xml-svg",
 500     "image/svg+xml-compressed",
 501     NULL
 502   };
 503
 504   static const gchar *extensions[] = {
 505     "svg",
 506     "svgz",
 507     "svg.gz",
 508     NULL
 509   };
 510
 511   info->name        = "svg";
 512   info->signature   = (GdkPixbufModulePattern*)signature;
 513   info->description = "Scalable Vector Graphics";
 514   info->mime_types  = (gchar**)mime_types;
 515   info->extensions  = (gchar**)extensions;
 516   info->flags       = GDK_PIXBUF_FORMAT_SCALABLE;
 517   info->license     = "AGPL3";
 518 }
 519
 520
 521 int main(int argc, char** argv) {
 522   char* svgpath;
 523   char* pngpath;
 524   FILE* fp;
 525   GError* err = NULL;
 526   GdkPixbuf* pb;
 527
 528   /* Parse arguments, and maybe print usage */
 529   if (argc < 3) {
 530     printf("Usage: %s INPUT OUTPUT\n", argv[0]);
 531     printf("Convert an SVG file (INPUT) to a PNG file (OUTPUT)\n");
 532     return 2;
 533   }
 534
 535   svgpath = argv[1];
 536   pngpath = argv[2];
 537
 538   fp = fopen(svgpath, "rb");
 539   if (!fp) {
 540     perror(svgpath);
 541     return 1;
 542   }
 543
 544   pb = gdk_pixbuf_from_svg_file_stream(fp, &err);
 545   if (!pb) {
 546     fprintf(stderr,
 547             "Error %d in gdk_pixbuf_from_svg_file_stream: %s\n",
 548             err->code,
 549             err->message);
 550     g_error_free(err);
 551     return 1;
 552   }
 553
 554   gdk_pixbuf_save(pb, pngpath, "png", NULL, NULL);
 555   g_object_unref(pb);
 556   return 0;
 557 }