static void append_basic_info (NemoImagePropertiesPage *page) { GdkPixbufFormat *format; char *name; char *desc; char *value; format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); value = g_strdup_printf ("%s (%s)", name, desc); g_free (name); g_free (desc); append_item (page, _("Image Type"), value); g_free (value); value = g_strdup_printf (ngettext ("%d pixel", "%d pixels", page->details->width), page->details->width); append_item (page, _("Width"), value); g_free (value); value = g_strdup_printf (ngettext ("%d pixel", "%d pixels", page->details->height), page->details->height); append_item (page, _("Height"), value); g_free (value); }
GdkPixbuf * tpaw_pixbuf_from_data_and_mime (gchar *data, gsize data_size, gchar **mime_type) { GdkPixbufLoader *loader; GdkPixbufFormat *format; GdkPixbuf *pixbuf = NULL; gchar **mime_types; GError *error = NULL; if (!data) return NULL; loader = gdk_pixbuf_loader_new (); if (!gdk_pixbuf_loader_write (loader, (guchar *) data, data_size, &error)) { DEBUG ("Failed to write to pixbuf loader: %s", error ? error->message : "No error given"); goto out; } if (!gdk_pixbuf_loader_close (loader, &error)) { DEBUG ("Failed to close pixbuf loader: %s", error ? error->message : "No error given"); goto out; } pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf) { g_object_ref (pixbuf); if (mime_type != NULL) { format = gdk_pixbuf_loader_get_format (loader); mime_types = gdk_pixbuf_format_get_mime_types (format); *mime_type = g_strdup (*mime_types); if (mime_types[1] != NULL) DEBUG ("Loader supports more than one mime " "type! Picking the first one, %s", *mime_type); g_strfreev (mime_types); } } out: g_clear_error (&error); g_object_unref (loader); return pixbuf; }
static void soi_info_cb (GdkPixbufLoader *loader, int width, int height, gpointer data) { SheetObjectImage *soi = SHEET_OBJECT_IMAGE (data); GdkPixbufFormat *format = gdk_pixbuf_loader_get_format (loader); char *name = gdk_pixbuf_format_get_name (format); g_free (soi->type); soi->type = name; }
/** Convert Base64 to pixbuf * @param b64 Base64 encoded data */ GdkPixbuf * pixbuf_decode_base64 (const gchar *b64) { /* see lib/prop_pixbuf.c(data_pixbuf) for a very similar implementation */ GdkPixbuf *pixbuf = NULL; GdkPixbufLoader *loader; GError *error = NULL; loader = gdk_pixbuf_loader_new (); if (loader) { gint state = 0; guint save = 0; # define BUF_SIZE 4096 guchar buf[BUF_SIZE]; gchar *in = (gchar *)b64; /* direct access, not involving another xmlStrDup/xmlFree */ gssize len = strlen (b64); do { gsize step = g_base64_decode_step (in, len > BUF_SIZE ? BUF_SIZE : len, buf, &state, &save); if (!gdk_pixbuf_loader_write (loader, buf, step, &error)) break; in += BUF_SIZE; len -= BUF_SIZE; } while (len > 0); if (gdk_pixbuf_loader_close (loader, error ? NULL : &error)) { GdkPixbufFormat *format = gdk_pixbuf_loader_get_format (loader); gchar *format_name = gdk_pixbuf_format_get_name (format); gchar **mime_types = gdk_pixbuf_format_get_mime_types (format); dia_log_message ("Loaded pixbuf from '%s' with '%s'\n", format_name, mime_types[0]); pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader)); /* attach the mime-type to the pixbuf */ g_object_set_data_full (G_OBJECT (pixbuf), "mime-type", g_strdup (mime_types[0]), (GDestroyNotify)g_free); g_strfreev (mime_types); g_free (format_name); } else { message_warning (_("Failed to load image form diagram:\n%s"), error->message); g_error_free (error); } g_object_unref (loader); } return pixbuf; # undef BUF_SIZE }
Pixbuf *Pixbuf::create_from_file(std::string const &fn) { Pixbuf *pb = NULL; // test correctness of filename if (!g_file_test(fn.c_str(), G_FILE_TEST_EXISTS)) { return NULL; } struct stat stdir; int val = g_stat(fn.c_str(), &stdir); if (val == 0 && stdir.st_mode & S_IFDIR){ return NULL; } // we need to load the entire file into memory, // since we'll store it as MIME data gchar *data = NULL; gsize len = 0; GError *error; if (g_file_get_contents(fn.c_str(), &data, &len, &error)) { GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(loader, (guchar *) data, len, NULL); gdk_pixbuf_loader_close(loader, NULL); GdkPixbuf *buf = gdk_pixbuf_loader_get_pixbuf(loader); if (buf) { g_object_ref(buf); pb = new Pixbuf(buf); pb->_mod_time = stdir.st_mtime; pb->_path = fn; GdkPixbufFormat *fmt = gdk_pixbuf_loader_get_format(loader); gchar *fmt_name = gdk_pixbuf_format_get_name(fmt); pb->_setMimeData((guchar *) data, len, fmt_name); g_free(fmt_name); } else { g_free(data); } g_object_unref(loader); // 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 { return NULL; } return pb; }
static void gst_gdk_pixbuf_type_find (GstTypeFind * tf, gpointer ignore) { guint8 *data; GdkPixbufLoader *pixbuf_loader; GdkPixbufFormat *format; data = gst_type_find_peek (tf, 0, GST_GDK_PIXBUF_TYPE_FIND_SIZE); if (data == NULL) return; GST_DEBUG ("creating new loader"); pixbuf_loader = gdk_pixbuf_loader_new (); gdk_pixbuf_loader_write (pixbuf_loader, data, GST_GDK_PIXBUF_TYPE_FIND_SIZE, NULL); format = gdk_pixbuf_loader_get_format (pixbuf_loader); if (format != NULL) { GstCaps *caps; gchar **p; gchar **mlist = gdk_pixbuf_format_get_mime_types (format); for (p = mlist; *p; ++p) { GST_DEBUG ("suggesting mime type %s", *p); caps = gst_caps_new_simple (*p, NULL); gst_type_find_suggest (tf, GST_TYPE_FIND_MINIMUM, caps); gst_caps_free (caps); } g_strfreev (mlist); } GST_DEBUG ("closing pixbuf loader, hope it doesn't hang ..."); /* librsvg 2.4.x has a bug where it triggers an endless loop in trying to close a gzip that's not an svg; fixed upstream but no good way to work around it */ gdk_pixbuf_loader_close (pixbuf_loader, NULL); GST_DEBUG ("closed pixbuf loader"); g_object_unref (G_OBJECT (pixbuf_loader)); }
static void load_finished (CajaImagePropertiesPage *page) { GdkPixbufFormat *format; char *name, *desc; gtk_widget_destroy (page->details->loading_label); if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); } if (page->details->got_size) { #ifdef HAVE_EXIF ExifData *exif_data; #endif /*HAVE_EXIF*/ format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); append_label_take_str (page->details->vbox, g_strdup_printf ("<b>%s</b> %s (%s)", _("Image Type:"), name, desc)); append_label_take_str (page->details->vbox, g_strdup_printf (ngettext ("<b>Width:</b> %d pixel", "<b>Width:</b> %d pixels", page->details->width), page->details->width)); append_label_take_str (page->details->vbox, g_strdup_printf (ngettext ("<b>Height:</b> %d pixel", "<b>Height:</b> %d pixels", page->details->height), page->details->height)); g_free (name); g_free (desc); #ifdef HAVE_EXIF exif_data = exif_loader_get_data (page->details->exifldr); append_exifdata_string (exif_data, page); exif_data_unref (exif_data); #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI append_xmpdata_string (page->details->xmp, page); #endif /*HAVE_EXEMPI*/ } else { append_label (page->details->vbox, _("Failed to load image information")); } if (page->details->loader != NULL) { g_object_unref (page->details->loader); page->details->loader = NULL; } #ifdef HAVE_EXIF if (page->details->exifldr != NULL) { exif_loader_unref (page->details->exifldr); page->details->exifldr = NULL; } #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI if (page->details->xmp != NULL) { xmp_free(page->details->xmp); page->details->xmp = NULL; } #endif /*HAVE_EXEMPI*/ }
GdkPixbuf * IE_ImpGraphic_GdkPixbuf::pixbufForByteBuf (UT_ByteBuf * pBB, std::string & mimetype) { if ( !pBB || !pBB->getLength() ) return NULL; GdkPixbuf * pixbuf = NULL; bool bIsXPM = false; const char * szBuf = reinterpret_cast<const char *>(pBB->getPointer(0)); if((pBB->getLength() > 9) && (strncmp (szBuf, "/* XPM */", 9) == 0)) { bIsXPM = true; } if(bIsXPM) { pixbuf = _loadXPM(pBB); } else { GError * err = 0; GdkPixbufLoader * ldr = 0; ldr = gdk_pixbuf_loader_new (); if (!ldr) { UT_DEBUGMSG (("GdkPixbuf: couldn't create loader! WTF?\n")); UT_ASSERT (ldr); return NULL ; } if (!gdk_pixbuf_loader_write (ldr, static_cast<const guchar *>(pBB->getPointer (0)), static_cast<gsize>(pBB->getLength ()), &err) ) { UT_DEBUGMSG(("DOM: couldn't write to loader: %s\n", err->message)); g_error_free(err); gdk_pixbuf_loader_close (ldr, NULL); g_object_unref (G_OBJECT(ldr)); mimetype.clear(); return NULL ; } gdk_pixbuf_loader_close (ldr, NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf (ldr); GdkPixbufFormat * format = gdk_pixbuf_loader_get_format(ldr); gchar ** mime_types = gdk_pixbuf_format_get_mime_types(format); gchar ** current = mime_types; while(*current) { if((strcmp(*current, "image/jpeg") == 0) || (strcmp(*current, "image/png") == 0)) { mimetype = *current; break; } current++; } g_strfreev(mime_types); // ref before closing the loader if ( pixbuf ) g_object_ref (G_OBJECT(pixbuf)); g_object_unref (G_OBJECT(ldr)); } return pixbuf; }
cairo_surface_t * rsvg_cairo_surface_new_from_href (RsvgHandle *handle, const char *href, GError **error) { char *data; gsize data_len; char *mime_type = NULL; GdkPixbufLoader *loader = NULL; GdkPixbuf *pixbuf = NULL; cairo_surface_t *surface = NULL; data = _rsvg_handle_acquire_data (handle, href, &mime_type, &data_len, error); if (data == NULL) return NULL; if (mime_type) { loader = gdk_pixbuf_loader_new_with_mime_type (mime_type, error); } else { loader = gdk_pixbuf_loader_new (); } if (loader == NULL) goto out; if (!gdk_pixbuf_loader_write (loader, (guchar *) data, data_len, error)) { gdk_pixbuf_loader_close (loader, NULL); goto out; } if (!gdk_pixbuf_loader_close (loader, error)) goto out; pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (!pixbuf) { g_set_error (error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_FAILED, _("Failed to load image '%s': reason not known, probably a corrupt image file"), href); goto out; } surface = rsvg_cairo_surface_from_pixbuf (pixbuf); if (mime_type == NULL) { /* Try to get the information from the loader */ GdkPixbufFormat *format; char **mime_types; if ((format = gdk_pixbuf_loader_get_format (loader)) != NULL) { mime_types = gdk_pixbuf_format_get_mime_types (format); if (mime_types != NULL) mime_type = g_strdup (mime_types[0]); g_strfreev (mime_types); } } if ((handle->priv->flags & RSVG_HANDLE_FLAG_KEEP_IMAGE_DATA) != 0 && mime_type != NULL && cairo_surface_set_mime_data (surface, mime_type, (guchar *) data, data_len, g_free, data) == CAIRO_STATUS_SUCCESS) { data = NULL; /* transferred to the surface */ } out: if (loader) g_object_unref (loader); g_free (mime_type); g_free (data); return surface; }
GdkPixbuf * eventd_nd_pixbuf_from_data(GVariant *var, gint width, gint height) { GdkPixbuf *pixbuf = NULL; GError *error = NULL; const gchar *mime_type; GVariant *invar; g_variant_get(var, "(m&sm&sv)", &mime_type, NULL, &invar); if ( g_strcmp0(mime_type, "image/x.eventd.pixbuf") == 0 ) { gboolean a; gint b, w, h, s, n; GVariant *data; g_variant_get(invar, "(iiibii@ay)", &w, &h, &s, &a, &b, &n, &data); /* This is the only format gdk-pixbuf can read */ if ( ( b == 8 ) && ( n == ( a ? 4 : 3 ) ) && ( h * s == (gint) g_variant_get_size(data) ) ) return gdk_pixbuf_new_from_data(g_variant_get_data(data), GDK_COLORSPACE_RGB, a, b, w, h, s, _eventd_nd_pixbuf_free_data, data); g_variant_unref(data); goto end; } if ( ! g_variant_is_of_type(invar, G_VARIANT_TYPE_BYTESTRING) ) goto end; GdkPixbufLoader *loader; const guchar *data; gsize length; data = g_variant_get_data(invar); length = g_variant_get_size(invar); if ( mime_type != NULL ) { loader = gdk_pixbuf_loader_new_with_mime_type(mime_type, &error); if ( loader == NULL ) { g_warning("Couldn't create loader for MIME type '%s': %s", mime_type, error->message); goto end; } GdkPixbufFormat *format; if ( ( ( width > 0 ) || ( height > 0 ) ) && ( ( format = gdk_pixbuf_loader_get_format(loader) ) != NULL ) && gdk_pixbuf_format_is_scalable(format) ) gdk_pixbuf_loader_set_size(loader, width, height); } else loader = gdk_pixbuf_loader_new(); if ( ! gdk_pixbuf_loader_write(loader, data, length, &error) ) { g_warning("Couldn't write image data: %s", error->message); goto error; } if ( ! gdk_pixbuf_loader_close(loader, &error) ) { g_warning("Couldn't load image data: %s", error->message); goto error; } pixbuf = g_object_ref(gdk_pixbuf_loader_get_pixbuf(loader)); error: g_object_unref(loader); end: g_variant_unref(invar); g_variant_unref(var); g_clear_error(&error); return pixbuf; }
static VALUE loader_get_format(VALUE self) { GdkPixbufFormat* format = gdk_pixbuf_loader_get_format(_SELF(self)); return BOXED2RVAL(format, GDK_TYPE_PIXBUF_FORMAT); }
static VALUE rg_format(VALUE self) { GdkPixbufFormat* format = gdk_pixbuf_loader_get_format(_SELF(self)); return GDKPIXBUFFORMAT2RVAL(format); }
static void append_xmp_value_pair (GString *string, XmpPtr xmp, const char *ns, const char *propname, char *descr) { uint32_t options; XmpStringPtr value; value = xmp_string_new(); #ifdef HAVE_EXEMPI_NEW_API if (xmp_get_property (xmp, ns, propname, value, &options)) { #else if (xmp_get_property_and_bits (xmp, ns, propname, value, &options)) { #endif if (XMP_IS_PROP_SIMPLE (options)) { g_string_append_printf (string, "<b>%s:</b> %s\n", descr, xmp_string_cstr (value)); } else if (XMP_IS_PROP_ARRAY (options)) { XmpIteratorPtr iter; iter = xmp_iterator_new (xmp, ns, propname, XMP_ITER_JUSTLEAFNODES); if (iter) { gboolean first = TRUE; g_string_append_printf (string, "<b>%s:</b> ", descr); while (xmp_iterator_next (iter, NULL, NULL, value, &options) && !XMP_IS_PROP_QUALIFIER(options)) { if (!first) { g_string_append_printf (string, ", "); } else { first = FALSE; } g_string_append_printf (string, "%s", xmp_string_cstr(value)); } xmp_iterator_free(iter); g_string_append_printf(string, "\n"); } } } xmp_string_free(value); } static void append_xmpdata_string(XmpPtr xmp, GString *string) { if(xmp != NULL) { append_xmp_value_pair(string, xmp, NS_IPTC4XMP, "Location", _("Location")); append_xmp_value_pair(string, xmp, NS_DC, "description", _("Description")); append_xmp_value_pair(string, xmp, NS_DC, "subject", _("Keywords")); append_xmp_value_pair(string, xmp, NS_DC, "creator", _("Creator")); append_xmp_value_pair(string, xmp, NS_DC, "rights", _("Copyright")); append_xmp_value_pair(string, xmp, NS_XAP,"Rating", _("Rating")); /* TODO add CC licenses */ } } #endif static void load_finished (NautilusImagePropertiesPage *page) { GdkPixbufFormat *format; char *name, *desc; GString *str; if (page->details->got_size) { #ifdef HAVE_EXIF ExifData *exif_data; #endif str = g_string_new (NULL); format = gdk_pixbuf_loader_get_format (page->details->loader); name = gdk_pixbuf_format_get_name (format); desc = gdk_pixbuf_format_get_description (format); g_string_append_printf (str, "<b>%s</b> %s (%s)\n", _("Image Type:"), name, desc); g_string_append_printf (str, ngettext ("<b>Width:</b> %d pixel\n", "<b>Width:</b> %d pixels\n", page->details->width), page->details->width); g_string_append_printf (str, ngettext ("<b>Height:</b> %d pixel\n", "<b>Height:</b> %d pixels\n", page->details->height), page->details->height); g_free (name); g_free (desc); #ifdef HAVE_EXIF exif_data = exif_loader_get_data (page->details->exifldr); append_exifdata_string (exif_data, str); exif_data_unref (exif_data); #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI append_xmpdata_string(page->details->xmp, str); #endif /*HAVE EXEMPI*/ gtk_label_set_markup (GTK_LABEL (page->details->resolution), str->str); gtk_label_set_selectable (GTK_LABEL (page->details->resolution), TRUE); g_string_free (str, TRUE); } else { gtk_label_set_text (GTK_LABEL (page->details->resolution), _("Failed to load image information")); } if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); g_object_unref (page->details->loader); page->details->loader = NULL; } #ifdef HAVE_EXIF if (page->details->exifldr != NULL) { exif_loader_unref (page->details->exifldr); page->details->exifldr = NULL; } #endif /*HAVE_EXIF*/ #ifdef HAVE_EXEMPI if (page->details->xmp != NULL) { xmp_free(page->details->xmp); page->details->xmp = NULL; } #endif }
Pixbuf *Pixbuf::create_from_data_uri(gchar const *uri_data) { Pixbuf *pixbuf = NULL; bool data_is_image = false; bool data_is_base64 = false; gchar const *data = uri_data; while (*data) { if (strncmp(data,"base64",6) == 0) { /* base64-encoding */ data_is_base64 = true; data_is_image = true; // 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 = true; data += 9; } else if (strncmp(data,"image/jpg",9) == 0) { /* JPEG image */ data_is_image = true; data += 9; } else if (strncmp(data,"image/jpeg",10) == 0) { /* JPEG image */ data_is_image = true; data += 10; } else if (strncmp(data,"image/jp2",9) == 0) { /* JPEG2000 image */ data_is_image = true; data += 9; } 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) { GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); if (!loader) return NULL; gsize decoded_len = 0; guchar *decoded = g_base64_decode(data, &decoded_len); if (gdk_pixbuf_loader_write(loader, decoded, decoded_len, NULL)) { gdk_pixbuf_loader_close(loader, NULL); GdkPixbuf *buf = gdk_pixbuf_loader_get_pixbuf(loader); if (buf) { g_object_ref(buf); pixbuf = new Pixbuf(buf); GdkPixbufFormat *fmt = gdk_pixbuf_loader_get_format(loader); gchar *fmt_name = gdk_pixbuf_format_get_name(fmt); pixbuf->_setMimeData(decoded, decoded_len, fmt_name); g_free(fmt_name); } else { g_free(decoded); } } else { g_free(decoded); } g_object_unref(loader); } return pixbuf; }
static void metadata_menuitem_on_fetcher_completed (MetadataMenuitem* self, GByteArray* update, const gchar* property) { GError * _inner_error_ = NULL; g_return_if_fail (self != NULL); g_return_if_fail (update != NULL); g_return_if_fail (property != NULL); { GdkPixbufLoader* _tmp0_; GdkPixbufLoader* loader; GdkPixbufLoader* _tmp1_; GByteArray* _tmp2_; guint8* _tmp3_; gint _tmp3__length1; GdkPixbufLoader* _tmp4_; GdkPixbufLoader* _tmp5_; GdkPixbuf* _tmp6_ = NULL; GdkPixbuf* _tmp7_; GdkPixbuf* icon; const gchar* _tmp8_; gchar* _tmp9_ = NULL; gchar* path; const gchar* _tmp10_; gint _tmp11_ = 0; gint r; gint _tmp12_; _tmp0_ = gdk_pixbuf_loader_new (); loader = _tmp0_; _tmp1_ = loader; _tmp2_ = update; _tmp3_ = _tmp2_->data; _tmp3__length1 = (gint) _tmp2_->len; gdk_pixbuf_loader_write (_tmp1_, _tmp3_, (gsize) _tmp3__length1, &_inner_error_); if (_inner_error_ != NULL) { _g_object_unref0 (loader); goto __catch6_g_error; } _tmp4_ = loader; gdk_pixbuf_loader_close (_tmp4_, &_inner_error_); if (_inner_error_ != NULL) { _g_object_unref0 (loader); goto __catch6_g_error; } _tmp5_ = loader; _tmp6_ = gdk_pixbuf_loader_get_pixbuf (_tmp5_); _tmp7_ = _g_object_ref0 (_tmp6_); icon = _tmp7_; _tmp8_ = metadata_menuitem_album_art_cache_dir; _tmp9_ = g_strconcat (_tmp8_, "/downloaded-coverart-XXXXXX", NULL); path = _tmp9_; _tmp10_ = path; _tmp11_ = g_mkstemp (_tmp10_); r = _tmp11_; _tmp12_ = r; if (_tmp12_ != (-1)) { GdkPixbuf* _tmp13_; const gchar* _tmp14_; GdkPixbufLoader* _tmp15_; GdkPixbufFormat* _tmp16_ = NULL; gchar* _tmp17_ = NULL; gchar* _tmp18_; const gchar* _tmp19_; const gchar* _tmp20_; const gchar* _tmp21_; const gchar* _tmp23_; gchar* _tmp24_; _tmp13_ = icon; _tmp14_ = path; _tmp15_ = loader; _tmp16_ = gdk_pixbuf_loader_get_format (_tmp15_); _tmp17_ = gdk_pixbuf_format_get_name (_tmp16_); _tmp18_ = _tmp17_; gdk_pixbuf_save (_tmp13_, _tmp14_, _tmp18_, &_inner_error_, NULL); _g_free0 (_tmp18_); if (_inner_error_ != NULL) { _g_free0 (path); _g_object_unref0 (icon); _g_object_unref0 (loader); goto __catch6_g_error; } _tmp19_ = property; _tmp20_ = path; dbusmenu_menuitem_property_set ((DbusmenuMenuitem*) self, _tmp19_, _tmp20_); _tmp21_ = self->priv->previous_temp_album_art_path; if (_tmp21_ != NULL) { const gchar* _tmp22_; _tmp22_ = self->priv->previous_temp_album_art_path; g_remove (_tmp22_); } _tmp23_ = path; _tmp24_ = g_strdup (_tmp23_); _g_free0 (self->priv->previous_temp_album_art_path); self->priv->previous_temp_album_art_path = _tmp24_; } _g_free0 (path); _g_object_unref0 (icon); _g_object_unref0 (loader); } goto __finally6; __catch6_g_error: { GError* e = NULL; GError* _tmp25_; const gchar* _tmp26_; e = _inner_error_; _inner_error_ = NULL; _tmp25_ = e; _tmp26_ = _tmp25_->message; g_warning ("metadata-menu-item.vala:163: Problem creating file from bytearray fetc" \ "hed from the interweb - error: %s", _tmp26_); _g_error_free0 (e); } __finally6: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return; } }