src/helper/png-write.cpp

   1 #define __SP_PNG_WRITE_C__
   2
   3 /*
   4  * PNG file format utilities
   5  *
   6  * Authors:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   Whoever wrote this example in libpng documentation
   9  *
  10  * Copyright (C) 1999-2002 authors
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 #ifdef HAVE_CONFIG_H
  16 # include "config.h"
  17 #endif
  18
  19 #include <interface.h>
  20 #include <libnr/nr-pixops.h>
  21 #include <libnr/nr-translate-scale-ops.h>
  22 #include <glib/gmessages.h>
  23 #include <png.h>
  24 #include "png-write.h"
  25 #include "io/sys.h"
  26 #include <display/nr-arena-item.h>
  27 #include <display/nr-arena.h>
  28 #include <document.h>
  29 #include <sp-item.h>
  30 #include <sp-root.h>
  31 #include <sp-defs.h>
  32 #include "prefs-utils.h"
  33
  34 /* This is an example of how to use libpng to read and write PNG files.
  35  * The file libpng.txt is much more verbose then this.  If you have not
  36  * read it, do so first.  This was designed to be a starting point of an
  37  * implementation.  This is not officially part of libpng, and therefore
  38  * does not require a copyright notice.
  39  *
  40  * This file does not currently compile, because it is missing certain
  41  * parts, like allocating memory to hold an image.  You will have to
  42  * supply these parts to get it to compile.  For an example of a minimal
  43  * working PNG reader/writer, see pngtest.c, included in this distribution.
  44  */
  45
  46 static unsigned int const MAX_STRIPE_SIZE = 1024*1024;
  47
  48 struct SPEBP {
  49     unsigned long int width, height, sheight;
  50     guchar r, g, b, a;
  51     NRArenaItem *root; // the root arena item to show; it is assumed that all unneeded items are hidden
  52     guchar *px;
  53     unsigned (*status)(float, void *);
  54     void *data;
  55 };
  56
  57 /* write a png file */
  58
  59 typedef struct SPPNGBD {
  60     guchar const *px;
  61     int rowstride;
  62 } SPPNGBD;
  63
  64 static bool
  65 sp_png_write_rgba_striped(gchar const *filename, unsigned long int width, unsigned long int height, double xdpi, double ydpi,
  66                           int (* get_rows)(guchar const **rows, int row, int num_rows, void *data),
  67                           void *data)
  68 {
  69     struct SPEBP *ebp = (struct SPEBP *) data;
  70     FILE *fp;
  71     png_structp png_ptr;
  72     png_infop info_ptr;
  73     png_color_8 sig_bit;
  74     png_text text_ptr[3];
  75     png_uint_32 r;
  76
  77     g_return_val_if_fail(filename != NULL, false);
  78
  79     /* open the file */
  80
  81     Inkscape::IO::dump_fopen_call(filename, "M");
  82     fp = Inkscape::IO::fopen_utf8name(filename, "wb");
  83     g_return_val_if_fail(fp != NULL, false);
  84
  85     /* Create and initialize the png_struct with the desired error handler
  86      * functions.  If you want to use the default stderr and longjump method,
  87      * you can supply NULL for the last three parameters.  We also check that
  88      * the library version is compatible with the one used at compile time,
  89      * in case we are using dynamically linked libraries.  REQUIRED.
  90      */
  91     png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
  92
  93     if (png_ptr == NULL) {
  94         fclose(fp);
  95         return false;
  96     }
  97
  98     /* Allocate/initialize the image information data.  REQUIRED */
  99     info_ptr = png_create_info_struct(png_ptr);
 100     if (info_ptr == NULL) {
 101         fclose(fp);
 102         png_destroy_write_struct(&png_ptr, NULL);
 103         return false;
 104     }
 105
 106     /* Set error handling.  REQUIRED if you aren't supplying your own
 107      * error hadnling functions in the png_create_write_struct() call.
 108      */
 109     if (setjmp(png_ptr->jmpbuf)) {
 110         /* If we get here, we had a problem reading the file */
 111         fclose(fp);
 112         png_destroy_write_struct(&png_ptr, &info_ptr);
 113         return false;
 114     }
 115
 116     /* set up the output control if you are using standard C streams */
 117     png_init_io(png_ptr, fp);
 118
 119     /* Set the image information here.  Width and height are up to 2^31,
 120      * bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
 121      * the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
 122      * PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
 123      * or PNG_COLOR_TYPE_RGB_ALPHA.  interlace is either PNG_INTERLACE_NONE or
 124      * PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
 125      * currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
 126      */
 127     png_set_IHDR(png_ptr, info_ptr,
 128                  width,
 129                  height,
 130                  8, /* bit_depth */
 131                  PNG_COLOR_TYPE_RGB_ALPHA,
 132                  PNG_INTERLACE_NONE,
 133                  PNG_COMPRESSION_TYPE_BASE,
 134                  PNG_FILTER_TYPE_BASE);
 135
 136     /* otherwise, if we are dealing with a color image then */
 137     sig_bit.red = 8;
 138     sig_bit.green = 8;
 139     sig_bit.blue = 8;
 140     /* if the image has an alpha channel then */
 141     sig_bit.alpha = 8;
 142     png_set_sBIT(png_ptr, info_ptr, &sig_bit);
 143
 144     /* Made by Inkscape comment */
 145     text_ptr[0].key = "Software";
 146     text_ptr[0].text = "www.inkscape.org";
 147     text_ptr[0].compression = PNG_TEXT_COMPRESSION_NONE;
 148     png_set_text(png_ptr, info_ptr, text_ptr, 1);
 149
 150     /* other optional chunks like cHRM, bKGD, tRNS, tIME, oFFs, pHYs, */
 151     /* note that if sRGB is present the cHRM chunk must be ignored
 152      * on read and must be written in accordance with the sRGB profile */
 153     png_set_pHYs(png_ptr, info_ptr, unsigned(xdpi / 0.0254 + 0.5), unsigned(ydpi / 0.0254 + 0.5), PNG_RESOLUTION_METER);
 154
 155     /* Write the file header information.  REQUIRED */
 156     png_write_info(png_ptr, info_ptr);
 157
 158     /* Once we write out the header, the compression type on the text
 159      * chunks gets changed to PNG_TEXT_COMPRESSION_NONE_WR or
 160      * PNG_TEXT_COMPRESSION_zTXt_WR, so it doesn't get written out again
 161      * at the end.
 162      */
 163
 164     /* set up the transformations you want.  Note that these are
 165      * all optional.  Only call them if you want them.
 166      */
 167
 168     /* --- CUT --- */
 169
 170     /* The easiest way to write the image (you may have a different memory
 171      * layout, however, so choose what fits your needs best).  You need to
 172      * use the first method if you aren't handling interlacing yourself.
 173      */
 174
 175     png_bytep* row_pointers = new png_bytep[ebp->sheight];
 176
 177     r = 0;
 178     while (r < static_cast< png_uint_32 > (height) ) {
 179         int n = get_rows((unsigned char const **) row_pointers, r, height-r, data);
 180         if (!n) break;
 181         png_write_rows(png_ptr, row_pointers, n);
 182         r += n;
 183     }
 184
 185     delete[] row_pointers;
 186
 187     /* You can write optional chunks like tEXt, zTXt, and tIME at the end
 188      * as well.
 189      */
 190
 191     /* It is REQUIRED to call this to finish writing the rest of the file */
 192     png_write_end(png_ptr, info_ptr);
 193
 194     /* if you allocated any text comments, free them here */
 195
 196     /* clean up after the write, and free any memory allocated */
 197     png_destroy_write_struct(&png_ptr, &info_ptr);
 198
 199     /* close the file */
 200     fclose(fp);
 201
 202     /* that's it */
 203     return true;
 204 }
 205
 206
 207 /**
 208  *
 209  */
 210 static int
 211 sp_export_get_rows(guchar const **rows, int row, int num_rows, void *data)
 212 {
 213     struct SPEBP *ebp = (struct SPEBP *) data;
 214
 215     if (ebp->status) {
 216         if (!ebp->status((float) row / ebp->height, ebp->data)) return 0;
 217     }
 218
 219     num_rows = MIN(num_rows, static_cast<int>(ebp->sheight));
 220     num_rows = MIN(num_rows, static_cast<int>(ebp->height - row));
 221
 222     /* Set area of interest */
 223     // bbox is now set to the entire image to prevent discontinuities
 224     // in the image when blur is used (the borders may still be a bit
 225     // off, but that's less noticeable).
 226     NRRectL bbox;
 227     bbox.x0 = 0;
 228     bbox.y0 = row;
 229     bbox.x1 = ebp->width;
 230     bbox.y1 = row + num_rows;
 231     /* Update to renderable state */
 232     NRGC gc(NULL);
 233     gc.transform.set_identity();
 234
 235     nr_arena_item_invoke_update(ebp->root, &bbox, &gc,
 236            NR_ARENA_ITEM_STATE_ALL, NR_ARENA_ITEM_STATE_NONE);
 237
 238     NRPixBlock pb;
 239     nr_pixblock_setup_extern(&pb, NR_PIXBLOCK_MODE_R8G8B8A8N,
 240                              bbox.x0, bbox.y0, bbox.x1, bbox.y1,
 241                              ebp->px, 4 * ebp->width, FALSE, FALSE);
 242
 243     for (int r = 0; r < num_rows; r++) {
 244         guchar *p = NR_PIXBLOCK_PX(&pb) + r * pb.rs;
 245         for (int c = 0; c < static_cast<int>(ebp->width); c++) {
 246             *p++ = ebp->r;
 247             *p++ = ebp->g;
 248             *p++ = ebp->b;
 249             *p++ = ebp->a;
 250         }
 251     }
 252
 253     /* Render */
 254     nr_arena_item_invoke_render(NULL, ebp->root, &bbox, &pb, 0);
 255
 256     for (int r = 0; r < num_rows; r++) {
 257         rows[r] = NR_PIXBLOCK_PX(&pb) + r * pb.rs;
 258     }
 259
 260     nr_pixblock_release(&pb);
 261
 262     return num_rows;
 263 }
 264
 265 /**
 266  * Hide all items that are not listed in list, recursively, skipping groups and defs.
 267  */
 268 static void
 269 hide_other_items_recursively(SPObject *o, GSList *list, unsigned dkey)
 270 {
 271     if ( SP_IS_ITEM(o)
 272          && !SP_IS_DEFS(o)
 273          && !SP_IS_ROOT(o)
 274          && !SP_IS_GROUP(o)
 275          && !g_slist_find(list, o) )
 276     {
 277         sp_item_invoke_hide(SP_ITEM(o), dkey);
 278     }
 279
 280     // recurse
 281     if (!g_slist_find(list, o)) {
 282         for (SPObject *child = sp_object_first_child(o) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
 283             hide_other_items_recursively(child, list, dkey);
 284         }
 285     }
 286 }
 287
 288
 289 /**
 290  * Export the given document as a Portable Network Graphics (PNG) file.
 291  *
 292  * \return true if succeeded (or if no action was taken), false if an error occurred.
 293  */
 294 bool
 295 sp_export_png_file(SPDocument *doc, gchar const *filename,
 296                    double x0, double y0, double x1, double y1,
 297                    unsigned long width, unsigned long height, double xdpi, double ydpi,
 298                    unsigned long bgcolor,
 299                    unsigned (*status)(float, void *),
 300                    void *data, bool force_overwrite,
 301                    GSList *items_only)
 302 {
 303     g_return_val_if_fail(doc != NULL, false);
 304     g_return_val_if_fail(filename != NULL, false);
 305     g_return_val_if_fail(width >= 1, false);
 306     g_return_val_if_fail(height >= 1, false);
 307
 308     if (!force_overwrite && !sp_ui_overwrite_file(filename)) {
 309         /* Remark: We return true so as not to invoke an error dialog in case export is cancelled
 310            by the user; currently this is safe because the callers only act when false is returned.
 311            If this changes in the future we need better distinction of return types (e.g., use int)
 312         */
 313         return true;
 314     }
 315
 316     // export with maximum blur rendering quality
 317     int saved_quality = prefs_get_int_attribute("options.blurquality", "value", 0);
 318     prefs_set_int_attribute("options.blurquality", "value", 2);
 319
 320     sp_document_ensure_up_to_date(doc);
 321
 322     /* Go to document coordinates */
 323     {
 324         gdouble const t = y0;
 325         y0 = sp_document_height(doc) - y1;
 326         y1 = sp_document_height(doc) - t;
 327     }
 328
 329     /*
 330      * 1) a[0] * x0 + a[2] * y1 + a[4] = 0.0
 331      * 2) a[1] * x0 + a[3] * y1 + a[5] = 0.0
 332      * 3) a[0] * x1 + a[2] * y1 + a[4] = width
 333      * 4) a[1] * x0 + a[3] * y0 + a[5] = height
 334      * 5) a[1] = 0.0;
 335      * 6) a[2] = 0.0;
 336      *
 337      * (1,3) a[0] * x1 - a[0] * x0 = width
 338      * a[0] = width / (x1 - x0)
 339      * (2,4) a[3] * y0 - a[3] * y1 = height
 340      * a[3] = height / (y0 - y1)
 341      * (1) a[4] = -a[0] * x0
 342      * (2) a[5] = -a[3] * y1
 343      */
 344
 345     NR::Matrix const affine(NR::translate(-x0, -y0)
 346                             * NR::scale(width / (x1 - x0),
 347                                         height / (y1 - y0)));
 348
 349     //SP_PRINT_MATRIX("SVG2PNG", &affine);
 350
 351     struct SPEBP ebp;
 352     ebp.width  = width;
 353     ebp.height = height;
 354     ebp.r      = NR_RGBA32_R(bgcolor);
 355     ebp.g      = NR_RGBA32_G(bgcolor);
 356     ebp.b      = NR_RGBA32_B(bgcolor);
 357     ebp.a      = NR_RGBA32_A(bgcolor);
 358
 359     /* Create new arena */
 360     NRArena *const arena = NRArena::create();
 361     unsigned const dkey = sp_item_display_key_new(1);
 362
 363     /* Create ArenaItems and set transform */
 364     ebp.root = sp_item_invoke_show(SP_ITEM(sp_document_root(doc)), arena, dkey, SP_ITEM_SHOW_DISPLAY);
 365     nr_arena_item_set_transform(NR_ARENA_ITEM(ebp.root), affine);
 366
 367     // We show all and then hide all items we don't want, instead of showing only requested items,
 368     // because that would not work if the shown item references something in defs
 369     if (items_only) {
 370         hide_other_items_recursively(sp_document_root(doc), items_only, dkey);
 371     }
 372
 373     ebp.status = status;
 374     ebp.data   = data;
 375
 376     bool write_status;
 377     if ((width < 256) || ((width * height) < 32768)) {
 378         ebp.px = nr_pixelstore_64K_new(FALSE, 0);
 379         ebp.sheight = 65536 / (4 * width);
 380         write_status = sp_png_write_rgba_striped(filename, width, height, xdpi, ydpi, sp_export_get_rows, &ebp);
 381         nr_pixelstore_64K_free(ebp.px);
 382     } else {
 383         ebp.px = g_new(guchar, 4 * 64 * width);
 384         ebp.sheight = 64;
 385         write_status = sp_png_write_rgba_striped(filename, width, height, xdpi, ydpi, sp_export_get_rows, &ebp);
 386         g_free(ebp.px);
 387     }
 388
 389     // Hide items
 390     sp_item_invoke_hide(SP_ITEM(sp_document_root(doc)), dkey);
 391
 392     /* Free Arena and ArenaItem */
 393     nr_arena_item_unref(ebp.root);
 394     nr_object_unref((NRObject *) arena);
 395
 396     // restore saved blur quality
 397     prefs_set_int_attribute("options.blurquality", "value", saved_quality);
 398
 399     return write_status;
 400 }
 401
 402
 403 /*
 404   Local Variables:
 405   mode:c++
 406   c-file-style:"stroustrup"
 407   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 408   indent-tabs-mode:nil
 409   fill-column:99
 410   End:
 411 */
 412 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :