static GthImage *
facebook_thumbnail_loader (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image = NULL;
FacebookPhoto *photo;
const char *uri;
photo = (FacebookPhoto *) g_file_info_get_attribute_object (file_data->info, "facebook::object");
uri = facebook_photo_get_thumbnail_url (photo, requested_size);
if (uri == NULL)
uri = facebook_photo_get_original_url (photo);
if (uri != NULL) {
GFile *file;
void *buffer;
gsize size;
file = g_file_new_for_uri (uri);
if (_g_file_load_in_buffer (file, &buffer, &size, cancellable, error)) {
GInputStream *stream;
GdkPixbuf *pixbuf;
stream = g_memory_input_stream_new_from_data (buffer, size, g_free);
pixbuf = gdk_pixbuf_new_from_stream (stream, cancellable, error);
if (pixbuf != NULL) {
GdkPixbuf *rotated;
rotated = gdk_pixbuf_apply_embedded_orientation (pixbuf);
g_object_unref (pixbuf);
pixbuf = rotated;
image = gth_image_new_for_pixbuf (pixbuf);
}
g_object_unref (pixbuf);
g_object_unref (stream);
}
g_object_unref (file);
}
else
*error = g_error_new_literal (GTH_ERROR, 0, "cannot generate the thumbnail");
return image;
}
static GthImage *
flickr_thumbnail_loader (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image = NULL;
GthThumbLoader *thumb_loader = user_data;
FlickrPhoto *photo;
const char *uri = NULL;
photo = (FlickrPhoto *) g_file_info_get_attribute_object (file_data->info, "flickr::object");
requested_size = gth_thumb_loader_get_requested_size (thumb_loader);
if (requested_size == FLICKR_SIZE_SMALL_SQUARE)
uri = photo->url[FLICKR_URL_SQ];
else if (requested_size == FLICKR_SIZE_THUMBNAIL)
uri = photo->url[FLICKR_URL_T];
else if (requested_size == FLICKR_SIZE_SMALL)
uri = photo->url[FLICKR_URL_S];
else if (requested_size == FLICKR_SIZE_MEDIUM)
uri = photo->url[FLICKR_URL_M];
if (uri == NULL)
uri = photo->url[FLICKR_URL_O];
if (uri != NULL) {
GFile *file;
void *buffer;
gsize size;
file = g_file_new_for_uri (uri);
if (_g_file_load_in_buffer (file, &buffer, &size, cancellable, error)) {
GInputStream *stream;
GdkPixbuf *pixbuf;
stream = g_memory_input_stream_new_from_data (buffer, size, g_free);
pixbuf = gdk_pixbuf_new_from_stream (stream, cancellable, error);
if (pixbuf != NULL) {
GdkPixbuf *rotated;
rotated = gdk_pixbuf_apply_embedded_orientation (pixbuf);
g_object_unref (pixbuf);
pixbuf = rotated;
image = gth_image_new_for_pixbuf (pixbuf);
}
g_object_unref (pixbuf);
g_object_unref (stream);
}
g_object_unref (file);
}
else
*error = g_error_new_literal (GTH_ERROR, 0, "cannot generate the thumbnail");
return image;
}
GthImage *
gth_pixbuf_new_from_file (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean scale_to_original,
GCancellable *cancellable,
GError **error)
{
ScaleData scale_data;
GdkPixbufLoader *pixbuf_loader;
GdkPixbuf *pixbuf;
GthImage *image;
if (original_width != NULL)
*original_width = -1;
if (original_height != NULL)
*original_height = -1;
scale_data.requested_size = requested_size;
scale_data.original_width = -1;
scale_data.original_height = -1;
scale_data.loader_width = -1;
scale_data.loader_height = -1;
pixbuf_loader = gdk_pixbuf_loader_new ();
g_signal_connect (pixbuf_loader,
"size-prepared",
G_CALLBACK (pixbuf_loader_size_prepared_cb),
&scale_data);
pixbuf = load_from_stream (pixbuf_loader, istream, requested_size, cancellable, error);
g_object_unref (pixbuf_loader);
if ((pixbuf != NULL) && scale_to_original) {
GdkPixbuf *tmp;
tmp = _gdk_pixbuf_scale_simple_safe (pixbuf, scale_data.original_width, scale_data.original_height, GDK_INTERP_NEAREST);
g_object_unref (pixbuf);
pixbuf = tmp;
}
if (pixbuf != NULL) {
GdkPixbuf *rotated;
rotated = gdk_pixbuf_apply_embedded_orientation (pixbuf);
if (rotated != NULL) {
scale_data.original_width = gdk_pixbuf_get_width (rotated);
scale_data.original_height = gdk_pixbuf_get_height (rotated);
g_object_unref (pixbuf);
pixbuf = rotated;
}
}
image = gth_image_new_for_pixbuf (pixbuf);
if (original_width != NULL)
*original_width = scale_data.original_width;
if (original_height != NULL)
*original_height = scale_data.original_height;
_g_object_unref (pixbuf);
return image;
}
static void
screenshot_ready_cb (GdkPixbuf *pixbuf,
gpointer user_data)
{
SaveData *save_data = user_data;
GtkWidget *file_sel;
if (pixbuf == NULL) {
_gtk_error_dialog_from_gerror_show (GTK_WINDOW (save_data->browser), _("Could not take a screenshot"), NULL);
save_date_free (save_data);
return;
}
save_data->image = gth_image_new_for_pixbuf (pixbuf);
file_sel = gth_file_chooser_dialog_new (_("Save Image"), GTK_WINDOW (save_data->browser), "image-saver");
gtk_window_set_modal (GTK_WINDOW (file_sel), TRUE);
{
char *last_uri;
GFile *last_folder;
GthFileData *file_data;
char *prefix;
char *display_name;
int attempt;
last_uri = g_settings_get_string (save_data->settings, PREF_GSTREAMER_TOOLS_SCREESHOT_LOCATION);
if ((last_uri == NULL) || (strcmp (last_uri, "~") == 0) || (strcmp (last_uri, "file://~") == 0)) {
const char *dir;
dir = g_get_user_special_dir (G_USER_DIRECTORY_PICTURES);
if (dir != NULL)
last_folder = g_file_new_for_path (dir);
else
last_folder = g_file_new_for_uri (get_home_uri ());
}
else
last_folder = g_file_new_for_uri (last_uri);
gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (file_sel), last_folder, NULL);
file_data = gth_media_viewer_page_get_file_data (save_data->page);
prefix = _g_utf8_remove_extension (g_file_info_get_display_name (file_data->info));
if (prefix == NULL)
prefix = g_strdup (C_("Filename", "Screenshot"));
display_name = NULL;
for (attempt = 1; attempt < MAX_ATTEMPTS; attempt++) {
GFile *proposed_file;
g_free (display_name);
display_name = g_strdup_printf ("%s-%02d.jpeg", prefix, attempt);
proposed_file = g_file_get_child_for_display_name (last_folder, display_name, NULL);
if ((proposed_file != NULL) && ! g_file_query_exists (proposed_file, NULL)) {
g_object_unref (proposed_file);
break;
}
}
if (display_name != NULL) {
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (file_sel), display_name);
g_free (display_name);
}
g_free (prefix);
g_object_unref (last_folder);
g_free (last_uri);
}
g_signal_connect (GTK_DIALOG (file_sel),
"response",
G_CALLBACK (save_as_response_cb),
save_data);
gtk_widget_show (file_sel);
}
static GthImage *
picasa_web_thumbnail_loader (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gboolean *loaded_original,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image = NULL;
GthThumbLoader *thumb_loader = user_data;
PicasaWebPhoto *photo;
const char *uri;
photo = (PicasaWebPhoto *) g_file_info_get_attribute_object (file_data->info, "gphoto::object");
requested_size = gth_thumb_loader_get_requested_size (thumb_loader);
if (requested_size == 72)
uri = photo->thumbnail_72;
else if (requested_size == 144)
uri = photo->thumbnail_144;
else if (requested_size == 288)
uri = photo->thumbnail_288;
else
uri = NULL;
if (uri == NULL)
uri = photo->uri;
if (uri != NULL) {
GFile *file;
void *buffer;
gsize size;
file = g_file_new_for_uri (uri);
if (_g_file_load_in_buffer (file, &buffer, &size, cancellable, error)) {
GInputStream *stream;
GdkPixbuf *pixbuf;
stream = g_memory_input_stream_new_from_data (buffer, size, g_free);
pixbuf = gdk_pixbuf_new_from_stream (stream, cancellable, error);
if (pixbuf != NULL) {
GdkPixbuf *rotated;
rotated = gdk_pixbuf_apply_embedded_orientation (pixbuf);
g_object_unref (pixbuf);
pixbuf = rotated;
image = gth_image_new_for_pixbuf (pixbuf);
}
g_object_unref (pixbuf);
g_object_unref (stream);
}
g_object_unref (file);
}
else
*error = g_error_new_literal (GTH_ERROR, 0, "cannot generate the thumbnail");
return image;
}
static GthImage *
dcraw_pixbuf_animation_new_from_file (GInputStream *istream,
GthFileData *file_data,
int requested_size,
int *original_width,
int *original_height,
gpointer user_data,
GCancellable *cancellable,
GError **error)
{
GthImage *image = NULL;
GdkPixbuf *pixbuf;
gboolean is_thumbnail;
gboolean is_raw;
gboolean is_hdr;
char *local_file;
char *local_file_md5;
char *cache_file;
char *cache_file_esc;
char *local_file_esc;
char *command = NULL;
if (file_data == NULL) {
if (error != NULL)
*error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_INVALID_FILENAME, "Could not load file");
return NULL;
}
is_thumbnail = requested_size > 0;
is_raw = _g_mime_type_is_raw (gth_file_data_get_mime_type (file_data));
is_hdr = _g_mime_type_is_hdr (gth_file_data_get_mime_type (file_data));
/* The output filename, and its persistence, depend on the input file
* type, and whether or not a thumbnail has been requested. */
local_file = g_file_get_path (file_data->file);
local_file_md5 = gnome_desktop_thumbnail_md5 (local_file);
if (is_raw && !is_thumbnail)
/* Full-sized converted RAW file */
cache_file = get_cache_full_path (local_file_md5, "conv.pnm");
else if (is_raw && is_thumbnail)
/* RAW: thumbnails generated in pnm format. The converted file is later removed. */
cache_file = get_cache_full_path (local_file_md5, "conv-thumb.pnm");
else if (is_hdr && is_thumbnail)
/* HDR: thumbnails generated in tiff format. The converted file is later removed. */
cache_file = get_cache_full_path (local_file_md5, "conv-thumb.tiff");
else
/* Full-sized converted HDR files */
cache_file = get_cache_full_path (local_file_md5, "conv.tiff");
g_free (local_file_md5);
if (cache_file == NULL) {
g_free (local_file);
return NULL;
}
local_file_esc = g_shell_quote (local_file);
cache_file_esc = g_shell_quote (cache_file);
/* Do nothing if an up-to-date converted file is already in the cache */
if (! g_file_test (cache_file, G_FILE_TEST_EXISTS)
|| (gth_file_data_get_mtime (file_data) > get_file_mtime (cache_file)))
{
if (is_raw) {
if (is_thumbnail) {
char *first_part;
char *jpg_thumbnail;
char *tiff_thumbnail;
char *ppm_thumbnail;
char *thumb_command;
thumb_command = g_strdup_printf ("dcraw -e %s", local_file_esc);
g_spawn_command_line_sync (thumb_command, NULL, NULL, NULL, NULL);
g_free (thumb_command);
first_part = _g_uri_remove_extension (local_file);
jpg_thumbnail = g_strdup_printf ("%s.thumb.jpg", first_part);
tiff_thumbnail = g_strdup_printf ("%s.thumb.tiff", first_part);
ppm_thumbnail = g_strdup_printf ("%s.thumb.ppm", first_part);
if (g_file_test (jpg_thumbnail, G_FILE_TEST_EXISTS)) {
g_free (cache_file);
cache_file = g_strdup (jpg_thumbnail);
}
else if (g_file_test (tiff_thumbnail, G_FILE_TEST_EXISTS)) {
g_free (cache_file);
cache_file = g_strdup (tiff_thumbnail);
}
else if (g_file_test (ppm_thumbnail, G_FILE_TEST_EXISTS)) {
g_free (cache_file);
cache_file = g_strdup (ppm_thumbnail);
}
else {
/* No embedded thumbnail. Read the whole file. */
/* Add -h option to speed up thumbnail generation. */
command = g_strdup_printf ("dcraw -w -c -h %s > %s",
local_file_esc,
cache_file_esc);
}
g_free (first_part);
g_free (jpg_thumbnail);
g_free (tiff_thumbnail);
g_free (ppm_thumbnail);
}
else {
/* -w option = camera-specified white balance */
command = g_strdup_printf ("dcraw -w -c %s > %s",
local_file_esc,
cache_file_esc);
}
}
if (is_hdr) {
/* HDR files. We can use the pfssize tool to speed up
thumbnail generation considerably, so we treat
thumbnailing as a special case. */
char *resize_command;
if (is_thumbnail)
resize_command = g_strdup_printf (" | pfssize --maxx %d --maxy %d",
requested_size,
requested_size);
else
resize_command = g_strdup_printf (" ");
command = g_strconcat ( "pfsin ",
local_file_esc,
resize_command,
" | pfsclamp --rgb | pfstmo_drago03 | pfsout ",
cache_file_esc,
NULL );
g_free (resize_command);
}
if (command != NULL) {
if (system (command) == -1) {
g_free (command);
g_free (cache_file_esc);
g_free (local_file_esc);
g_free (cache_file);
g_free (local_file);
return NULL;
}
g_free (command);
}
}
pixbuf = gdk_pixbuf_new_from_file (cache_file, NULL);
/* Thumbnail files are already cached, so delete the conversion cache copies */
if (is_thumbnail) {
GFile *file;
file = g_file_new_for_path (cache_file);
g_file_delete (file, NULL, NULL);
g_object_unref (file);
}
if (pixbuf != NULL) {
image = gth_image_new_for_pixbuf (pixbuf);
g_object_unref (pixbuf);
}
g_free (cache_file_esc);
g_free (local_file_esc);
g_free (cache_file);
g_free (local_file);
return image;
}
