static void free_pixbuf_load_handle (GnomeGdkPixbufAsyncHandle *handle) { if (handle->done_callback) (* handle->done_callback) (handle, handle->callback_data); if (handle->loader != NULL) { gdk_pixbuf_loader_close (handle->loader, NULL); g_object_unref (G_OBJECT (handle->loader)); } if (handle->file_input_stream != NULL) { g_input_stream_close (G_INPUT_STREAM (handle->file_input_stream), NULL, NULL); g_object_unref (handle->file_input_stream); } if (handle->file != NULL) { g_object_unref (handle->file); } if (handle->cancellable != NULL) { g_object_unref (handle->cancellable); } g_free (handle); }
static GObject* hippo_pixbuf_cache_parse(HippoObjectCache *cache, const char *url, const char *content_type, GString *content, GError **error_p) { GdkPixbufLoader *loader; GdkPixbuf *pixbuf; loader = gdk_pixbuf_loader_new(); if (!gdk_pixbuf_loader_write(loader, (guchar*) content->str, content->len, error_p)) goto failed; if (!gdk_pixbuf_loader_close(loader, error_p)) goto failed; pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf == NULL) { g_set_error(error_p, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_FAILED, _("Could not load pixbuf")); goto failed; } g_object_ref(pixbuf); g_object_unref(loader); return G_OBJECT(pixbuf); failed: g_assert(error_p == NULL || *error_p != NULL); if (loader) g_object_unref(loader); return NULL; }
static GdkPixbuf * totem_gst_buffer_to_pixbuf (GstBuffer *buffer) { GdkPixbufLoader *loader; GdkPixbuf *pixbuf = NULL; GError *err = NULL; loader = gdk_pixbuf_loader_new (); if (gdk_pixbuf_loader_write (loader, buffer->data, buffer->size, &err) && gdk_pixbuf_loader_close (loader, &err)) { pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf) g_object_ref (pixbuf); } else { GST_WARNING("could not convert tag image to pixbuf: %s", err->message); g_error_free (err); } g_object_unref (loader); return pixbuf; }
/** 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 similiar 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)) { pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader)); } 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 }
static void avatar_cache_close_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GiggleAvatarCacheLoader *loader = user_data; GInputStream *stream = G_INPUT_STREAM (object); GError *error = NULL; if (g_input_stream_close_finish (stream, result, &error) && gdk_pixbuf_loader_close (loader->pixbuf_loader, &error)) { loader->pixbuf = gdk_pixbuf_loader_get_pixbuf (loader->pixbuf_loader); avatar_cache_insert (loader->cache, loader->uri, loader->pixbuf); g_object_unref (loader->pixbuf_loader); loader->pixbuf_loader = NULL; } if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) g_warning ("%s: %s", G_STRFUNC, error->message); avatar_cache_loader_finish (loader, error); }
static void load_finished (NemoImagePropertiesPage *page) { GtkWidget *label; label = gtk_grid_get_child_at (GTK_GRID (page->details->grid), 0, 0); gtk_container_remove (GTK_CONTAINER (page->details->grid), label); if (page->details->loader != NULL) { gdk_pixbuf_loader_close (page->details->loader, NULL); } if (page->details->got_size) { append_basic_info (page); append_options_info (page); append_exif_info (page); append_xmp_info (page); } else { append_item (page, _("Failed to load image information"), NULL); } 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 }
static void cleanup_callback (GObject *object, gpointer data) { if (load_timeout) { g_source_remove (load_timeout); load_timeout = 0; } if (pixbuf_loader) { gdk_pixbuf_loader_close (pixbuf_loader, NULL); g_object_unref (pixbuf_loader); pixbuf_loader = NULL; } if (image_stream) { g_object_unref (image_stream); image_stream = NULL; } }
static GdkPixbuf* parse_pixbuf(const char *url, GString *image_data) { GdkPixbufLoader *loader; GError *error; GdkPixbuf *pixbuf; loader = gdk_pixbuf_loader_new(); error = NULL; if (!gdk_pixbuf_loader_write(loader, (guchar*) image_data->str, image_data->len, &error)) goto failed; g_assert(error == NULL); if (!gdk_pixbuf_loader_close(loader, &error)) goto failed; g_assert(error == NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf == NULL) goto failed; g_object_ref(pixbuf); g_object_unref(loader); return pixbuf; failed: if (loader) g_object_unref(loader); if (error) { g_debug("Failed to load image '%s': %s", url, error->message); g_error_free(error); } return NULL; }
static struct graphics_image_priv * image_new(struct graphics_priv *gr, struct graphics_image_methods *meth, char *name, int *w, int *h, struct point *hot, int rotation) { GdkPixbuf *pixbuf; struct graphics_image_priv *ret; const char *option; if (!strcmp(name,"buffer:")) { struct graphics_image_buffer *buffer=(struct graphics_image_buffer *)name; GdkPixbufLoader *loader=gdk_pixbuf_loader_new(); if (!loader) return NULL; if (*w != -1 || *h != -1) gdk_pixbuf_loader_set_size(loader, *w, *h); gdk_pixbuf_loader_write(loader, buffer->start, buffer->len, NULL); gdk_pixbuf_loader_close(loader, NULL); pixbuf=gdk_pixbuf_loader_get_pixbuf(loader); g_object_ref(pixbuf); g_object_unref(loader); } else { if (*w == -1 && *h == -1) pixbuf=gdk_pixbuf_new_from_file(name, NULL); else pixbuf=gdk_pixbuf_new_from_file_at_size(name, *w, *h, NULL); } if (!pixbuf) return NULL; if (rotation) { GdkPixbuf *tmp; switch (rotation) { case 90: rotation=270; break; case 180: break; case 270: rotation=90; break; default: return NULL; } tmp=gdk_pixbuf_rotate_simple(pixbuf, rotation); if (!tmp) { g_object_unref(pixbuf); return NULL; } g_object_unref(pixbuf); pixbuf=tmp; } ret=g_new0(struct graphics_image_priv, 1); ret->pixbuf=pixbuf; ret->w=gdk_pixbuf_get_width(pixbuf); ret->h=gdk_pixbuf_get_height(pixbuf); *w=ret->w; *h=ret->h; if (hot) { option=gdk_pixbuf_get_option(pixbuf, "x_hot"); if (option) hot->x=atoi(option); else hot->x=ret->w/2-1; option=gdk_pixbuf_get_option(pixbuf, "y_hot"); if (option) hot->y=atoi(option); else hot->y=ret->h/2-1; } return ret; }
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; }
/** * be sure to unref the result if it is non-NULL * * TODO : this is really overkill for now. * only wmf/emf will require regenerating the pixbuf for different scale * factors. And even then we should cache them. */ static GdkPixbuf * soi_get_pixbuf (SheetObjectImage *soi, double scale) { GError *err = NULL; guint8 *data; guint32 data_len; GdkPixbufLoader *loader = NULL; GdkPixbuf *pixbuf = NULL; gboolean ret; g_return_val_if_fail (IS_SHEET_OBJECT_IMAGE (soi), NULL); data = soi->bytes.data; data_len = soi->bytes.len; if (data == NULL || data_len == 0) return pixbuf; if (soi->type != NULL && !strcmp (soi->type, "wmf")) loader = gdk_pixbuf_loader_new_with_type (soi->type, &err); else loader = gdk_pixbuf_loader_new (); if (soi->type == NULL || strlen (soi->type) == 0) g_signal_connect (loader, "size-prepared", G_CALLBACK (soi_info_cb), soi); if (loader) { ret = gdk_pixbuf_loader_write (loader, soi->bytes.data, soi->bytes.len, &err); /* Close in any case. But don't let error during closing * shadow error from loader_write. */ gdk_pixbuf_loader_close (loader, ret ? &err : NULL); if (ret) pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf) { g_object_ref (G_OBJECT (pixbuf)); d (printf ("pixbuf width=%d, height=%d\n", gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf))); if (soi->crop_top != 0.0 || soi->crop_bottom != 0.0 || soi->crop_left != 0.0 || soi->crop_right != 0.0) { d (printf ("crop rect top=%g, bottom=%g, " "left=%g, right=%g\n", soi->crop_top, soi->crop_bottom, soi->crop_left, soi->crop_right)); pixbuf = soi_get_cropped_pixbuf (soi, pixbuf); } } g_object_unref (G_OBJECT (loader)); } if (!pixbuf) { if (!soi->dumped) { static int count = 0; char *filename = g_strdup_printf ("unknown%d.%s", count++, soi->type); #if 0 GsfOutput *file = gsf_output_stdio_new (filename, NULL); if (file) { gsf_output_write (GSF_OUTPUT (file), soi->bytes.len, soi->bytes.data); gsf_output_close (GSF_OUTPUT (file)); g_object_unref (file); } #endif g_free (filename); soi->dumped = TRUE; } if (err != NULL) { g_warning ("%s", err->message); g_error_free (err); err = NULL; } else { g_warning ("Unable to display image"); } } return pixbuf; }
void ArticleView::AppendData(gchar *data, const gchar *oword, const gchar *real_oword) { std::string mark; guint32 sec_size=0; const guint32 data_size=get_uint32(data); data+=sizeof(guint32); const gchar *p=data; bool first_time = true; size_t iPlugin; size_t nPlugins = gpAppFrame->oStarDictPlugins->ParseDataPlugins.nplugins(); unsigned int parsed_size; ParseResult parse_result; while (guint32(p - data)<data_size) { if (first_time) first_time=false; else mark+= "\n"; for (iPlugin = 0; iPlugin < nPlugins; iPlugin++) { parse_result.clear(); if (gpAppFrame->oStarDictPlugins->ParseDataPlugins.parse(iPlugin, p, &parsed_size, parse_result, oword)) { p += parsed_size; break; } } if (iPlugin != nPlugins) { append_and_mark_orig_word(mark, real_oword, LinksPosList()); mark.clear(); append_data_parse_result(real_oword, parse_result); parse_result.clear(); continue; } switch (*p) { case 'm': //case 'l': //TODO: convert from local encoding to utf-8 p++; sec_size = strlen(p); if (sec_size) { gchar *m_str = g_markup_escape_text(p, sec_size); mark+=m_str; g_free(m_str); } sec_size++; break; case 'g': p++; sec_size=strlen(p); if (sec_size) { mark+=p; } sec_size++; break; case 'x': p++; sec_size = strlen(p) + 1; mark+= _("XDXF data parsing plug-in is not found!"); break; case 'k': p++; sec_size = strlen(p) + 1; mark+= _("PowerWord data parsing plug-in is not found!"); break; case 'w': p++; sec_size = strlen(p) + 1; mark+= _("Wiki data parsing plug-in is not found!"); break; case 'h': p++; sec_size = strlen(p) + 1; mark+= _("HTML data parsing plug-in is not found!"); break; case 'n': p++; sec_size = strlen(p) + 1; mark+= _("WordNet data parsing plug-in is not found!"); break; case 't': p++; sec_size = strlen(p); if (sec_size) { mark += "[<span foreground=\"blue\">"; gchar *m_str = g_markup_escape_text(p, sec_size); mark += m_str; g_free(m_str); mark += "</span>]"; } sec_size++; break; case 'y': p++; sec_size = strlen(p); if (sec_size) { mark += "[<span foreground=\"red\">"; gchar *m_str = g_markup_escape_text(p, sec_size); mark += m_str; g_free(m_str); mark += "</span>]"; } sec_size++; break; case 'r': p++; sec_size = strlen(p); if(sec_size) { append_and_mark_orig_word(mark, real_oword, LinksPosList()); mark.clear(); append_resource_file_list(p); } sec_size++; break; /*case 'W': { p++; sec_size=g_ntohl(get_uint32(p)); //TODO: sound button. sec_size += sizeof(guint32); } break;*/ case 'P': { p++; sec_size=g_ntohl(get_uint32(p)); if (sec_size) { if (for_float_win) { append_and_mark_orig_word(mark, real_oword, LinksPosList()); mark.clear(); append_pixbuf(NULL); } else { GdkPixbufLoader* loader = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(loader, (const guchar *)(p+sizeof(guint32)), sec_size, NULL); gdk_pixbuf_loader_close(loader, NULL); GdkPixbuf* pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf) { append_and_mark_orig_word(mark, real_oword, LinksPosList()); mark.clear(); append_pixbuf(pixbuf); } else { mark += _("<span foreground=\"red\">[Load image error!]</span>"); } g_object_unref(loader); } } else { mark += _("<span foreground=\"red\">[Missing Image]</span>"); } sec_size += sizeof(guint32); } break; default: if (g_ascii_isupper(*p)) { p++; sec_size=g_ntohl(get_uint32(p)); sec_size += sizeof(guint32); } else { p++; sec_size = strlen(p)+1; } mark += _("Unknown data type, please upgrade StarDict!"); break; } p += sec_size; } append_and_mark_orig_word(mark, real_oword, LinksPosList()); }
bool _openslide_gdkpixbuf_read(const char *format, const char *filename, int64_t offset, int64_t length, uint32_t *dest, int32_t w, int32_t h, GError **err) { GdkPixbufLoader *loader = NULL; uint8_t *buf = g_slice_alloc(BUFSIZE); bool success = false; struct load_state state = { .w = w, .h = h, }; // open and seek FILE *f = _openslide_fopen(filename, "rb", err); if (!f) { goto DONE; } if (fseeko(f, offset, SEEK_SET)) { _openslide_io_error(err, "Couldn't fseek %s", filename); goto DONE; } // create loader loader = gdk_pixbuf_loader_new_with_type(format, err); if (!loader) { goto DONE; } g_signal_connect(loader, "area-prepared", G_CALLBACK(area_prepared), &state); // read data while (length) { size_t count = fread(buf, 1, MIN(length, BUFSIZE), f); if (!count) { g_set_error(err, OPENSLIDE_ERROR, OPENSLIDE_ERROR_FAILED, "Short read loading pixbuf from %s", filename); goto DONE; } if (!gdk_pixbuf_loader_write(loader, buf, count, err)) { g_prefix_error(err, "gdk-pixbuf error: "); goto DONE; } if (state.err) { goto DONE; } length -= count; } // finish load if (!gdk_pixbuf_loader_close(loader, err)) { g_prefix_error(err, "gdk-pixbuf error: "); goto DONE; } if (state.err) { goto DONE; } g_assert(state.pixbuf); // copy pixels uint8_t *pixels = gdk_pixbuf_get_pixels(state.pixbuf); int rowstride = gdk_pixbuf_get_rowstride(state.pixbuf); for (int32_t y = 0; y < h; y++) { for (int32_t x = 0; x < w; x++) { dest[y * w + x] = 0xFF000000 | // A pixels[y * rowstride + x * 3 + 0] << 16 | // R pixels[y * rowstride + x * 3 + 1] << 8 | // G pixels[y * rowstride + x * 3 + 2]; // B } } success = true; DONE: // clean up if (loader) { gdk_pixbuf_loader_close(loader, NULL); g_object_unref(loader); } if (f) { fclose(f); } g_slice_free1(BUFSIZE, buf); // now that the loader is closed, we know state.err won't be set // behind our back if (state.err) { // signal handler validation errors override GdkPixbuf errors g_clear_error(err); g_propagate_error(err, state.err); // signal handler errors should have been noticed before falling through g_assert(!success); } return success; }
void remmina_rdp_cliprdr_process_data_response(RemminaProtocolWidget* gp, RDP_CB_DATA_RESPONSE_EVENT* event) { UINT8* data; size_t size; rfContext* rfi = GET_DATA(gp); GdkPixbufLoader *pixbuf; gpointer output = NULL; data = event->data; size = event->size; if (size > 0) { switch (rfi->format) { case CB_FORMAT_UNICODETEXT: { size = ConvertFromUnicode(CP_UTF8, 0, (WCHAR*)data, size / 2, (CHAR**)&data, 0, NULL, NULL); crlf2lf(data, &size); output = data; break; } case CB_FORMAT_TEXT: case CB_FORMAT_HTML: { crlf2lf(data, &size); output = data; break; } case CB_FORMAT_DIB: { wStream* s; UINT16 bpp; UINT32 offset; UINT32 ncolors; s = Stream_New(data, size); Stream_Seek(s, 14); Stream_Read_UINT16(s, bpp); Stream_Read_UINT32(s, ncolors); offset = 14 + 40 + (bpp <= 8 ? (ncolors == 0 ? (1 << bpp) : ncolors) * 4 : 0); Stream_Free(s, TRUE); s = Stream_New(NULL, 14 + size); Stream_Write_UINT8(s, 'B'); Stream_Write_UINT8(s, 'M'); Stream_Write_UINT32(s, 14 + size); Stream_Write_UINT32(s, 0); Stream_Write_UINT32(s, offset); Stream_Write(s, data, size); data = Stream_Buffer(s); size = Stream_Length(s); pixbuf = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(pixbuf, data, size, NULL); gdk_pixbuf_loader_close(pixbuf, NULL); Stream_Free(s, TRUE); output = g_object_ref(gdk_pixbuf_loader_get_pixbuf(pixbuf)); g_object_unref(pixbuf); break; } case CB_FORMAT_PNG: case CB_FORMAT_JPEG: { pixbuf = gdk_pixbuf_loader_new(); gdk_pixbuf_loader_write(pixbuf, data, size, NULL); output = g_object_ref(gdk_pixbuf_loader_get_pixbuf(pixbuf)); gdk_pixbuf_loader_close(pixbuf, NULL); g_object_unref(pixbuf); break; } } } g_async_queue_push(rfi->clipboard_queue, output); }
static void sanity_check(const gchar *filename) { GdkPixbufLoader *loader; GSList *formats, *l; GError *err = NULL; GdkPixbuf *pixbuf; gchar *buf = NULL; gsize size; FILE *fh; gboolean ok, fileok = TRUE; g_printerr("Performing sanity check for %s.\n", filename); fileok &= ok = g_file_test(filename, G_FILE_TEST_EXISTS); g_printerr("Does it exist: %s\n", ok ? "YES" : "NO"); fileok &= ok = g_file_test(filename, G_FILE_TEST_IS_REGULAR); g_printerr("Is it a regular file: %s\n", ok ? "YES" : "NO"); fh = fopen(filename, "rb"); fileok &= ok = !!fh; g_printerr("Can we open it for reading: %s\n", ok ? "YES" : "NO"); if (fh) fclose(fh); else g_printerr("fopen() fails with: %s\n", g_strerror(errno)); fileok &= ok = g_file_get_contents(filename, &buf, &size, &err); g_printerr("Can we use g_file_get_contents(): %s\n", ok ? "YES" : "NO"); if (!ok) { g_printerr("g_file_get_contents() fails with: %s\n", err->message); g_clear_error(&err); } if (!fileok) { if (buf) g_free(buf); g_printerr("The file does not seem OK. No point continuing.\n"); return; } g_printerr("The file seems OK, continuing checks.\n"); pixbuf = gdk_pixbuf_new_from_file(filename, &err); if (pixbuf) { g_printerr("Apparently we can load the pixbuf (%dx%d) now?!\n", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf)); g_printerr("What has changed?\n"); g_printerr("This is completely f****d up.\n"); g_object_unref(pixbuf); } else { g_printerr("gdk_pixbuf_new_from_file() fails with: %s\n", err->message); g_clear_error(&err); } g_printerr("Checking the pixbuf loaders.\n"); formats = gdk_pixbuf_get_formats(); for (l = formats; l; l = g_slist_next(l)) { GdkPixbufFormat *pixbuf_format = (GdkPixbufFormat*)l->data; gchar **ext; gchar *fmtname, *desc, *exts; fmtname = gdk_pixbuf_format_get_name(pixbuf_format); desc = gdk_pixbuf_format_get_description(pixbuf_format); ext = gdk_pixbuf_format_get_extensions(pixbuf_format); exts = g_strjoinv(" ", ext); g_printerr("Found format %s: %s (%s)\n", fmtname, desc, exts); g_free(exts); g_strfreev(ext); g_free(desc); format_check(pixbuf_format, buf, size); loader = gdk_pixbuf_loader_new_with_type(fmtname, &err); if (!loader) { g_printerr(" Cannot create loader for %s: %s\n", fmtname, err->message); g_clear_error(&err); g_free(fmtname); continue; } ok = gdk_pixbuf_loader_write(loader, buf, size, &err); if (ok) { g_printerr(" Loader %s accepts the file content.\n", fmtname); ok = gdk_pixbuf_loader_close(loader, &err); if (ok) { g_printerr(" Loader %s accepts the entire file.\n", fmtname); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf) { g_printerr(" Obtained pixbuf %dx%d from the loader.\n", gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf)); } else { g_printerr(" Cannot obtain pixbuf from the loader.\n"); } } else { g_printerr(" Loader %s fails at close(): %s.\n", fmtname, err->message); g_clear_error(&err); } } else { g_printerr(" Loader %s does not accept the file content: %s\n", fmtname, err->message); g_clear_error(&err); } g_object_unref(loader); g_free(fmtname); } g_slist_free(formats); }
// maybe this should be (partly) in common/imageio.[c|h]? static void _lib_import_update_preview(GtkFileChooser *file_chooser, gpointer data) { GtkWidget *preview; char *filename; GdkPixbuf *pixbuf = NULL; gboolean have_preview = FALSE, no_preview_fallback = FALSE; preview = GTK_WIDGET(data); filename = gtk_file_chooser_get_preview_filename(file_chooser); if(!g_file_test(filename, G_FILE_TEST_IS_REGULAR)) { no_preview_fallback = TRUE; } else { // don't create dng thumbnails to avoid crashes in libtiff when these are hdr: char *c = filename + strlen(filename); while(c > filename && *c != '.') c--; if(!strcasecmp(c, ".dng")) no_preview_fallback = TRUE; } // unfortunately we can not use following, because frequently it uses wrong orientation // pixbuf = gdk_pixbuf_new_from_file_at_size(filename, 128, 128, NULL); have_preview = (pixbuf != NULL); if(!have_preview && !no_preview_fallback) { uint8_t *buffer = NULL; size_t size; char *mime_type = NULL; if(!dt_exif_get_thumbnail(filename, &buffer, &size, &mime_type)) { // Scale the image to the correct size GdkPixbuf *tmp; GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); if (!gdk_pixbuf_loader_write(loader, buffer, size, NULL)) goto cleanup; if (!(tmp = gdk_pixbuf_loader_get_pixbuf(loader))) goto cleanup; float ratio = 1.0 * gdk_pixbuf_get_height(tmp) / gdk_pixbuf_get_width(tmp); int width = 128, height = 128 * ratio; pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_BILINEAR); have_preview = TRUE; cleanup: gdk_pixbuf_loader_close(loader, NULL); free(mime_type); free(buffer); g_object_unref(loader); // This should clean up tmp as well } } if(have_preview && !no_preview_fallback) { // get image orientation dt_image_t img = { 0 }; (void)dt_exif_read(&img, filename); // Rotate the image to the correct orientation GdkPixbuf *tmp = pixbuf; if(img.orientation == ORIENTATION_ROTATE_CCW_90_DEG) { tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE); } else if(img.orientation == ORIENTATION_ROTATE_CW_90_DEG) { tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_CLOCKWISE); } else if(img.orientation == ORIENTATION_ROTATE_180_DEG) { tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_UPSIDEDOWN); } if(pixbuf != tmp) { g_object_unref(pixbuf); pixbuf = tmp; } } if(no_preview_fallback || !have_preview) { guint8 *image_buffer = NULL; /* load the dt logo as a brackground */ char filename[PATH_MAX] = { 0 }; char datadir[PATH_MAX] = { 0 }; char *logo; dt_logo_season_t season = get_logo_season(); if(season != DT_LOGO_SEASON_NONE) logo = g_strdup_printf("%%s/pixmaps/idbutton-%d.svg", (int)season); else logo = g_strdup("%s/pixmaps/idbutton.svg"); dt_loc_get_datadir(datadir, sizeof(datadir)); snprintf(filename, sizeof(filename), logo, datadir); g_free(logo); RsvgHandle *svg = rsvg_handle_new_from_file(filename, NULL); if(svg) { cairo_surface_t *surface; cairo_t *cr; RsvgDimensionData dimension; rsvg_handle_get_dimensions(svg, &dimension); float svg_size = MAX(dimension.width, dimension.height); float final_size = 128; float factor = final_size / svg_size; float final_width = dimension.width * factor * darktable.gui->ppd, final_height = dimension.height * factor * darktable.gui->ppd; int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, final_width); image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8)); surface = dt_cairo_image_surface_create_for_data(image_buffer, CAIRO_FORMAT_ARGB32, final_width, final_height, stride); if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) { free(image_buffer); image_buffer = NULL; } else { cr = cairo_create(surface); cairo_scale(cr, factor, factor); rsvg_handle_render_cairo(svg, cr); cairo_surface_flush(surface); pixbuf = gdk_pixbuf_get_from_surface(surface, 0, 0, final_width / darktable.gui->ppd, final_height / darktable.gui->ppd); } g_object_unref(svg); } have_preview = TRUE; } if(have_preview) gtk_image_set_from_pixbuf(GTK_IMAGE(preview), pixbuf); if(pixbuf) g_object_unref(pixbuf); g_free(filename); gtk_file_chooser_set_preview_widget_active(file_chooser, have_preview); }
void Tetris::dragDrop(GtkWidget *widget, GdkDragContext *context, gint x, gint y, GtkSelectionData *data, guint info, guint time, Tetris * t) { const char *fileuri; GError *error = NULL; GFile *file; GFile *outfile; GFileInfo *fileinfo; GFileInputStream *istream; GFileOutputStream *outstream; goffset filesize; gssize bytesread, byteswrote; GdkPixbufLoader *loader; GdkPixbuf *pixbuf; guchar *buffer; /* Accept a dropped filename and try and load it as the background image. In the event of any kind of failure we silently ignore it. */ /* FIXME: We don't handle colour gradients (e.g. from the gimp) */ /* FIXME: Dropped URLs from mozilla don't work (see below). */ if (data->length < 0) { gtk_drag_finish (context, FALSE, FALSE, time); return; } gtk_drag_finish (context, TRUE, FALSE, time); if (info == COLOUR) { if (data->length == 8) decodeColour ((guint16 *)data->data, t); return; } if (info == RESET) { resetColour (t); return; } fileuri = decodeDropData ((char *)data->data, info); /* Silently ignore bad data. */ if (fileuri == NULL) goto error_exit; /* Now that we have a URI we load it and test it to see if it is * an image file. */ file = g_file_new_for_uri (fileuri); istream = g_file_read (file, NULL, &error); if (error) goto error_exit; fileinfo = g_file_input_stream_query_info (istream, (char *)G_FILE_ATTRIBUTE_STANDARD_SIZE, NULL, &error); if (error) goto error_exit_handle; filesize = g_file_info_get_size (fileinfo); buffer = (guchar *)g_malloc (filesize); if (buffer == NULL) goto error_exit_handle; bytesread = g_input_stream_read (G_INPUT_STREAM (istream), buffer, filesize, NULL, &error); /* FIXME: We should reread if not enough was read. */ if (error || (bytesread != filesize)) goto error_exit_buffer; loader = gdk_pixbuf_loader_new (); if (!gdk_pixbuf_loader_write (loader, buffer, filesize, NULL)) goto error_exit_loader; gdk_pixbuf_loader_close (loader, NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf == NULL) goto error_exit_loader; g_object_ref (pixbuf); /* We now have an image file, in memory, that we know gdk-pixbuf * can handle. Now we save it to disk. This is necessary so that * "slow" URIs (e.g. http) behave well in the long run. */ outfile = g_file_new_for_path (t->bgPixmap); outstream = g_file_replace (outfile, NULL, FALSE, G_FILE_CREATE_PRIVATE, NULL, &error); if (error) goto error_exit_loader; byteswrote = g_output_stream_write (G_OUTPUT_STREAM (outstream), buffer, bytesread, NULL, &error); if (byteswrote != filesize) goto error_exit_saver; t->usebg = TRUE; t->saveBgOptions (); error_exit_saver: g_object_unref(outstream); error_exit_loader: g_object_unref (loader); error_exit_buffer: g_free (buffer); error_exit_handle: g_object_unref(istream); error_exit: if(error) g_error_free(error); return; }
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* hybrid_create_round_pixbuf(const guchar *pixbuf_data, gint pixbuf_len, gint scale_size) { GdkPixbufLoader *loader; GdkPixbuf *pixbuf; GdkPixbuf *newpixbuf; gint orig_width; gint orig_height; guchar *default_pixbuf_data; gsize default_pixbuf_size; loader = gdk_pixbuf_loader_new(); if (!pixbuf_data || pixbuf_len == 0) { /**< Load the default. */ g_file_get_contents(PIXMAPS_DIR"icons/icon.png", (gchar**)&default_pixbuf_data, &default_pixbuf_size, NULL); gdk_pixbuf_loader_write(loader, default_pixbuf_data, default_pixbuf_size, NULL); g_free(default_pixbuf_data); } else { gdk_pixbuf_loader_write(loader, pixbuf_data, pixbuf_len, NULL); } gdk_pixbuf_loader_close(loader, NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); if (pixbuf) { g_object_ref(loader); } g_object_unref(loader); if (!pixbuf) { hybrid_debug_error("blist", "get pixbuf from loader"); return NULL; } orig_width = gdk_pixbuf_get_width(pixbuf); orig_height = gdk_pixbuf_get_height(pixbuf); newpixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, scale_size, scale_size); gdk_pixbuf_fill(newpixbuf, 0x00000000); gdk_pixbuf_scale(pixbuf, newpixbuf, 0, 0, scale_size, scale_size, 0, 0, (double)scale_size/(double)orig_width, (double)scale_size/(double)orig_height, GDK_INTERP_BILINEAR); g_object_unref(pixbuf); if (pixbuf_is_opaque(newpixbuf)) { pixbuf_make_round(newpixbuf); } pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, scale_size, scale_size); gdk_pixbuf_fill(pixbuf, 0x00000000); gdk_pixbuf_copy_area(newpixbuf, 0, 0, scale_size, scale_size, pixbuf, 0, 0); g_object_unref(newpixbuf); return pixbuf; }
static void image_decode_data (video_decoder_t *this_gen, buf_element_t *buf) { image_decoder_t *this = (image_decoder_t *) this_gen; GError *error = NULL; if (!this->video_open) { lprintf("opening video\n"); (this->stream->video_out->open) (this->stream->video_out, this->stream); this->video_open = 1; } if (this->loader == NULL) { this->loader = gdk_pixbuf_loader_new (); } if (gdk_pixbuf_loader_write (this->loader, buf->mem, buf->size, &error) == FALSE) { lprintf("error loading image: %s\n", error->message); g_error_free (error); gdk_pixbuf_loader_close (this->loader, NULL); g_object_unref (G_OBJECT (this->loader)); this->loader = NULL; return; } if (buf->decoder_flags & BUF_FLAG_FRAME_END) { GdkPixbuf *pixbuf; int width, height, rowstride, n_channels; guchar *img_buf; vo_frame_t *img; int color_matrix, flags; void *rgb2yuy2; /* * this->image -> rgb data */ if (gdk_pixbuf_loader_close (this->loader, &error) == FALSE) { lprintf("error loading image: %s\n", error->message); g_error_free (error); g_object_unref (G_OBJECT (this->loader)); this->loader = NULL; return; } pixbuf = gdk_pixbuf_loader_get_pixbuf (this->loader); if (pixbuf != NULL) g_object_ref (G_OBJECT (pixbuf)); g_object_unref (this->loader); this->loader = NULL; if (pixbuf == NULL) { lprintf("error loading image\n"); return; } width = gdk_pixbuf_get_width (pixbuf) & ~1; /* must be even for init_yuv_planes */ height = gdk_pixbuf_get_height (pixbuf); img_buf = gdk_pixbuf_get_pixels (pixbuf); _x_stream_info_set(this->stream, XINE_STREAM_INFO_VIDEO_WIDTH, width); _x_stream_info_set(this->stream, XINE_STREAM_INFO_VIDEO_HEIGHT, height); lprintf("image loaded successfully\n"); flags = VO_BOTH_FIELDS; color_matrix = this->stream->video_out->get_capabilities (this->stream->video_out) & VO_CAP_FULLRANGE ? 11 : 10; VO_SET_FLAGS_CM (color_matrix, flags); /* * alloc video frame */ img = this->stream->video_out->get_frame (this->stream->video_out, width, height, (double)width / (double)height, XINE_IMGFMT_YUY2, flags); /* crop if allocated frame is smaller than requested */ if (width > img->width) width = img->width; if (height > img->height) height = img->height; img->ratio = (double)width / (double)height; /* rgb data -> yuv */ n_channels = gdk_pixbuf_get_n_channels (pixbuf); rowstride = gdk_pixbuf_get_rowstride (pixbuf); rgb2yuy2 = rgb2yuy2_alloc (color_matrix, n_channels > 3 ? "rgba" : "rgb"); if (!img->proc_slice || (img->height & 15)) { /* do all at once */ rgb2yuy2_slice (rgb2yuy2, img_buf, rowstride, img->base[0], img->pitches[0], width, height); } else { /* sliced */ uint8_t *sptr[1]; int y, h = 16; for (y = 0; y < height; y += 16) { if (y + 16 > height) h = height & 15; sptr[0] = img->base[0] + y * img->pitches[0]; rgb2yuy2_slice (rgb2yuy2, img_buf + y * rowstride, rowstride, sptr[0], img->pitches[0], width, h); img->proc_slice (img, sptr); } } rgb2yuy2_free (rgb2yuy2); g_object_unref (pixbuf); /* * draw video frame */ img->pts = buf->pts; img->duration = 3600; img->bad_frame = 0; _x_stream_info_set(this->stream, XINE_STREAM_INFO_FRAME_DURATION, img->duration); img->draw(img, this->stream); img->free(img); } }
static void _camera_process_job(const dt_camctl_t *c,const dt_camera_t *camera, gpointer job) { dt_camera_t *cam=(dt_camera_t *)camera; _camctl_camera_job_t *j = (_camctl_camera_job_t *)job; switch( j->type ) { case _JOB_TYPE_EXECUTE_CAPTURE: { dt_print (DT_DEBUG_CAMCTL,"[camera_control] executing remote camera capture job\n"); CameraFilePath fp; int res=GP_OK; if( (res = gp_camera_capture (camera->gpcam, GP_CAPTURE_IMAGE,&fp, c->gpcontext)) == GP_OK ) { CameraFile *destination; const char *output_path = _dispatch_request_image_path(c,camera); if( !output_path ) output_path="/tmp"; const char *fname = _dispatch_request_image_filename(c,fp.name,cam); if( !fname ) fname=fp.name; char *output = g_build_filename (output_path,fname,(char *)NULL); int handle = open (output, O_CREAT | O_WRONLY,0666); gp_file_new_from_fd (&destination , handle); gp_camera_file_get (camera->gpcam, fp.folder , fp.name, GP_FILE_TYPE_NORMAL, destination, c->gpcontext); close (handle); // Notify listerners of captured image _dispatch_camera_image_downloaded (c,camera,output); g_free (output); } else dt_print (DT_DEBUG_CAMCTL,"[camera_control] capture job failed to capture image: %s\n",gp_result_as_string(res)); } break; case _JOB_TYPE_EXECUTE_LIVE_VIEW: { CameraFile *fp = NULL; int res = GP_OK; const gchar* data = NULL; unsigned long int data_size = 0; gp_file_new(&fp); if( (res = gp_camera_capture_preview (cam->gpcam, fp, c->gpcontext)) != GP_OK ) { dt_print (DT_DEBUG_CAMCTL,"[camera_control] live view failed to capture preview: %s\n", gp_result_as_string(res)); } else if( (res = gp_file_get_data_and_size(fp, &data, &data_size)) != GP_OK ) { dt_print (DT_DEBUG_CAMCTL,"[camera_control] live view failed to get preview data: %s\n", gp_result_as_string(res)); } else { // everything worked GdkPixbufLoader *loader = gdk_pixbuf_loader_new(); if(gdk_pixbuf_loader_write(loader, (guchar*)data, data_size, NULL) == TRUE) { dt_pthread_mutex_lock(&cam->live_view_pixbuf_mutex); if(cam->live_view_pixbuf != NULL) g_object_unref(cam->live_view_pixbuf); cam->live_view_pixbuf = gdk_pixbuf_loader_get_pixbuf(loader); dt_pthread_mutex_unlock(&cam->live_view_pixbuf_mutex); } gdk_pixbuf_loader_close(loader, NULL); } if(fp) gp_file_free(fp); dt_pthread_mutex_unlock(&cam->live_view_synch); dt_control_queue_redraw_center(); } break; case _JOB_TYPE_SET_PROPERTY: { _camctl_camera_set_property_job_t *spj=(_camctl_camera_set_property_job_t *)job; dt_print(DT_DEBUG_CAMCTL,"[camera_control] executing set camera config job %s=%s\n",spj->name,spj->value); CameraWidget *config; // Copy of camera configuration CameraWidget *widget; gp_camera_get_config( cam->gpcam, &config, c->gpcontext ); if( gp_widget_get_child_by_name ( config, spj->name, &widget) == GP_OK) { gp_widget_set_value ( widget , spj->value); gp_camera_set_config( cam->gpcam, config, c->gpcontext ); } /* dt_pthread_mutex_lock( &cam->config_lock ); CameraWidget *widget; if( gp_widget_get_child_by_name ( camera->configuration, spj->name, &widget) == GP_OK) { gp_widget_set_value ( widget , spj->value); //gp_widget_set_changed( widget, 1 ); cam->config_changed=TRUE; } dt_pthread_mutex_unlock( &cam->config_lock);*/ } break; default: dt_print(DT_DEBUG_CAMCTL,"[camera_control] process of unknown job type %lx\n",(unsigned long int)j->type); break; } g_free(j); }
static gint progressive_timeout (gpointer data) { GtkWidget *image; LoadContext *lc; image = GTK_WIDGET (data); lc = get_load_context (image); /* This shows off fully-paranoid error handling, so looks scary. * You could factor out the error handling code into a nice separate * function to make things nicer. */ if (lc->image_stream) { size_t bytes_read; guchar buf[256]; GError *error = NULL; bytes_read = fread (buf, 1, 256, lc->image_stream); if (ferror (lc->image_stream)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failure reading image file 'alphatest.png': %s", g_strerror (errno)); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); fclose (lc->image_stream); lc->image_stream = NULL; gtk_widget_show (dialog); lc->load_timeout = 0; return FALSE; /* uninstall the timeout */ } if (!gdk_pixbuf_loader_write (lc->pixbuf_loader, buf, bytes_read, &error)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to load image: %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); fclose (lc->image_stream); lc->image_stream = NULL; gtk_widget_show (dialog); lc->load_timeout = 0; return FALSE; /* uninstall the timeout */ } if (feof (lc->image_stream)) { fclose (lc->image_stream); lc->image_stream = NULL; /* Errors can happen on close, e.g. if the image * file was truncated we'll know on close that * it was incomplete. */ error = NULL; if (!gdk_pixbuf_loader_close (lc->pixbuf_loader, &error)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to load image: %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); g_object_unref (lc->pixbuf_loader); lc->pixbuf_loader = NULL; lc->load_timeout = 0; return FALSE; /* uninstall the timeout */ } g_object_unref (lc->pixbuf_loader); lc->pixbuf_loader = NULL; } } else { lc->image_stream = fopen (lc->filename, "r"); if (lc->image_stream == NULL) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (lc->window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Unable to open image file '%s': %s", lc->filename, g_strerror (errno)); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); lc->load_timeout = 0; return FALSE; /* uninstall the timeout */ } if (lc->pixbuf_loader) { gdk_pixbuf_loader_close (lc->pixbuf_loader, NULL); g_object_unref (lc->pixbuf_loader); lc->pixbuf_loader = NULL; } lc->pixbuf_loader = gdk_pixbuf_loader_new (); g_signal_connect (lc->pixbuf_loader, "area_prepared", G_CALLBACK (progressive_prepared_callback), image); g_signal_connect (lc->pixbuf_loader, "area_updated", G_CALLBACK (progressive_updated_callback), image); } /* leave timeout installed */ return TRUE; }
static GdkPixbuf * _gdk_pixbuf_new_from_uri_at_scale (const char *uri, gint size, GError **error) { gboolean result; guchar buffer[LOAD_BUFFER_SIZE]; gssize bytes_read; GdkPixbufLoader *loader = NULL; GdkPixbuf *pixbuf; GdkPixbufAnimation *animation; GdkPixbufAnimationIter *iter; gboolean has_frame; SizePrepareContext info; GFile *file; GInputStream *input_stream; g_return_val_if_fail (uri != NULL, NULL); file = g_file_new_for_uri (uri); input_stream = G_INPUT_STREAM (g_file_read (file, NULL, error)); if (input_stream == NULL) { g_object_unref (file); return NULL; } has_frame = FALSE; result = FALSE; while (!has_frame) { bytes_read = g_input_stream_read (input_stream, buffer, sizeof (buffer), NULL, error); if (bytes_read == -1) { break; } result = TRUE; if (bytes_read == 0) { break; } if (loader == NULL) { loader = create_loader (file, buffer, bytes_read); if (1 <= size) { info.size = size; info.input_width = info.input_height = 0; g_signal_connect (loader, "size-prepared", G_CALLBACK (size_prepared_cb), &info); } g_assert (loader != NULL); } if (!gdk_pixbuf_loader_write (loader, (unsigned char *)buffer, bytes_read, error)) { result = FALSE; break; } animation = gdk_pixbuf_loader_get_animation (loader); if (animation) { iter = gdk_pixbuf_animation_get_iter (animation, NULL); if (!gdk_pixbuf_animation_iter_on_currently_loading_frame (iter)) { has_frame = TRUE; } g_object_unref (iter); } } if (loader == NULL) { /* This can happen if the above loop was exited due to the * g_input_stream_read() call failing. */ result = FALSE; } else if (*error != NULL) { gdk_pixbuf_loader_close (loader, NULL); result = FALSE; } else if (gdk_pixbuf_loader_close (loader, error) == FALSE) { if (!g_error_matches (*error, GDK_PIXBUF_ERROR, GDK_PIXBUF_ERROR_INCOMPLETE_ANIMATION)) result = FALSE; else g_clear_error (error); } if (!result) { g_clear_object (&loader); g_input_stream_close (input_stream, NULL, NULL); g_object_unref (input_stream); g_object_unref (file); return NULL; } g_input_stream_close (input_stream, NULL, NULL); g_object_unref (input_stream); g_object_unref (file); pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf != NULL) { g_object_ref (G_OBJECT (pixbuf)); g_object_set_data (G_OBJECT (pixbuf), "gnome-original-width", GINT_TO_POINTER (info.input_width)); g_object_set_data (G_OBJECT (pixbuf), "gnome-original-height", GINT_TO_POINTER (info.input_height)); } g_object_unref (G_OBJECT (loader)); return pixbuf; }
static void load_sliced_image (GTask *result, gpointer object, gpointer task_data, GCancellable *cancellable) { AsyncImageData *data; GList *res = NULL; GdkPixbuf *pix; gint width, height, y, x; GdkPixbufLoader *loader; GError *error = NULL; gchar *buffer = NULL; gsize length; g_assert (!cancellable); data = task_data; g_assert (data); loader = gdk_pixbuf_loader_new (); g_signal_connect (loader, "size-prepared", G_CALLBACK (on_loader_size_prepared), data); if (!g_file_load_contents (data->gfile, NULL, &buffer, &length, NULL, &error)) { g_warning ("Failed to open sliced image: %s", error->message); goto out; } if (!gdk_pixbuf_loader_write (loader, (const guchar *) buffer, length, &error)) { g_warning ("Failed to load image: %s", error->message); goto out; } if (!gdk_pixbuf_loader_close (loader, NULL)) goto out; pix = gdk_pixbuf_loader_get_pixbuf (loader); width = gdk_pixbuf_get_width (pix); height = gdk_pixbuf_get_height (pix); for (y = 0; y < height; y += data->grid_height * data->scale_factor) { for (x = 0; x < width; x += data->grid_width * data->scale_factor) { GdkPixbuf *pixbuf = gdk_pixbuf_new_subpixbuf (pix, x, y, data->grid_width * data->scale_factor, data->grid_height * data->scale_factor); g_assert (pixbuf != NULL); res = g_list_append (res, pixbuf); } } out: /* We don't need the original pixbuf anymore, which is owned by the loader, * though the subpixbufs will hold a reference. */ g_object_unref (loader); g_free (buffer); g_clear_pointer (&error, g_error_free); g_task_return_pointer (result, res, free_glist_unref_gobjects); }
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*/ }
static GdkPixbuf * impl_load_pixbuf_data (const guchar *data, gsize size, int available_width, int available_height, int scale, GError **error) { GdkPixbufLoader *pixbuf_loader = NULL; GdkPixbuf *rotated_pixbuf = NULL; GdkPixbuf *pixbuf; gboolean success; Dimensions available_dimensions; int width_before_rotation, width_after_rotation; pixbuf_loader = gdk_pixbuf_loader_new (); available_dimensions.width = available_width; available_dimensions.height = available_height; available_dimensions.scale = scale; g_signal_connect (pixbuf_loader, "size-prepared", G_CALLBACK (on_image_size_prepared), &available_dimensions); success = gdk_pixbuf_loader_write (pixbuf_loader, data, size, error); if (!success) goto out; success = gdk_pixbuf_loader_close (pixbuf_loader, error); if (!success) goto out; pixbuf = gdk_pixbuf_loader_get_pixbuf (pixbuf_loader); width_before_rotation = gdk_pixbuf_get_width (pixbuf); rotated_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf); width_after_rotation = gdk_pixbuf_get_width (rotated_pixbuf); /* There is currently no way to tell if the pixbuf will need to be rotated before it is loaded, * so we only check that once it is loaded, and reload it again if it needs to be rotated in order * to use the available width and height correctly. * See http://bugzilla.gnome.org/show_bug.cgi?id=579003 */ if (width_before_rotation != width_after_rotation) { g_object_unref (pixbuf_loader); g_object_unref (rotated_pixbuf); rotated_pixbuf = NULL; pixbuf_loader = gdk_pixbuf_loader_new (); /* We know that the image will later be rotated, so we reverse the available dimensions. */ available_dimensions.width = available_height; available_dimensions.height = available_width; available_dimensions.scale = scale; g_signal_connect (pixbuf_loader, "size-prepared", G_CALLBACK (on_image_size_prepared), &available_dimensions); success = gdk_pixbuf_loader_write (pixbuf_loader, data, size, error); if (!success) goto out; success = gdk_pixbuf_loader_close (pixbuf_loader, error); if (!success) goto out; pixbuf = gdk_pixbuf_loader_get_pixbuf (pixbuf_loader); rotated_pixbuf = gdk_pixbuf_apply_embedded_orientation (pixbuf); } out: if (pixbuf_loader) g_object_unref (pixbuf_loader); return rotated_pixbuf; }
static gint progressive_timeout (gpointer data) { GtkWidget *picture; picture = GTK_WIDGET (data); /* This shows off fully-paranoid error handling, so looks scary. * You could factor out the error handling code into a nice separate * function to make things nicer. */ if (image_stream) { gssize bytes_read; guchar buf[256]; GError *error = NULL; bytes_read = g_input_stream_read (image_stream, buf, 256, NULL, &error); if (bytes_read < 0) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failure reading image file 'alphatest.png': %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_object_unref (image_stream); image_stream = NULL; gtk_widget_show (dialog); load_timeout = 0; return FALSE; /* uninstall the timeout */ } if (!gdk_pixbuf_loader_write (pixbuf_loader, buf, bytes_read, &error)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to load image: %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_object_unref (image_stream); image_stream = NULL; gtk_widget_show (dialog); load_timeout = 0; return FALSE; /* uninstall the timeout */ } if (bytes_read == 0) { /* Errors can happen on close, e.g. if the image * file was truncated we'll know on close that * it was incomplete. */ error = NULL; if (!g_input_stream_close (image_stream, NULL, &error)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to load image: %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); g_object_unref (image_stream); image_stream = NULL; g_object_unref (pixbuf_loader); pixbuf_loader = NULL; load_timeout = 0; return FALSE; /* uninstall the timeout */ } g_object_unref (image_stream); image_stream = NULL; /* Errors can happen on close, e.g. if the image * file was truncated we'll know on close that * it was incomplete. */ error = NULL; if (!gdk_pixbuf_loader_close (pixbuf_loader, &error)) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "Failed to load image: %s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); g_object_unref (pixbuf_loader); pixbuf_loader = NULL; load_timeout = 0; return FALSE; /* uninstall the timeout */ } g_object_unref (pixbuf_loader); pixbuf_loader = NULL; } } else { GError *error = NULL; image_stream = g_resources_open_stream ("/images/alphatest.png", 0, &error); if (image_stream == NULL) { GtkWidget *dialog; dialog = gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", error->message); g_error_free (error); g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (dialog); load_timeout = 0; return FALSE; /* uninstall the timeout */ } if (pixbuf_loader) { gdk_pixbuf_loader_close (pixbuf_loader, NULL); g_object_unref (pixbuf_loader); } pixbuf_loader = gdk_pixbuf_loader_new (); g_signal_connect (pixbuf_loader, "area-prepared", G_CALLBACK (progressive_prepared_callback), picture); g_signal_connect (pixbuf_loader, "area-updated", G_CALLBACK (progressive_updated_callback), picture); } /* leave timeout installed */ return TRUE; }
static void render_compact (EABContactFormatter *formatter, EContact *contact, GString *buffer) { const gchar *str; gchar *html; EContactPhoto *photo; g_string_append (buffer, HTML_HEADER); g_string_append (buffer,"<body class=\"-e-web-view-background-color -e-web-view-text-color\">"); if (contact == NULL) { g_string_append (buffer, "</body></html>"); return; } g_string_append_printf ( buffer, "<table><tr><td valign=\"top\">"); photo = e_contact_get (contact, E_CONTACT_PHOTO); if (photo == NULL) photo = e_contact_get (contact, E_CONTACT_LOGO); if (photo != NULL) { gint calced_width = MAX_COMPACT_IMAGE_DIMENSION; gint calced_height = MAX_COMPACT_IMAGE_DIMENSION; GdkPixbufLoader *loader = gdk_pixbuf_loader_new (); GdkPixbuf *pixbuf; /* figure out if we need to downscale the * image here. we don't scale the pixbuf * itself, just insert width/height tags in * the html */ if (photo->type == E_CONTACT_PHOTO_TYPE_INLINED) { gdk_pixbuf_loader_write ( loader, photo->data.inlined.data, photo->data.inlined.length, NULL); } else if (photo->type == E_CONTACT_PHOTO_TYPE_URI && photo->data.uri && g_ascii_strncasecmp (photo->data.uri, "file://", 7) == 0) { gchar *filename, *contents = NULL; gsize length; filename = g_filename_from_uri (photo->data.uri, NULL, NULL); if (filename) { if (g_file_get_contents (filename, &contents, &length, NULL)) { gdk_pixbuf_loader_write (loader, (const guchar *) contents, length, NULL); g_free (contents); } g_free (filename); } } gdk_pixbuf_loader_close (loader, NULL); pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (pixbuf) g_object_ref (pixbuf); g_object_unref (loader); if (pixbuf) { gint max_dimension; calced_width = gdk_pixbuf_get_width (pixbuf); calced_height = gdk_pixbuf_get_height (pixbuf); max_dimension = calced_width; if (max_dimension < calced_height) max_dimension = calced_height; if (max_dimension > MAX_COMPACT_IMAGE_DIMENSION) { calced_width *= ((gfloat) MAX_COMPACT_IMAGE_DIMENSION / max_dimension); calced_height *= ((gfloat) MAX_COMPACT_IMAGE_DIMENSION / max_dimension); } g_object_unref (pixbuf); } if (photo->type == E_CONTACT_PHOTO_TYPE_URI && photo->data.uri && *photo->data.uri) { gboolean is_local = g_str_has_prefix (photo->data.uri, "file://"); const gchar *uri = photo->data.uri; /* WebKit 2.2.x doesn't re-escape URIs, thus do this for versions before and after this */ #if !(WEBKIT_MAJOR_VERSION == 2 && WEBKIT_MINOR_VERSION == 2) gchar *unescaped = g_uri_unescape_string (uri, NULL); uri = unescaped; #endif g_string_append_printf ( buffer, "<img id=\"__evo-contact-photo\" width=\"%d\" height=\"%d\" src=\"%s%s\">", calced_width, calced_height, is_local ? "evo-" : "", uri); #if !(WEBKIT_MAJOR_VERSION == 2 && WEBKIT_MINOR_VERSION == 2) g_free (unescaped); #endif } else { gchar *photo_data; photo_data = g_base64_encode ( photo->data.inlined.data, photo->data.inlined.length); g_string_append_printf ( buffer, "<img id=\"__evo-contact-photo\" border=\"1\" src=\"data:%s;base64,%s\" " "width=\"%d\" height=\"%d\">", photo->data.inlined.mime_type, photo_data, calced_width, calced_height); g_free (photo_data); } e_contact_photo_free (photo); } g_string_append (buffer, "</td><td width=\"5\"></td><td valign=\"top\">\n"); str = e_contact_get_const (contact, E_CONTACT_FILE_AS); if (str) { html = e_text_to_html (str, 0); g_string_append_printf (buffer, "<b>%s</b>", html); g_free (html); } else { str = e_contact_get_const (contact, E_CONTACT_FULL_NAME); if (str) { html = e_text_to_html (str, 0); g_string_append_printf (buffer, "<b>%s</b>", html); g_free (html); } } g_string_append (buffer, "<hr>"); if (e_contact_get (contact, E_CONTACT_IS_LIST)) { GList *email_list; GList *l; g_string_append ( buffer, "<table border=\"0\" cellspacing=\"0\" cellpadding=\"0\">" "<tr><td valign=\"top\">"); g_string_append_printf ( buffer, "<b>%s:</b> <td>", _ ("List Members")); email_list = e_contact_get (contact, E_CONTACT_EMAIL); for (l = email_list; l; l = l->next) { if (l->data) { html = e_text_to_html (l->data, 0); g_string_append_printf (buffer, "%s, ", html); g_free (html); } } g_string_append (buffer, "</td></tr></table>"); } else { gboolean comma = FALSE; str = e_contact_get_const (contact, E_CONTACT_TITLE); if (str) { html = e_text_to_html (str, 0); g_string_append_printf (buffer, "<b>%s:</b> %s<br>", _ ("Job Title"), str); g_free (html); } #define print_email() { \ html = eab_parse_qp_email_to_html (str); \ \ if (!html) \ html = e_text_to_html (str, 0); \ \ g_string_append_printf (buffer, "%s%s", comma ? ", " : "", html); \ g_free (html); \ comma = TRUE; \ } g_string_append_printf (buffer, "<b>%s:</b> ", _ ("Email")); str = e_contact_get_const (contact, E_CONTACT_EMAIL_1); if (str) print_email (); str = e_contact_get_const (contact, E_CONTACT_EMAIL_2); if (str) print_email (); str = e_contact_get_const (contact, E_CONTACT_EMAIL_3); if (str) print_email (); g_string_append (buffer, "<br>"); #undef print_email str = e_contact_get_const (contact, E_CONTACT_HOMEPAGE_URL); if (str) { html = e_text_to_html (str, E_TEXT_TO_HTML_CONVERT_URLS); g_string_append_printf ( buffer, "<b>%s:</b> %s<br>", _ ("Home page"), html); g_free (html); } str = e_contact_get_const (contact, E_CONTACT_BLOG_URL); if (str) { html = e_text_to_html (str, E_TEXT_TO_HTML_CONVERT_URLS); g_string_append_printf ( buffer, "<b>%s:</b> %s<br>", _ ("Blog"), html); } } g_string_append (buffer, "</td></tr></table>\n"); g_string_append (buffer, "</body></html>\n"); }
static GdkPixbuf* compose_splash(const gchar *version) { gint xpos = 224; gint ypos = 36; GdkPixbufLoader *loader; GdkPixbuf *base, *digit; GError *err = NULL; guint i; gchar *p, *filename; p = gwy_find_self_dir("pixmaps"); filename = g_build_filename(p, "splash.png", NULL); g_free(p); base = gdk_pixbuf_new_from_file(filename, &err); if (!base) { g_warning("Cannot load base splash image: %s", err->message); g_clear_error(&err); sanity_check(filename); g_free(filename); return NULL; } g_free(filename); while (*version) { loader = NULL; for (i = 0; i < G_N_ELEMENTS(digits); i++) { if (*version == digits[i].c) break; } if (i == G_N_ELEMENTS(digits)) { g_warning("Cannot find image for %c", *version); version++; continue; } loader = gdk_pixbuf_loader_new_with_type("png", &err); /* We have already successfully loaded base PNG */ g_assert(loader); if (!gdk_pixbuf_loader_write(loader, digits[i].data, digits[i].len, &err)) { g_critical("Cannot load in-line image for %c as PNG", *version); break; } if (!gdk_pixbuf_loader_close(loader, &err)) { g_critical("Cannot load in-line image for %c as PNG", *version); break; } digit = gdk_pixbuf_loader_get_pixbuf(loader); g_assert(digit); gdk_pixbuf_composite(digit, base, xpos, ypos, gdk_pixbuf_get_width(digit), gdk_pixbuf_get_height(digit), xpos, ypos, 1.0, 1.0, GDK_INTERP_NEAREST, 255); xpos += gdk_pixbuf_get_width(digit); g_object_unref(loader); version++; } return base; }
cairo_surface_t * rsvg_cairo_surface_new_from_href (RsvgHandle *handle, const char *href, GError **error) { guint8 *data; gsize data_len; char *mime_type = NULL; GdkPixbufLoader *loader; GdkPixbuf *pixbuf = NULL; int res; cairo_surface_t *surface; 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); g_free (mime_type); } else { loader = gdk_pixbuf_loader_new (); } if (loader == NULL) { g_free (data); return NULL; } res = gdk_pixbuf_loader_write (loader, data, data_len, error); g_free (data); if (!res) { gdk_pixbuf_loader_close (loader, NULL); g_object_unref (loader); return NULL; } if (!gdk_pixbuf_loader_close (loader, error)) { g_object_unref (loader); return NULL; } pixbuf = gdk_pixbuf_loader_get_pixbuf (loader); if (!pixbuf) { g_object_unref (loader); 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); return NULL; } surface = rsvg_cairo_surface_from_pixbuf (pixbuf); g_object_unref (loader); return surface; }