Encapsulate the shared memory hack for Cairo and GdkPixbuf in a class

called Inkscape::Pixbuf. Replace usage in the code as appropriate.

(bzr r12531)

1 files changed, 58 insertions, 285 deletions

diff --git a/src/sp-image.cpp b/src/sp-image.cpp
index 0e692eb40..57bcd69b9 100644
--- a/src/sp-image.cpp
+++ b/src/sp-image.cpp
@@ -17,9 +17,6 @@
 # include "config.h"
 #endif
 
-// This has to be included prior to anything that includes setjmp.h, it croaks otherwise
-#include <png.h>
-
 #include <cstring>
 #include <algorithm>
 #include <string>
@@ -90,8 +87,7 @@ static Inkscape::DrawingItem *sp_image_show (SPItem *item, Inkscape::Drawing &dr
 static Geom::Affine sp_image_set_transform (SPItem *item, Geom::Affine const &xform);
 static void sp_image_set_curve(SPImage *image);
 
-static GdkPixbuf *sp_image_repr_read_image( time_t& modTime, gchar*& pixPath, const gchar *href, const gchar *absref, const gchar *base );
-static GdkPixbuf *sp_image_pixbuf_force_rgba (GdkPixbuf * pixbuf);
+static Inkscape::Pixbuf *sp_image_repr_read_image(gchar const *href, gchar const *absref, gchar const *base );
 static void sp_image_update_arenaitem (SPImage *img, Inkscape::DrawingImage *ai);
 static void sp_image_update_canvas_image (SPImage *image);
 static GdkPixbuf * sp_image_repr_read_dataURI (const gchar * uri_data);
@@ -130,65 +126,6 @@ extern guint update_in_progress;
 #define DEBUG_MESSAGE_SCISLAC(key, ...)
 #endif // DEBUG_LCMS
 
-namespace Inkscape {
-namespace IO {
-
-GdkPixbuf* pixbuf_new_from_file(const char *filename, time_t &modTime, gchar*& pixPath)
-{
-    GdkPixbuf* buf = NULL;
-    modTime = 0;
-    if ( pixPath ) {
-        g_free(pixPath);
-        pixPath = NULL;
-    }
-
-    //test correctness of filename
-    if (!g_file_test (filename, G_FILE_TEST_EXISTS)){ 
-        return NULL;
-    }
-    struct stat stdir;
-    int val = g_stat(filename, &stdir);
-    if (stdir.st_mode & S_IFDIR){
-        g_warning("Linked image file %s is a directory", filename);
-        return NULL;
-    }
-
-    // we need to load the entire pixbuf into memory
-    gchar *data = NULL;
-    gsize len = 0;
-
-    if (g_file_get_contents(filename, &data, &len, NULL)) {
-        if (!val) {
-            modTime = stdir.st_mtime;
-            pixPath = g_strdup(filename);
-        }
-
-        GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
-        gdk_pixbuf_loader_write(loader, (guchar *) data, len, NULL);
-        gdk_pixbuf_loader_close(loader, NULL);
-
-        buf = gdk_pixbuf_loader_get_pixbuf(loader);
-        if (buf) {
-            g_object_ref(buf);
-            buf = sp_image_pixbuf_force_rgba(buf);
-            pixbuf_set_mime_data(buf, (guchar *) data, len, gdk_pixbuf_loader_get_format(loader));
-        } else {
-            g_free(data);
-            g_warning("Error loading pixbuf");
-        }
-
-        // TODO: we could also read DPI, ICC profile, gamma correction, and other information
-        // from the file. This can be done by using format-specific libraries e.g. libpng.
-    } else {
-        g_warning("Unable to open linked file: %s", filename);
-    }
-
-    return buf;
-}
-
-}
-}
-
 G_DEFINE_TYPE(SPImage, sp_image, SP_TYPE_ITEM);
 
 static void sp_image_class_init( SPImageClass * klass )
@@ -229,8 +166,6 @@ static void sp_image_init( SPImage *image )
     image->color_profile = 0;
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
     image->pixbuf = 0;
-    image->pixPath = 0;
-    image->lastMod = 0;
 }
 
 static void sp_image_build( SPObject *object, SPDocument *document, Inkscape::XML::Node *repr )
@@ -266,8 +201,7 @@ static void sp_image_release( SPObject *object )
     }
 
     if (image->pixbuf) {
-        g_object_set_data(G_OBJECT(image->pixbuf), "cairo_surface", NULL);
-        g_object_unref (image->pixbuf);
+        delete image->pixbuf;
         image->pixbuf = NULL;
     }
 
@@ -278,11 +212,6 @@ static void sp_image_release( SPObject *object )
     }
 #endif // defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
-    if (image->pixPath) {
-        g_free(image->pixPath);
-        image->pixPath = 0;
-    }
-
     if (image->curve) {
         image->curve = image->curve->unref();
     }
@@ -427,24 +356,13 @@ static void sp_image_update( SPObject *object, SPCtx *ctx, unsigned int flags )
 
     if (flags & SP_IMAGE_HREF_MODIFIED_FLAG) {
         if (image->pixbuf) {
-            g_object_unref (image->pixbuf);
+            delete image->pixbuf;
             image->pixbuf = NULL;
         }
-        if ( image->pixPath ) {
-            g_free(image->pixPath);
-            image->pixPath = 0;
-        }
-        image->lastMod = 0;
         if (image->href) {
-            GdkPixbuf *pixbuf;
+            Inkscape::Pixbuf *pixbuf = NULL;
             pixbuf = sp_image_repr_read_image (
-                image->lastMod,
-                image->pixPath,
-
-                //XML Tree being used directly while it shouldn't be.
                 object->getRepr()->attribute("xlink:href"),
-
-                //XML Tree being used directly while it shouldn't be.
                 object->getRepr()->attribute("sodipodi:absref"),
                 doc->getBase());
             if (pixbuf) {
@@ -452,10 +370,13 @@ static void sp_image_update( SPObject *object, SPCtx *ctx, unsigned int flags )
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
                 if ( image->color_profile )
                 {
-                    int imagewidth = gdk_pixbuf_get_width( pixbuf );
-                    int imageheight = gdk_pixbuf_get_height( pixbuf );
-                    int rowstride = gdk_pixbuf_get_rowstride( pixbuf );
-                    guchar* px = gdk_pixbuf_get_pixels( pixbuf );
+                    // TODO: this will prevent using MIME data when exporting.
+                    // Integrate color correction into loading.
+                    pixbuf->ensurePixelFormat(Inkscape::Pixbuf::PF_GDK);
+                    int imagewidth = pixbuf->width();
+                    int imageheight = pixbuf->height();
+                    int rowstride = pixbuf->rowstride();;
+                    guchar* px = pixbuf->pixels();
 
                     if ( px ) {
                         DEBUG_MESSAGE( lcmsFive, "in <image>'s sp_image_update. About to call colorprofile_get_handle()" );
@@ -522,10 +443,10 @@ static void sp_image_update( SPObject *object, SPCtx *ctx, unsigned int flags )
     if (image->pixbuf) {
         /* fixme: We are slightly violating spec here (Lauris) */
         if (!image->width._set) {
-            image->width.computed = gdk_pixbuf_get_width(image->pixbuf);
+            image->width.computed = image->pixbuf->width();
         }
         if (!image->height._set) {
-            image->height.computed = gdk_pixbuf_get_height(image->pixbuf);
+            image->height.computed = image->pixbuf->height();
         }
     }
 
@@ -536,8 +457,8 @@ static void sp_image_update( SPObject *object, SPCtx *ctx, unsigned int flags )
     image->ox = image->x.computed;
     image->oy = image->y.computed;
 
-    int pixwidth = gdk_pixbuf_get_width (image->pixbuf);
-    int pixheight = gdk_pixbuf_get_height (image->pixbuf);
+    int pixwidth = image->pixbuf->width();
+    int pixheight = image->pixbuf->height();
 
     image->sx = image->width.computed / pixwidth;
     image->sy = image->height.computed / pixheight;
@@ -678,16 +599,15 @@ static void sp_image_print( SPItem *item, SPPrintContext *ctx )
     SPImage *image = SP_IMAGE(item);
 
     if (image->pixbuf && (image->width.computed > 0.0) && (image->height.computed > 0.0) ) {
-        GdkPixbuf *pb = gdk_pixbuf_copy(image->pixbuf);
-        // GObject data is not copied, so we have to set the pixel format explicitly
-        g_object_set_data_full(G_OBJECT(pb), "pixel_format", g_strdup("argb32"), g_free);
-        ink_pixbuf_ensure_normal(pb);
+        Inkscape::Pixbuf *pb = new Inkscape::Pixbuf(*image->pixbuf);
+        pb->ensurePixelFormat(Inkscape::Pixbuf::PF_GDK);
 
-        guchar *px = gdk_pixbuf_get_pixels(pb);
-        int w = gdk_pixbuf_get_width(pb);
-        int h = gdk_pixbuf_get_height(pb);
-        int rs = gdk_pixbuf_get_rowstride(pb);
-        int pixskip = gdk_pixbuf_get_n_channels(pb) * gdk_pixbuf_get_bits_per_sample(pb) / 8;
+        guchar *px = pb->pixels();
+        int w = pb->width();
+        int h = pb->height();
+        int rs = pb->rowstride();
+        //int pixskip = gdk_pixbuf_get_n_channels(pb) * gdk_pixbuf_get_bits_per_sample(pb) / 8;
+        int pixskip = 4;
 
         if (image->aspect_align == SP_ASPECT_NONE) {
             Geom::Affine t;
@@ -739,8 +659,8 @@ static gchar *sp_image_description( SPItem *item )
     char *ret = ( image->pixbuf == NULL
                   ? g_strdup_printf(_("<b>Image with bad reference</b>: %s"), href_desc)
                   : g_strdup_printf(_("<b>Image</b> %d &#215; %d: %s"),
-                                    gdk_pixbuf_get_width(image->pixbuf),
-                                    gdk_pixbuf_get_height(image->pixbuf),
+                                    image->pixbuf->width(),
+                                    image->pixbuf->height(),
                                     href_desc) );
     g_free(href_desc);
     return ret;
@@ -756,22 +676,9 @@ static Inkscape::DrawingItem *sp_image_show( SPItem *item, Inkscape::Drawing &dr
     return ai;
 }
 
-/*
- * utility function to try loading image from href
- *
- * docbase/relative_src
- * absolute_src
- *
- */
-
-GdkPixbuf *sp_image_repr_read_image( time_t& modTime, char*& pixPath, const gchar *href, const gchar *absref, const gchar *base )
+Inkscape::Pixbuf *sp_image_repr_read_image(gchar const *href, gchar const *absref, gchar const *base)
 {
-    GdkPixbuf *pixbuf = 0;
-    modTime = 0;
-    if ( pixPath ) {
-        g_free(pixPath);
-        pixPath = 0;
-    }
+    Inkscape::Pixbuf *inkpb = 0;
 
     gchar const *filename = href;
     
@@ -779,18 +686,18 @@ GdkPixbuf *sp_image_repr_read_image( time_t& modTime, char*& pixPath, const gcha
         if (strncmp (filename,"file:",5) == 0) {
             gchar *fullname = g_filename_from_uri(filename, NULL, NULL);
             if (fullname) {
-                pixbuf = Inkscape::IO::pixbuf_new_from_file(fullname, modTime, pixPath);
+                inkpb = Inkscape::Pixbuf::create_from_file(fullname);
                 g_free(fullname);
-                if (pixbuf != NULL) {
-                    return pixbuf;
+                if (inkpb != NULL) {
+                    return inkpb;
                 }
             }
         } else if (strncmp (filename,"data:",5) == 0) {
             /* data URI - embedded image */
             filename += 5;
-            pixbuf = sp_image_repr_read_dataURI (filename);
-            if (pixbuf != NULL) {
-                return pixbuf;
+            inkpb = Inkscape::Pixbuf::create_from_data_uri(filename);
+            if (inkpb != NULL) {
+                return inkpb;
             }
         } else {
 
@@ -806,19 +713,19 @@ GdkPixbuf *sp_image_repr_read_image( time_t& modTime, char*& pixPath, const gcha
                 // different dir) or unset (when doc is not saved yet), so we check for base+href existence first,
                 // and if it fails, we also try to use bare href regardless of its g_path_is_absolute
                 if (g_file_test (fullname, G_FILE_TEST_EXISTS) && !g_file_test (fullname, G_FILE_TEST_IS_DIR)) {
-                    pixbuf = Inkscape::IO::pixbuf_new_from_file(fullname, modTime, pixPath);
+                    inkpb = Inkscape::Pixbuf::create_from_file(fullname);
                     g_free (fullname);
-                    if (pixbuf != NULL) {
-                        return pixbuf;
+                    if (inkpb != NULL) {
+                        return inkpb;
                     }
                 }
             }
 
             /* try filename as absolute */
             if (g_file_test (filename, G_FILE_TEST_EXISTS) && !g_file_test (filename, G_FILE_TEST_IS_DIR)) {
-                pixbuf = Inkscape::IO::pixbuf_new_from_file(filename, modTime, pixPath);
-                if (pixbuf != NULL) {
-                    return pixbuf;
+                inkpb = Inkscape::Pixbuf::create_from_file(filename);
+                if (inkpb != NULL) {
+                    return inkpb;
                 }
             }
         }
@@ -834,31 +741,20 @@ GdkPixbuf *sp_image_repr_read_image( time_t& modTime, char*& pixPath, const gcha
             g_warning ("xlink:href did not resolve to a valid image file, now trying sodipodi:absref=\"%s\"", absref);
         }
 
-        pixbuf = Inkscape::IO::pixbuf_new_from_file(filename, modTime, pixPath);
-        if (pixbuf != NULL) {
-            return pixbuf;
+        inkpb = Inkscape::Pixbuf::create_from_file(filename);
+        if (inkpb != NULL) {
+            return inkpb;
         }
     }
     /* Nope: We do not find any valid pixmap file :-( */
-    pixbuf = gdk_pixbuf_new_from_xpm_data((const gchar **) brokenimage_xpm);
+    GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data((const gchar **) brokenimage_xpm);
+    inkpb = new Inkscape::Pixbuf(pixbuf);
 
     /* It should be included xpm, so if it still does not does load, */
     /* our libraries are broken */
-    g_assert (pixbuf != NULL);
-
-    return pixbuf;
-}
+    g_assert (inkpb != NULL);
 
-static GdkPixbuf *sp_image_pixbuf_force_rgba( GdkPixbuf * pixbuf )
-{
-    GdkPixbuf* result;
-    if (gdk_pixbuf_get_has_alpha(pixbuf)) {
-        result = pixbuf;
-    } else {
-        result = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
-        g_object_unref(pixbuf);
-    }
-    return result;
+    return inkpb;
 }
 
 /* We assert that realpixbuf is either NULL or identical size to pixbuf */
@@ -866,7 +762,7 @@ static void
 sp_image_update_arenaitem (SPImage *image, Inkscape::DrawingImage *ai)
 {
     ai->setStyle(SP_OBJECT(image)->style);
-    ai->setARGB32Pixbuf(image->pixbuf);
+    ai->setPixbuf(image->pixbuf);
     ai->setOrigin(Geom::Point(image->ox, image->oy));
     ai->setScale(image->sx, image->sy);
     ai->setClipbox(image->clipbox);
@@ -957,113 +853,6 @@ static Geom::Affine sp_image_set_transform( SPItem *item, Geom::Affine const &xf
     return ret;
 }
 
-static GdkPixbuf *sp_image_repr_read_dataURI( const gchar * uri_data )
-{
-    GdkPixbuf * pixbuf = NULL;
-
-    gint data_is_image = 0;
-    gint data_is_base64 = 0;
-
-    const gchar * data = uri_data;
-
-    while (*data) {
-        if (strncmp(data,"base64",6) == 0) {
-            /* base64-encoding */
-            data_is_base64 = 1;
-            data_is_image = 1; // Illustrator produces embedded images without MIME type, so we assume it's image no matter what
-            data += 6;
-        }
-        else if (strncmp(data,"image/png",9) == 0) {
-            /* PNG image */
-            data_is_image = 1;
-            data += 9;
-        }
-        else if (strncmp(data,"image/jpg",9) == 0) {
-            /* JPEG image */
-            data_is_image = 1;
-            data += 9;
-        }
-        else if (strncmp(data,"image/jpeg",10) == 0) {
-            /* JPEG image */
-            data_is_image = 1;
-            data += 10;
-        }
-        else { /* unrecognized option; skip it */
-            while (*data) {
-                if (((*data) == ';') || ((*data) == ',')) {
-                    break;
-                }
-                data++;
-            }
-        }
-        if ((*data) == ';') {
-            data++;
-            continue;
-        }
-        if ((*data) == ',') {
-            data++;
-            break;
-        }
-    }
-
-    if ((*data) && data_is_image && data_is_base64) {
-        pixbuf = sp_image_repr_read_b64(data);
-    }
-
-    return pixbuf;
-}
-
-static GdkPixbuf *sp_image_repr_read_b64(gchar const *uri_data)
-{
-    GdkPixbuf *pixbuf = NULL;
-    GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
-
-    if (!loader) return NULL;
-
-    gsize decoded_len = 0;
-    guchar *decoded = g_base64_decode(uri_data, &decoded_len);
-
-    if (gdk_pixbuf_loader_write(loader, decoded, decoded_len, NULL)) {
-        gdk_pixbuf_loader_close(loader, NULL);
-        pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
-        g_object_ref(pixbuf);
-        pixbuf = sp_image_pixbuf_force_rgba(pixbuf);
-        pixbuf_set_mime_data(pixbuf, decoded, decoded_len, gdk_pixbuf_loader_get_format(loader));
-    } else {
-        g_free(decoded);
-    }
-    g_object_unref(loader);
-
-    return pixbuf;
-}
-
-// takes ownership of passed data
-static void pixbuf_set_mime_data(GdkPixbuf *pb, guchar *data, gsize len, GdkPixbufFormat *fmt)
-{
-    cairo_surface_t *s = ink_cairo_surface_get_for_pixbuf(pb);
-
-    gchar const *mimetype = NULL;
-    gchar *fmt_name = gdk_pixbuf_format_get_name(fmt);
-    Glib::ustring name = fmt_name;
-    g_free(fmt_name);
-
-    if (name == "jpeg") {
-        mimetype = CAIRO_MIME_TYPE_JPEG;
-    } else if (name == "jpeg2000") {
-        mimetype = CAIRO_MIME_TYPE_JP2;
-    } else if (name == "png") {
-        mimetype = CAIRO_MIME_TYPE_PNG;
-    }
-
-    if (mimetype != NULL) {
-        cairo_surface_set_mime_data(s, mimetype, data, len, g_free, data);
-        //g_message("Setting Cairo MIME data: %s", mimetype);
-    } else {
-        g_free(data);
-        //g_message("Not setting Cairo MIME data: unknown format %s", name.c_str());
-    }
-}
-
 static void sp_image_set_curve( SPImage *image )
 {
     //create a curve at the image's boundary for snapping
@@ -1099,31 +888,16 @@ SPCurve *sp_image_get_curve( SPImage *image )
     return result;
 }
 
-void sp_embed_image(Inkscape::XML::Node *image_node, GdkPixbuf *pb)
+void sp_embed_image(Inkscape::XML::Node *image_node, Inkscape::Pixbuf *pb)
 {
-    static gchar const *mimetypes[] = {
-        CAIRO_MIME_TYPE_JPEG, CAIRO_MIME_TYPE_JP2, CAIRO_MIME_TYPE_PNG, NULL };
-    static guint mimetypes_len = g_strv_length(const_cast<gchar**>(mimetypes));
-
     bool free_data = false;
 
     // check whether the pixbuf has MIME data
     guchar *data = NULL;
     gsize len = 0;
-    gchar const *data_mimetype = NULL;
-
-    cairo_surface_t *s = reinterpret_cast<cairo_surface_t*>(g_object_get_data(G_OBJECT(pb), "cairo_surface"));
-    if (s) {
-        for (guint i = 0; i < mimetypes_len; ++i) {
-            unsigned long len_long = 0;
-            cairo_surface_get_mime_data(s, mimetypes[i], const_cast<unsigned char const **>(&data), &len_long);
-            len = len_long; // this assumes that the added range of long is not needed. the code below assumes gsize range of values is sufficient.
-            if (data != NULL) {
-                data_mimetype = mimetypes[i];
-                break;
-            }
-        }
-    }
+    std::string data_mimetype;
+
+    data = const_cast<guchar *>(pb->getMimeData(len, data_mimetype));
 
     if (data == NULL) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -1131,8 +905,7 @@ void sp_embed_image(Inkscape::XML::Node *image_node, GdkPixbuf *pb)
 
         // if there is no supported MIME data, embed as PNG
         data_mimetype = "image/png";
-        ink_pixbuf_ensure_normal(pb);
-        gdk_pixbuf_save_to_buffer(pb, reinterpret_cast<gchar**>(&data), &len, "png", NULL,
+        gdk_pixbuf_save_to_buffer(pb->getPixbufRaw(), reinterpret_cast<gchar**>(&data), &len, "png", NULL,
             "quality", quality.c_str(), NULL);
         free_data = true;
     }
@@ -1140,11 +913,11 @@ void sp_embed_image(Inkscape::XML::Node *image_node, GdkPixbuf *pb)
     // Save base64 encoded data in image node
     // this formula taken from Glib docs
     gsize needed_size = len * 4 / 3 + len * 4 / (3 * 72) + 7;
-    needed_size += 5 + 8 + strlen(data_mimetype); // 5 bytes for data: + 8 for ;base64,
+    needed_size += 5 + 8 + data_mimetype.size(); // 5 bytes for data: + 8 for ;base64,
 
     gchar *buffer = (gchar *) g_malloc(needed_size);
     gchar *buf_work = buffer;
-    buf_work += g_sprintf(buffer, "data:%s;base64,", data_mimetype);
+    buf_work += g_sprintf(buffer, "data:%s;base64,", data_mimetype.c_str());
 
     gint state = 0;
     gint save = 0;
@@ -1164,18 +937,18 @@ void sp_embed_image(Inkscape::XML::Node *image_node, GdkPixbuf *pb)
 
 void sp_image_refresh_if_outdated( SPImage* image )
 {
-    if ( image->href && image->lastMod ) {
+    if ( image->href && image->pixbuf && image->pixbuf->modificationTime()) {
         // It *might* change
 
         struct stat st;
         memset(&st, 0, sizeof(st));
         int val = 0;
-        if (g_file_test (image->pixPath, G_FILE_TEST_EXISTS)){ 
-            val = g_stat(image->pixPath, &st);
+        if (g_file_test (image->pixbuf->originalPath().c_str(), G_FILE_TEST_EXISTS)){ 
+            val = g_stat(image->pixbuf->originalPath().c_str(), &st);
         }
         if ( !val ) {
             // stat call worked. Check time now
-            if ( st.st_mtime != image->lastMod ) {
+            if ( st.st_mtime != image->pixbuf->modificationTime() ) {
                 SPCtx *ctx = 0;
                 unsigned int flags = SP_IMAGE_HREF_MODIFIED_FLAG;
                 sp_image_update(image, ctx, flags);