1 /*
2 * Copyright (C) 2004 John Ellis
3 * Copyright (C) 2008 - 2016 The Geeqie Team
4 *
5 * Author: John Ellis
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include "main.h"
23 #include "thumb.h"
24
25 #include "cache.h"
26 #include "image-load.h"
27 #include "filedata.h"
28 #include "pixbuf_util.h"
29 #include "thumb_standard.h"
30 #include "ui_fileops.h"
31 #include "exif.h"
32 #include "metadata.h"
33
34 #include <utime.h>
35
36
37 static void thumb_loader_error_cb(ImageLoader *il, gpointer data);
38 static void thumb_loader_setup(ThumbLoader *tl, FileData *fd);
39
40 static GdkPixbuf *get_xv_thumbnail(gchar *thumb_filename, gint max_w, gint max_h);
41
42
43 /*
44 *-----------------------------------------------------------------------------
45 * thumbnail routines: creation, caching, and maintenance (public)
46 *-----------------------------------------------------------------------------
47 */
48
49 /* Save thumbnail to disk
50 * or just mark failed thumbnail with 0 byte file (mark_failure = TRUE) */
thumb_loader_save_thumbnail(ThumbLoader * tl,gboolean mark_failure)51 static gboolean thumb_loader_save_thumbnail(ThumbLoader *tl, gboolean mark_failure)
52 {
53 gchar *cache_dir;
54 gboolean success = FALSE;
55 mode_t mode = 0755;
56
57 if (!tl || !tl->fd) return FALSE;
58 if (!mark_failure && !tl->fd->thumb_pixbuf) return FALSE;
59
60 cache_dir = cache_get_location(CACHE_TYPE_THUMB, tl->fd->path, FALSE, &mode);
61
62 if (recursive_mkdir_if_not_exists(cache_dir, mode))
63 {
64 gchar *cache_path;
65 gchar *pathl;
66 gchar *name = g_strconcat(filename_from_path(tl->fd->path), GQ_CACHE_EXT_THUMB, NULL);
67
68 cache_path = g_build_filename(cache_dir, name, NULL);
69 g_free(name);
70
71 pathl = path_from_utf8(cache_path);
72
73 if (mark_failure)
74 {
75 FILE *f = fopen(pathl, "w"); ;
76
77 DEBUG_1("Marking thumb failure: %s", cache_path);
78 if (f)
79 {
80 fclose(f);
81 success = TRUE;
82 }
83 }
84 else
85 {
86 DEBUG_1("Saving thumb: %s", cache_path);
87 success = pixbuf_to_file_as_png(tl->fd->thumb_pixbuf, pathl);
88 }
89
90 if (success)
91 {
92 struct utimbuf ut;
93 /* set thumb time to that of source file */
94
95 ut.actime = ut.modtime = filetime(tl->fd->path);
96 if (ut.modtime > 0)
97 {
98 utime(pathl, &ut);
99 }
100 }
101 else
102 {
103 DEBUG_1("Saving failed: %s", pathl);
104 }
105
106 g_free(pathl);
107 g_free(cache_path);
108 }
109
110 g_free(cache_dir);
111
112 return success;
113 }
114
thumb_loader_percent_cb(ImageLoader * il,gdouble percent,gpointer data)115 static void thumb_loader_percent_cb(ImageLoader *il, gdouble percent, gpointer data)
116 {
117 ThumbLoader *tl = data;
118
119 tl->percent_done = percent;
120
121 if (tl->func_progress) tl->func_progress(tl, tl->data);
122 }
123
thumb_loader_set_fallback(ThumbLoader * tl)124 static void thumb_loader_set_fallback(ThumbLoader *tl)
125 {
126 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
127 tl->fd->thumb_pixbuf = pixbuf_fallback(tl->fd, tl->max_w, tl->max_h);
128 }
129
thumb_loader_done_cb(ImageLoader * il,gpointer data)130 static void thumb_loader_done_cb(ImageLoader *il, gpointer data)
131 {
132 ThumbLoader *tl = data;
133 GdkPixbuf *pixbuf;
134 gint pw, ph;
135 gint save;
136 GdkPixbuf *rotated = NULL;
137
138 DEBUG_1("thumb done: %s", tl->fd->path);
139
140 pixbuf = image_loader_get_pixbuf(tl->il);
141 if (!pixbuf)
142 {
143 DEBUG_1("...but no pixbuf: %s", tl->fd->path);
144 thumb_loader_error_cb(tl->il, tl);
145 return;
146 }
147
148
149 if (!tl->cache_hit && options->image.exif_rotate_enable)
150 {
151 if (!tl->fd->exif_orientation)
152 {
153 tl->fd->exif_orientation = metadata_read_int(tl->fd, ORIENTATION_KEY, EXIF_ORIENTATION_TOP_LEFT);
154 }
155
156 if (tl->fd->exif_orientation != EXIF_ORIENTATION_TOP_LEFT)
157 {
158 rotated = pixbuf_apply_orientation(pixbuf, tl->fd->exif_orientation);
159 pixbuf = rotated;
160 }
161 }
162
163 pw = gdk_pixbuf_get_width(pixbuf);
164 ph = gdk_pixbuf_get_height(pixbuf);
165
166 if (tl->cache_hit && pw != tl->max_w && ph != tl->max_h)
167 {
168 /* requested thumbnail size may have changed, load original */
169 DEBUG_1("thumbnail size mismatch, regenerating: %s", tl->fd->path);
170 tl->cache_hit = FALSE;
171
172 thumb_loader_setup(tl, tl->fd);
173
174 g_signal_connect(G_OBJECT(tl->il), "done", (GCallback)thumb_loader_done_cb, tl);
175
176 if (!image_loader_start(tl->il))
177 {
178 image_loader_free(tl->il);
179 tl->il = NULL;
180
181 DEBUG_1("regeneration failure: %s", tl->fd->path);
182 thumb_loader_error_cb(tl->il, tl);
183 }
184 return;
185 }
186
187 /* scale ?? */
188
189 if (pw > tl->max_w || ph > tl->max_h)
190 {
191 gint w, h;
192
193 if (((gdouble)tl->max_w / pw) < ((gdouble)tl->max_h / ph))
194 {
195 w = tl->max_w;
196 h = (gdouble)w / pw * ph;
197 if (h < 1) h = 1;
198 }
199 else
200 {
201 h = tl->max_h;
202 w = (gdouble)h / ph * pw;
203 if (w < 1) w = 1;
204 }
205
206 if (tl->fd)
207 {
208 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
209 tl->fd->thumb_pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, (GdkInterpType)options->thumbnails.quality);
210 }
211 save = TRUE;
212 }
213 else
214 {
215 if (tl->fd)
216 {
217 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
218 tl->fd->thumb_pixbuf = pixbuf;
219
220 g_object_ref(tl->fd->thumb_pixbuf);
221 }
222 save = image_loader_get_shrunk(il);
223 }
224
225 if (rotated) g_object_unref(rotated);
226
227 /* save it ? */
228 if (tl->cache_enable && save)
229 {
230 thumb_loader_save_thumbnail(tl, FALSE);
231 }
232
233 if (tl->func_done) tl->func_done(tl, tl->data);
234 }
235
thumb_loader_error_cb(ImageLoader * il,gpointer data)236 static void thumb_loader_error_cb(ImageLoader *il, gpointer data)
237 {
238 ThumbLoader *tl = data;
239
240 /* if at least some of the image is available, go to done_cb */
241 if (image_loader_get_pixbuf(tl->il) != NULL)
242 {
243 thumb_loader_done_cb(il, data);
244 return;
245 }
246
247 DEBUG_1("thumb error: %s", tl->fd->path);
248
249 image_loader_free(tl->il);
250 tl->il = NULL;
251
252 thumb_loader_set_fallback(tl);
253
254 if (tl->func_error) tl->func_error(tl, tl->data);
255 }
256
thumb_loader_done_delay_cb(gpointer data)257 static gboolean thumb_loader_done_delay_cb(gpointer data)
258 {
259 ThumbLoader *tl = data;
260
261 tl->idle_done_id = 0;
262
263 if (tl->func_done) tl->func_done(tl, tl->data);
264
265 return FALSE;
266 }
267
thumb_loader_delay_done(ThumbLoader * tl)268 static void thumb_loader_delay_done(ThumbLoader *tl)
269 {
270 if (!tl->idle_done_id) tl->idle_done_id = g_idle_add(thumb_loader_done_delay_cb, tl);
271 }
272
thumb_loader_setup(ThumbLoader * tl,FileData * fd)273 static void thumb_loader_setup(ThumbLoader *tl, FileData *fd)
274 {
275 image_loader_free(tl->il);
276 tl->il = image_loader_new(fd);
277 image_loader_set_priority(tl->il, G_PRIORITY_LOW);
278
279 /* this will speed up jpegs by up to 3x in some cases */
280 image_loader_set_requested_size(tl->il, tl->max_w, tl->max_h);
281
282 g_signal_connect(G_OBJECT(tl->il), "error", (GCallback)thumb_loader_error_cb, tl);
283 if (tl->func_progress) g_signal_connect(G_OBJECT(tl->il), "percent", (GCallback)thumb_loader_percent_cb, tl);
284 }
285
thumb_loader_set_callbacks(ThumbLoader * tl,ThumbLoaderFunc func_done,ThumbLoaderFunc func_error,ThumbLoaderFunc func_progress,gpointer data)286 void thumb_loader_set_callbacks(ThumbLoader *tl,
287 ThumbLoaderFunc func_done,
288 ThumbLoaderFunc func_error,
289 ThumbLoaderFunc func_progress,
290 gpointer data)
291 {
292 if (!tl) return;
293
294 if (tl->standard_loader)
295 {
296 thumb_loader_std_set_callbacks((ThumbLoaderStd *)tl,
297 (ThumbLoaderStdFunc) func_done,
298 (ThumbLoaderStdFunc) func_error,
299 (ThumbLoaderStdFunc) func_progress,
300 data);
301 return;
302 }
303
304 tl->func_done = func_done;
305 tl->func_error = func_error;
306 tl->func_progress = func_progress;
307
308 tl->data = data;
309 }
310
thumb_loader_set_cache(ThumbLoader * tl,gboolean enable_cache,gboolean local,gboolean retry_failed)311 void thumb_loader_set_cache(ThumbLoader *tl, gboolean enable_cache, gboolean local, gboolean retry_failed)
312 {
313 if (!tl) return;
314
315 if (tl->standard_loader)
316 {
317 thumb_loader_std_set_cache((ThumbLoaderStd *)tl, enable_cache, local, retry_failed);
318 return;
319 }
320
321 tl->cache_enable = enable_cache;
322 }
323
324
thumb_loader_start(ThumbLoader * tl,FileData * fd)325 gboolean thumb_loader_start(ThumbLoader *tl, FileData *fd)
326 {
327 gchar *cache_path = NULL;
328
329 if (!tl) return FALSE;
330
331 if (tl->standard_loader)
332 {
333 return thumb_loader_std_start((ThumbLoaderStd *)tl, fd);
334 }
335
336 if (!tl->fd && !fd) return FALSE;
337
338 if (!tl->fd) tl->fd = file_data_ref(fd);
339
340 if (tl->fd->format_class != FORMAT_CLASS_IMAGE && tl->fd->format_class != FORMAT_CLASS_RAWIMAGE && tl->fd->format_class != FORMAT_CLASS_COLLECTION && tl->fd->format_class != FORMAT_CLASS_VIDEO && tl->fd->format_class != FORMAT_CLASS_DOCUMENT && !options->file_filter.disable)
341 {
342 thumb_loader_set_fallback(tl);
343 return FALSE;
344 }
345
346 if (tl->cache_enable)
347 {
348 cache_path = cache_find_location(CACHE_TYPE_THUMB, tl->fd->path);
349
350 if (cache_path)
351 {
352 if (cache_time_valid(cache_path, tl->fd->path))
353 {
354 DEBUG_1("Found in cache:%s", tl->fd->path);
355
356 if (filesize(cache_path) == 0)
357 {
358 DEBUG_1("Broken image mark found:%s", cache_path);
359 g_free(cache_path);
360 thumb_loader_set_fallback(tl);
361 return FALSE;
362 }
363
364 DEBUG_1("Cache location:%s", cache_path);
365 }
366 else
367 {
368 g_free(cache_path);
369 cache_path = NULL;
370 }
371 }
372 }
373
374 if (!cache_path && options->thumbnails.use_xvpics)
375 {
376 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
377 tl->fd->thumb_pixbuf = get_xv_thumbnail(tl->fd->path, tl->max_w, tl->max_h);
378 if (tl->fd->thumb_pixbuf)
379 {
380 thumb_loader_delay_done(tl);
381 return TRUE;
382 }
383 }
384
385 if (cache_path)
386 {
387 FileData *fd = file_data_new_no_grouping(cache_path);
388 thumb_loader_setup(tl, fd);
389 file_data_unref(fd);
390 g_free(cache_path);
391 tl->cache_hit = TRUE;
392 }
393 else
394 {
395 thumb_loader_setup(tl, tl->fd);
396 }
397
398 g_signal_connect(G_OBJECT(tl->il), "done", (GCallback)thumb_loader_done_cb, tl);
399 if (!image_loader_start(tl->il))
400 {
401 /* try from original if cache attempt */
402 if (tl->cache_hit)
403 {
404 tl->cache_hit = FALSE;
405 log_printf("%s", _("Thumbnail image in cache failed to load, trying to recreate.\n"));
406
407 thumb_loader_setup(tl, tl->fd);
408 g_signal_connect(G_OBJECT(tl->il), "done", (GCallback)thumb_loader_done_cb, tl);
409 if (image_loader_start(tl->il)) return TRUE;
410 }
411 /* mark failed thumbnail in cache with 0 byte file */
412 if (tl->cache_enable)
413 {
414 thumb_loader_save_thumbnail(tl, TRUE);
415 }
416
417 image_loader_free(tl->il);
418 tl->il = NULL;
419 thumb_loader_set_fallback(tl);
420 return FALSE;
421 }
422
423 return TRUE;
424 }
425
thumb_loader_get_pixbuf(ThumbLoader * tl)426 GdkPixbuf *thumb_loader_get_pixbuf(ThumbLoader *tl)
427 {
428 GdkPixbuf *pixbuf;
429
430 if (tl && tl->standard_loader)
431 {
432 return thumb_loader_std_get_pixbuf((ThumbLoaderStd *)tl);
433 }
434
435 if (tl && tl->fd && tl->fd->thumb_pixbuf)
436 {
437 pixbuf = tl->fd->thumb_pixbuf;
438 g_object_ref(pixbuf);
439 }
440 else
441 {
442 pixbuf = pixbuf_fallback(NULL, tl->max_w, tl->max_h);
443 }
444
445 return pixbuf;
446 }
447
thumb_loader_new(gint width,gint height)448 ThumbLoader *thumb_loader_new(gint width, gint height)
449 {
450 ThumbLoader *tl;
451
452 /* non-std thumb loader is more effective for configurations with disabled caching
453 because it loads the thumbnails at the required size. loader_std loads
454 the thumbnails at the sizes appropriate for standard cache (typically 256x256 pixels)
455 and then performs one additional scaling */
456 if (options->thumbnails.spec_standard && options->thumbnails.enable_caching)
457 {
458 return (ThumbLoader *)thumb_loader_std_new(width, height);
459 }
460
461 tl = g_new0(ThumbLoader, 1);
462
463 tl->cache_enable = options->thumbnails.enable_caching;
464 tl->percent_done = 0.0;
465 tl->max_w = width;
466 tl->max_h = height;
467
468 return tl;
469 }
470
thumb_loader_free(ThumbLoader * tl)471 void thumb_loader_free(ThumbLoader *tl)
472 {
473 if (!tl) return;
474
475 if (tl->standard_loader)
476 {
477 thumb_loader_std_free((ThumbLoaderStd *)tl);
478 return;
479 }
480
481 image_loader_free(tl->il);
482 file_data_unref(tl->fd);
483
484 if (tl->idle_done_id) g_source_remove(tl->idle_done_id);
485
486 g_free(tl);
487 }
488
489 /* release thumb_pixbuf on file change - this forces reload. */
thumb_notify_cb(FileData * fd,NotifyType type,gpointer data)490 void thumb_notify_cb(FileData *fd, NotifyType type, gpointer data)
491 {
492 if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE)) && fd->thumb_pixbuf)
493 {
494 DEBUG_1("Notify thumb: %s %04x", fd->path, type);
495 g_object_unref(fd->thumb_pixbuf);
496 fd->thumb_pixbuf = NULL;
497 }
498 }
499
500
501 /*
502 *-----------------------------------------------------------------------------
503 * xvpics thumbnail support, read-only (private)
504 *-----------------------------------------------------------------------------
505 */
506
507 /*
508 * xvpics code originally supplied by:
509 * "Diederen Damien" <D.Diederen@student.ulg.ac.be>
510 *
511 * Note: Code has been modified to fit the style of the other code, and to use
512 * a few more glib-isms.
513 * 08-28-2000: Updated to return a gdk_pixbuf, Imlib is dieing a death here.
514 */
515
516 #define XV_BUFFER 2048
load_xv_thumbnail(gchar * filename,gint * widthp,gint * heightp)517 static guchar *load_xv_thumbnail(gchar *filename, gint *widthp, gint *heightp)
518 {
519 FILE *file;
520 gchar buffer[XV_BUFFER];
521 guchar *data = NULL;
522
523 file = fopen(filename, "rt");
524 if (!file) return NULL;
525
526 if (fgets(buffer, XV_BUFFER, file) != NULL
527 && strncmp(buffer, "P7 332", 6) == 0)
528 {
529 gint width, height, depth;
530
531 while (fgets(buffer, XV_BUFFER, file) && buffer[0] == '#') /* do_nothing() */;
532
533 if (sscanf(buffer, "%d %d %d", &width, &height, &depth) == 3)
534 {
535 gsize size = width * height;
536
537 data = g_new(guchar, size);
538 if (data && fread(data, 1, size, file) == size)
539 {
540 *widthp = width;
541 *heightp = height;
542 }
543 }
544 }
545
546 fclose(file);
547 return data;
548 }
549 #undef XV_BUFFER
550
free_rgb_buffer(guchar * pixels,gpointer data)551 static void free_rgb_buffer(guchar *pixels, gpointer data)
552 {
553 g_free(pixels);
554 }
555
get_xv_thumbnail(gchar * thumb_filename,gint max_w,gint max_h)556 static GdkPixbuf *get_xv_thumbnail(gchar *thumb_filename, gint max_w, gint max_h)
557 {
558 gint width, height;
559 gchar *thumb_name;
560 gchar *path;
561 gchar *directory;
562 gchar *name;
563 guchar *packed_data;
564
565 path = path_from_utf8(thumb_filename);
566 directory = g_path_get_dirname(path);
567 name = g_path_get_basename(path);
568
569 thumb_name = g_build_filename(directory, ".xvpics", name, NULL);
570
571 g_free(name);
572 g_free(directory);
573 g_free(path);
574
575 packed_data = load_xv_thumbnail(thumb_name, &width, &height);
576 g_free(thumb_name);
577
578 if (packed_data)
579 {
580 guchar *rgb_data;
581 GdkPixbuf *pixbuf;
582 gint i;
583
584 rgb_data = g_new(guchar, width * height * 3);
585 for (i = 0; i < width * height; i++)
586 {
587 rgb_data[i * 3 + 0] = (packed_data[i] >> 5) * 36;
588 rgb_data[i * 3 + 1] = ((packed_data[i] & 28) >> 2) * 36;
589 rgb_data[i * 3 + 2] = (packed_data[i] & 3) * 85;
590 }
591 g_free(packed_data);
592
593 pixbuf = gdk_pixbuf_new_from_data(rgb_data, GDK_COLORSPACE_RGB, FALSE, 8,
594 width, height, 3 * width, free_rgb_buffer, NULL);
595
596 if (pixbuf_scale_aspect(width, height, max_w, max_h, &width, &height))
597 {
598 /* scale */
599 GdkPixbuf *tmp;
600
601 tmp = pixbuf;
602 pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_NEAREST);
603 g_object_unref(tmp);
604 }
605
606 return pixbuf;
607 }
608
609 return NULL;
610 }
611 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
612