Mercurial > geeqie.yaz
annotate src/thumb_standard.c @ 882:912726c2f5e3
Fix a segfault occuring when opening some collection files.
Skip all lines not starting with a # when only geometry is required.
author | zas_ |
---|---|
date | Sun, 13 Jul 2008 12:36:18 +0000 |
parents | 10d0bf784323 |
children | 2ea1059a6091 |
rev | line source |
---|---|
9 | 1 /* |
196 | 2 * Geeqie |
79
528e3432e0c0
Thu Oct 19 07:23:37 2006 John Ellis <johne@verizon.net>
gqview
parents:
66
diff
changeset
|
3 * (C) 2006 John Ellis |
475 | 4 * Copyright (C) 2008 The Geeqie Team |
9 | 5 * |
6 * Author: John Ellis | |
7 * | |
8 * This software is released under the GNU General Public License (GNU GPL). | |
9 * Please read the included file COPYING for more information. | |
10 * This software comes with no warranty of any kind, use at your own risk! | |
11 */ | |
12 | |
13 | |
281 | 14 #include "main.h" |
9 | 15 #include "thumb_standard.h" |
16 | |
17 #include "cache.h" /* for cache_ensure_dir_exists */ | |
18 #include "image-load.h" | |
19 #include "md5-util.h" | |
20 #include "pixbuf_util.h" | |
21 #include "ui_fileops.h" | |
838 | 22 #include "filedata.h" |
839 | 23 #include "exif.h" |
9 | 24 |
25 | |
26 /* | |
27 * This thumbnail caching implementation attempts to conform | |
28 * to the Thumbnail Managing Standard proposed on freedesktop.org | |
29 * The standard is documented here: | |
30 * http://triq.net/~jens/thumbnail-spec/index.html | |
31 * (why isn't it actually hosted on freedesktop.org?) | |
32 * | |
33 * This code attempts to conform to version 0.7.0 of the standard. | |
34 * | |
35 * Notes: | |
36 * > Validation of the thumb's embedded uri is a simple strcmp between our | |
37 * version of the escaped uri and the thumb's escaped uri. But not all uri | |
38 * escape functions escape the same set of chars, comparing the unescaped | |
39 * versions may be more accurate. | |
40 * > Only Thumb::URI and Thumb::MTime are stored in a thumb at this time. | |
41 * Storing the Size, Width, Height should probably be implemented. | |
42 */ | |
43 | |
44 | |
45 #define THUMB_SIZE_NORMAL 128 | |
46 #define THUMB_SIZE_LARGE 256 | |
47 | |
48 #define THUMB_MARKER_URI "tEXt::Thumb::URI" | |
49 #define THUMB_MARKER_MTIME "tEXt::Thumb::MTime" | |
50 #define THUMB_MARKER_SIZE "tEXt::Thumb::Size" | |
51 #define THUMB_MARKER_WIDTH "tEXt::Thumb::Image::Width" | |
52 #define THUMB_MARKER_HEIGHT "tEXt::Thumb::Image::Height" | |
53 #define THUMB_MARKER_APP "tEXt::Software" | |
54 | |
55 #define THUMB_PERMS_FOLDER 0700 | |
56 #define THUMB_PERMS_THUMB 0600 | |
57 | |
58 | |
59 | |
60 /* | |
61 *----------------------------------------------------------------------------- | |
62 * thumbnail loader | |
63 *----------------------------------------------------------------------------- | |
64 */ | |
65 | |
66 | |
67 static void thumb_loader_std_error_cb(ImageLoader *il, gpointer data); | |
68 static gint thumb_loader_std_setup(ThumbLoaderStd *tl, const gchar *path); | |
69 | |
70 | |
71 ThumbLoaderStd *thumb_loader_std_new(gint width, gint height) | |
72 { | |
73 ThumbLoaderStd *tl; | |
74 | |
75 tl = g_new0(ThumbLoaderStd, 1); | |
76 | |
77 tl->standard_loader = TRUE; | |
78 | |
79 tl->requested_width = width; | |
80 tl->requested_height = height; | |
81 | |
82 tl->il = NULL; | |
838 | 83 tl->fd = NULL; |
9 | 84 |
333 | 85 tl->cache_enable = options->thumbnails.enable_caching; |
9 | 86 tl->cache_local = FALSE; |
87 tl->cache_retry = FALSE; | |
88 | |
89 return tl; | |
90 } | |
91 | |
92 void thumb_loader_std_set_callbacks(ThumbLoaderStd *tl, | |
93 ThumbLoaderStdFunc func_done, | |
94 ThumbLoaderStdFunc func_error, | |
95 ThumbLoaderStdFunc func_progress, | |
96 gpointer data) | |
97 { | |
98 if (!tl) return; | |
99 | |
100 tl->func_done = func_done; | |
101 tl->func_error = func_error; | |
102 tl->func_progress = func_progress; | |
103 tl->data = data; | |
104 } | |
105 | |
106 static void thumb_loader_std_reset(ThumbLoaderStd *tl) | |
107 { | |
108 image_loader_free(tl->il); | |
109 tl->il = NULL; | |
110 | |
838 | 111 file_data_unref(tl->fd); |
112 tl->fd = NULL; | |
9 | 113 |
114 g_free(tl->thumb_path); | |
115 tl->thumb_path = NULL; | |
116 | |
117 g_free(tl->thumb_uri); | |
118 tl->thumb_uri = NULL; | |
119 tl->local_uri = NULL; | |
120 | |
121 tl->thumb_path_local = FALSE; | |
122 | |
123 tl->cache_hit = FALSE; | |
124 | |
125 tl->source_mtime = 0; | |
126 tl->source_size = 0; | |
127 tl->source_mode = 0; | |
128 | |
129 tl->progress = 0.0; | |
130 } | |
131 | |
132 static gchar *thumb_std_cache_path(const gchar *path, const gchar *uri, gint local, | |
133 const gchar *cache_subfolder) | |
134 { | |
135 gchar *result = NULL; | |
136 gchar *md5_text; | |
137 guchar digest[16]; | |
716
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
138 gchar *name; |
9 | 139 |
140 if (!path || !uri || !cache_subfolder) return NULL; | |
141 | |
716
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
142 md5_get_digest((guchar *)uri, strlen(uri), digest); |
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
143 md5_text = md5_digest_to_text(digest); |
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
144 |
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
145 if (!md5_text) return NULL; |
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
146 |
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
147 name = g_strconcat(md5_text, THUMB_NAME_EXTENSION, NULL); |
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
148 |
9 | 149 if (local) |
150 { | |
716
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
151 gchar *base = remove_level_from_path(path); |
9 | 152 |
716
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
153 result = g_build_filename(base, THUMB_FOLDER_LOCAL, cache_subfolder, name, NULL); |
9 | 154 g_free(base); |
155 } | |
156 else | |
157 { | |
716
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
158 result = g_build_filename(homedir(), THUMB_FOLDER_GLOBAL, cache_subfolder, name, NULL); |
9 | 159 } |
160 | |
716
c534b8cecc1f
thumb_std_cache_path(): use g_build_filename() and simplify.
zas_
parents:
671
diff
changeset
|
161 g_free(name); |
9 | 162 g_free(md5_text); |
163 | |
164 return result; | |
165 } | |
166 | |
167 static gchar *thumb_loader_std_cache_path(ThumbLoaderStd *tl, gint local, GdkPixbuf *pixbuf, gint fail) | |
168 { | |
436 | 169 const gchar *folder; |
9 | 170 gint w, h; |
171 | |
838 | 172 if (!tl->fd || !tl->thumb_uri) return NULL; |
9 | 173 |
174 if (pixbuf) | |
175 { | |
176 w = gdk_pixbuf_get_width(pixbuf); | |
177 h = gdk_pixbuf_get_height(pixbuf); | |
178 } | |
179 else | |
180 { | |
181 w = tl->requested_width; | |
182 h = tl->requested_height; | |
183 } | |
184 | |
185 if (fail) | |
186 { | |
436 | 187 folder = THUMB_FOLDER_FAIL; |
9 | 188 } |
189 else if (w > THUMB_SIZE_NORMAL || h > THUMB_SIZE_NORMAL) | |
190 { | |
436 | 191 folder = THUMB_FOLDER_LARGE; |
9 | 192 } |
193 else | |
194 { | |
436 | 195 folder = THUMB_FOLDER_NORMAL; |
9 | 196 } |
197 | |
838 | 198 return thumb_std_cache_path(tl->fd->path, |
9 | 199 (local) ? tl->local_uri : tl->thumb_uri, |
436 | 200 local, folder); |
9 | 201 } |
202 | |
203 static gint thumb_loader_std_fail_check(ThumbLoaderStd *tl) | |
204 { | |
205 gchar *fail_path; | |
206 gint result = FALSE; | |
207 | |
208 fail_path = thumb_loader_std_cache_path(tl, FALSE, NULL, TRUE); | |
209 if (isfile(fail_path)) | |
210 { | |
211 GdkPixbuf *pixbuf; | |
212 | |
213 if (tl->cache_retry) | |
214 { | |
215 pixbuf = NULL; | |
216 } | |
217 else | |
218 { | |
219 gchar *pathl; | |
220 | |
221 pathl = path_from_utf8(fail_path); | |
222 pixbuf = gdk_pixbuf_new_from_file(pathl, NULL); | |
223 g_free(pathl); | |
224 } | |
225 | |
226 if (pixbuf) | |
227 { | |
228 const gchar *mtime_str; | |
229 | |
230 mtime_str = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_MTIME); | |
231 if (mtime_str && strtol(mtime_str, NULL, 10) == tl->source_mtime) | |
232 { | |
233 result = TRUE; | |
838 | 234 DEBUG_1("thumb fail valid: %s", tl->fd->path); |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
235 DEBUG_1(" thumb: %s", fail_path); |
9 | 236 } |
237 | |
238 g_object_unref(G_OBJECT(pixbuf)); | |
239 } | |
240 | |
241 if (!result) unlink_file(fail_path); | |
242 } | |
243 g_free(fail_path); | |
244 | |
245 return result; | |
246 } | |
247 | |
248 static gint thumb_loader_std_validate(ThumbLoaderStd *tl, GdkPixbuf *pixbuf) | |
249 { | |
250 const gchar *valid_uri; | |
251 const gchar *uri; | |
252 const gchar *mtime_str; | |
253 time_t mtime; | |
254 gint w, h; | |
255 | |
256 if (!pixbuf) return FALSE; | |
257 | |
258 w = gdk_pixbuf_get_width(pixbuf); | |
259 h = gdk_pixbuf_get_height(pixbuf); | |
260 | |
261 if (w != THUMB_SIZE_NORMAL && w != THUMB_SIZE_LARGE && | |
262 h != THUMB_SIZE_NORMAL && h != THUMB_SIZE_LARGE) return FALSE; | |
263 | |
264 valid_uri = (tl->thumb_path_local) ? tl->local_uri : tl->thumb_uri; | |
265 | |
266 uri = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_URI); | |
267 mtime_str = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_MTIME); | |
268 | |
269 if (!mtime_str || !uri || !valid_uri) return FALSE; | |
270 if (strcmp(uri, valid_uri) != 0) return FALSE; | |
271 | |
272 mtime = strtol(mtime_str, NULL, 10); | |
273 if (tl->source_mtime != mtime) return FALSE; | |
274 | |
275 return TRUE; | |
276 } | |
277 | |
278 static void thumb_loader_std_save(ThumbLoaderStd *tl, GdkPixbuf *pixbuf) | |
279 { | |
280 gchar *base_path; | |
281 gchar *tmp_path; | |
282 gint fail; | |
283 | |
284 if (!tl->cache_enable || tl->cache_hit) return; | |
285 if (tl->thumb_path) return; | |
286 | |
287 if (!pixbuf) | |
288 { | |
289 /* local failures are not stored */ | |
290 if (tl->cache_local) return; | |
291 | |
436 | 292 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 1, 1); |
9 | 293 fail = TRUE; |
294 } | |
295 else | |
296 { | |
297 g_object_ref(G_OBJECT(pixbuf)); | |
298 fail = FALSE; | |
299 } | |
300 | |
301 tl->thumb_path = thumb_loader_std_cache_path(tl, tl->cache_local, pixbuf, fail); | |
302 if (!tl->thumb_path) | |
303 { | |
304 g_object_unref(G_OBJECT(pixbuf)); | |
305 return; | |
306 } | |
307 tl->thumb_path_local = tl->cache_local; | |
308 | |
309 /* create thumbnail dir if needed */ | |
310 base_path = remove_level_from_path(tl->thumb_path); | |
311 if (tl->cache_local) | |
312 { | |
313 if (!isdir(base_path)) | |
314 { | |
315 struct stat st; | |
316 gchar *source_base; | |
317 | |
838 | 318 source_base = remove_level_from_path(tl->fd->path); |
9 | 319 if (stat_utf8(source_base, &st)) |
320 { | |
321 cache_ensure_dir_exists(base_path, st.st_mode); | |
322 } | |
323 g_free(source_base); | |
324 } | |
325 } | |
326 else | |
327 { | |
328 cache_ensure_dir_exists(base_path, THUMB_PERMS_FOLDER); | |
329 } | |
330 g_free(base_path); | |
331 | |
838 | 332 DEBUG_1("thumb saving: %s", tl->fd->path); |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
333 DEBUG_1(" saved: %s", tl->thumb_path); |
9 | 334 |
335 /* save thumb, using a temp file then renaming into place */ | |
336 tmp_path = unique_filename(tl->thumb_path, ".tmp", "_", 2); | |
337 if (tmp_path) | |
338 { | |
339 const gchar *mark_uri; | |
340 gchar *mark_app; | |
341 gchar *mark_mtime; | |
342 gchar *pathl; | |
343 gint success; | |
344 | |
345 mark_uri = (tl->cache_local) ? tl->local_uri :tl->thumb_uri; | |
346 | |
288
d1f74154463e
Replace occurences of Geeqie / geeqie by constants defined in main.h.
zas_
parents:
281
diff
changeset
|
347 mark_app = g_strdup_printf("%s %s", GQ_APPNAME, VERSION); |
9 | 348 mark_mtime = g_strdup_printf("%lu", tl->source_mtime); |
349 | |
350 pathl = path_from_utf8(tmp_path); | |
351 success = gdk_pixbuf_save(pixbuf, pathl, "png", NULL, | |
352 THUMB_MARKER_URI, mark_uri, | |
353 THUMB_MARKER_MTIME, mark_mtime, | |
354 THUMB_MARKER_APP, mark_app, | |
355 NULL); | |
356 if (success) | |
357 { | |
358 chmod(pathl, (tl->cache_local) ? tl->source_mode : THUMB_PERMS_THUMB); | |
359 success = rename_file(tmp_path, tl->thumb_path); | |
360 } | |
361 | |
362 g_free(pathl); | |
363 | |
364 g_free(mark_mtime); | |
365 g_free(mark_app); | |
366 | |
367 g_free(tmp_path); | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
368 if (!success) |
9 | 369 { |
838 | 370 DEBUG_1("thumb save failed: %s", tl->fd->path); |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
371 DEBUG_1(" thumb: %s", tl->thumb_path); |
9 | 372 } |
373 | |
374 } | |
375 | |
376 g_object_unref(G_OBJECT(pixbuf)); | |
377 } | |
378 | |
876
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
379 static void thumb_loader_std_set_fallback(ThumbLoaderStd *tl) |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
380 { |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
381 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf); |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
382 tl->fd->thumb_pixbuf = pixbuf_fallback(tl->fd, tl->requested_width, tl->requested_height); |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
383 } |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
384 |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
385 static GdkPixbuf *thumb_loader_std_finish(ThumbLoaderStd *tl, GdkPixbuf *pixbuf, gint shrunk) |
9 | 386 { |
387 GdkPixbuf *pixbuf_thumb = NULL; | |
388 GdkPixbuf *result; | |
839 | 389 GdkPixbuf *rotated = NULL; |
9 | 390 gint sw, sh; |
391 | |
839 | 392 |
393 if (!tl->cache_hit && options->image.exif_rotate_enable) | |
394 { | |
395 if (!tl->fd->exif_orientation) | |
396 { | |
397 ExifData *exif = exif_read_fd(tl->fd); | |
398 gint orientation; | |
399 | |
400 if (exif && exif_get_integer(exif, "Exif.Image.Orientation", &orientation)) | |
401 tl->fd->exif_orientation = orientation; | |
402 else | |
842
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
403 tl->fd->exif_orientation = EXIF_ORIENTATION_TOP_LEFT; |
844 | 404 exif_free_fd(tl->fd, exif); |
839 | 405 } |
406 | |
842
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
407 if (tl->fd->exif_orientation != EXIF_ORIENTATION_TOP_LEFT) |
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
408 { |
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
409 rotated = pixbuf_apply_orientation(pixbuf, tl->fd->exif_orientation); |
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
410 pixbuf = rotated; |
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
411 } |
839 | 412 } |
413 | |
9 | 414 sw = gdk_pixbuf_get_width(pixbuf); |
415 sh = gdk_pixbuf_get_height(pixbuf); | |
416 | |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
417 if (tl->cache_enable) |
9 | 418 { |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
419 if (!tl->cache_hit) |
9 | 420 { |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
421 gint cache_w, cache_h; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
422 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
423 if (tl->requested_width > THUMB_SIZE_NORMAL || tl->requested_height > THUMB_SIZE_NORMAL) |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
424 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
425 cache_w = cache_h = THUMB_SIZE_LARGE; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
426 } |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
427 else |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
428 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
429 cache_w = cache_h = THUMB_SIZE_NORMAL; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
430 } |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
431 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
432 if (sw > cache_w || sh > cache_h || shrunk) |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
433 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
434 gint thumb_w, thumb_h; |
9 | 435 |
864 | 436 if (pixbuf_scale_aspect(cache_w, cache_h, sw, sh, |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
437 &thumb_w, &thumb_h)) |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
438 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
439 pixbuf_thumb = gdk_pixbuf_scale_simple(pixbuf, thumb_w, thumb_h, |
333 | 440 (GdkInterpType)options->thumbnails.quality); |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
441 } |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
442 else |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
443 { |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
444 pixbuf_thumb = pixbuf; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
445 g_object_ref(G_OBJECT(pixbuf_thumb)); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
446 } |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
447 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
448 thumb_loader_std_save(tl, pixbuf_thumb); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
449 } |
9 | 450 } |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
451 else if (tl->cache_hit && |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
452 tl->cache_local && !tl->thumb_path_local) |
9 | 453 { |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
454 /* A local cache save was requested, but a valid thumb is in $HOME, |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
455 * so specifically save as a local thumbnail. |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
456 */ |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
457 g_free(tl->thumb_path); |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
458 tl->thumb_path = NULL; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
459 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
460 tl->cache_hit = FALSE; |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
461 |
838 | 462 DEBUG_1("thumb copied: %s", tl->fd->path); |
40
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
463 |
dcc04a6a58bf
Sat Apr 16 12:29:42 2005 John Ellis <johne@verizon.net>
gqview
parents:
14
diff
changeset
|
464 thumb_loader_std_save(tl, pixbuf); |
9 | 465 } |
466 } | |
467 | |
468 if (sw <= tl->requested_width && sh <= tl->requested_height) | |
469 { | |
470 result = pixbuf; | |
471 g_object_ref(result); | |
472 } | |
473 else | |
474 { | |
475 gint thumb_w, thumb_h; | |
476 | |
477 if (pixbuf_thumb) | |
478 { | |
479 pixbuf = pixbuf_thumb; | |
480 sw = gdk_pixbuf_get_width(pixbuf); | |
481 sh = gdk_pixbuf_get_height(pixbuf); | |
482 } | |
483 | |
864 | 484 if (pixbuf_scale_aspect(tl->requested_width, tl->requested_height, sw, sh, |
9 | 485 &thumb_w, &thumb_h)) |
486 { | |
487 result = gdk_pixbuf_scale_simple(pixbuf, thumb_w, thumb_h, | |
333 | 488 (GdkInterpType)options->thumbnails.quality); |
9 | 489 } |
490 else | |
491 { | |
492 result = pixbuf; | |
493 g_object_ref(result); | |
494 } | |
495 } | |
496 | |
497 if (pixbuf_thumb) g_object_unref(pixbuf_thumb); | |
839 | 498 if (rotated) g_object_unref(rotated); |
9 | 499 |
500 return result; | |
501 } | |
502 | |
503 static gint thumb_loader_std_next_source(ThumbLoaderStd *tl, gint remove_broken) | |
504 { | |
505 image_loader_free(tl->il); | |
506 tl->il = NULL; | |
507 | |
508 if (tl->thumb_path) | |
509 { | |
510 if (!tl->thumb_path_local && remove_broken) | |
511 { | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
512 DEBUG_1("thumb broken, unlinking: %s", tl->thumb_path); |
9 | 513 unlink_file(tl->thumb_path); |
514 } | |
515 | |
516 g_free(tl->thumb_path); | |
517 tl->thumb_path = NULL; | |
518 | |
519 if (!tl->thumb_path_local) | |
520 { | |
521 tl->thumb_path = thumb_loader_std_cache_path(tl, TRUE, NULL, FALSE); | |
522 if (isfile(tl->thumb_path) && thumb_loader_std_setup(tl, tl->thumb_path)) | |
523 { | |
524 tl->thumb_path_local = TRUE; | |
525 return TRUE; | |
526 } | |
527 | |
528 g_free(tl->thumb_path); | |
529 tl->thumb_path = NULL; | |
530 } | |
531 | |
838 | 532 if (thumb_loader_std_setup(tl, tl->fd->path)) return TRUE; |
9 | 533 } |
534 | |
535 thumb_loader_std_save(tl, NULL); | |
536 return FALSE; | |
537 } | |
538 | |
539 static void thumb_loader_std_done_cb(ImageLoader *il, gpointer data) | |
540 { | |
541 ThumbLoaderStd *tl = data; | |
542 GdkPixbuf *pixbuf; | |
543 | |
881
10d0bf784323
Prevent segfault in certain conditions when displaying debug message.
zas_
parents:
876
diff
changeset
|
544 DEBUG_1("thumb image done: %s", tl->fd ? tl->fd->path : "???"); |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
545 DEBUG_1(" from: %s", tl->il->path); |
9 | 546 |
547 pixbuf = image_loader_get_pixbuf(tl->il); | |
548 if (!pixbuf) | |
549 { | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
550 DEBUG_1("...but no pixbuf"); |
9 | 551 thumb_loader_std_error_cb(il, data); |
552 return; | |
553 } | |
554 | |
555 if (tl->thumb_path && !thumb_loader_std_validate(tl, pixbuf)) | |
556 { | |
557 if (thumb_loader_std_next_source(tl, TRUE)) return; | |
558 | |
559 if (tl->func_error) tl->func_error(tl, tl->data); | |
560 return; | |
561 } | |
562 | |
563 tl->cache_hit = (tl->thumb_path != NULL); | |
564 | |
838 | 565 if (tl->fd) |
566 { | |
845 | 567 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf); |
568 tl->fd->thumb_pixbuf = thumb_loader_std_finish(tl, pixbuf, il->shrunk); | |
838 | 569 } |
9 | 570 |
571 if (tl->func_done) tl->func_done(tl, tl->data); | |
572 } | |
573 | |
574 static void thumb_loader_std_error_cb(ImageLoader *il, gpointer data) | |
575 { | |
576 ThumbLoaderStd *tl = data; | |
577 | |
578 /* if at least some of the image is available, go to done */ | |
579 if (image_loader_get_pixbuf(tl->il) != NULL) | |
580 { | |
581 thumb_loader_std_done_cb(il, data); | |
582 return; | |
583 } | |
495 | 584 |
838 | 585 DEBUG_1("thumb image error: %s", tl->fd->path); |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
586 DEBUG_1(" from: %s", tl->il->fd->path); |
9 | 587 |
588 if (thumb_loader_std_next_source(tl, TRUE)) return; | |
589 | |
876
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
590 thumb_loader_std_set_fallback(tl); |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
591 |
9 | 592 if (tl->func_error) tl->func_error(tl, tl->data); |
593 } | |
594 | |
595 static void thumb_loader_std_progress_cb(ImageLoader *il, gdouble percent, gpointer data) | |
596 { | |
597 ThumbLoaderStd *tl = data; | |
598 | |
599 tl->progress = (gdouble)percent; | |
600 | |
601 if (tl->func_progress) tl->func_progress(tl, tl->data); | |
602 } | |
603 | |
604 static gint thumb_loader_std_setup(ThumbLoaderStd *tl, const gchar *path) | |
605 { | |
138 | 606 tl->il = image_loader_new_from_path(path); |
9 | 607 |
333 | 608 if (options->thumbnails.fast) |
9 | 609 { |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
610 /* this will speed up jpegs by up to 3x in some cases */ |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
611 if (tl->requested_width <= THUMB_SIZE_NORMAL && |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
612 tl->requested_height <= THUMB_SIZE_NORMAL) |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
613 { |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
614 image_loader_set_requested_size(tl->il, THUMB_SIZE_NORMAL, THUMB_SIZE_NORMAL); |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
615 } |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
616 else |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
617 { |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
618 image_loader_set_requested_size(tl->il, THUMB_SIZE_LARGE, THUMB_SIZE_LARGE); |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
619 } |
9 | 620 } |
621 | |
622 image_loader_set_error_func(tl->il, thumb_loader_std_error_cb, tl); | |
623 if (tl->func_progress) | |
624 { | |
625 image_loader_set_percent_func(tl->il, thumb_loader_std_progress_cb, tl); | |
626 } | |
627 | |
628 if (image_loader_start(tl->il, thumb_loader_std_done_cb, tl)) | |
629 { | |
630 return TRUE; | |
631 } | |
632 | |
633 image_loader_free(tl->il); | |
634 tl->il = NULL; | |
635 return FALSE; | |
636 } | |
637 | |
638 /* | |
639 * Note: Currently local_cache only specifies where to save a _new_ thumb, if | |
640 * a valid existing thumb is found anywhere the local thumb will not be created. | |
641 */ | |
642 void thumb_loader_std_set_cache(ThumbLoaderStd *tl, gint enable_cache, gint local, gint retry_failed) | |
643 { | |
644 if (!tl) return; | |
645 | |
646 tl->cache_enable = enable_cache; | |
647 tl->cache_local = local; | |
648 tl->cache_retry = retry_failed; | |
649 } | |
650 | |
838 | 651 gint thumb_loader_std_start(ThumbLoaderStd *tl, FileData *fd) |
9 | 652 { |
653 static gchar *thumb_cache = NULL; | |
654 struct stat st; | |
655 | |
838 | 656 if (!tl || !fd) return FALSE; |
9 | 657 |
658 thumb_loader_std_reset(tl); | |
659 | |
838 | 660 if (!stat_utf8(fd->path, &st)) return FALSE; |
9 | 661 |
838 | 662 tl->fd = file_data_ref(fd); |
9 | 663 tl->source_mtime = st.st_mtime; |
664 tl->source_size = st.st_size; | |
665 tl->source_mode = st.st_mode; | |
666 | |
717 | 667 if (!thumb_cache) thumb_cache = g_build_filename(homedir(), THUMB_FOLDER_GLOBAL, NULL); |
838 | 668 if (strncmp(tl->fd->path, thumb_cache, strlen(thumb_cache)) != 0) |
9 | 669 { |
670 gchar *pathl; | |
671 | |
838 | 672 pathl = path_from_utf8(fd->path); |
9 | 673 tl->thumb_uri = g_filename_to_uri(pathl, NULL, NULL); |
674 tl->local_uri = filename_from_path(tl->thumb_uri); | |
675 g_free(pathl); | |
676 } | |
677 | |
678 if (tl->cache_enable) | |
679 { | |
680 gint found; | |
681 | |
682 tl->thumb_path = thumb_loader_std_cache_path(tl, FALSE, NULL, FALSE); | |
683 tl->thumb_path_local = FALSE; | |
684 | |
685 found = isfile(tl->thumb_path); | |
686 if (found && thumb_loader_std_setup(tl, tl->thumb_path)) return TRUE; | |
687 | |
876
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
688 if (thumb_loader_std_fail_check(tl) || |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
689 !thumb_loader_std_next_source(tl, found)) |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
690 { |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
691 thumb_loader_std_set_fallback(tl); |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
692 return FALSE; |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
693 } |
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
694 return TRUE; |
9 | 695 } |
696 | |
838 | 697 if (!thumb_loader_std_setup(tl, tl->fd->path)) |
9 | 698 { |
699 thumb_loader_std_save(tl, NULL); | |
876
2d8705f33da5
set fallback thumbnail pixbuf only if the loading really fails
nadvornik
parents:
864
diff
changeset
|
700 thumb_loader_std_set_fallback(tl); |
9 | 701 return FALSE; |
702 } | |
703 | |
704 return TRUE; | |
705 } | |
706 | |
707 void thumb_loader_std_free(ThumbLoaderStd *tl) | |
708 { | |
709 if (!tl) return; | |
710 | |
711 thumb_loader_std_reset(tl); | |
712 g_free(tl); | |
713 } | |
714 | |
864 | 715 GdkPixbuf *thumb_loader_std_get_pixbuf(ThumbLoaderStd *tl) |
9 | 716 { |
717 GdkPixbuf *pixbuf; | |
718 | |
845 | 719 if (tl && tl->fd && tl->fd->thumb_pixbuf) |
9 | 720 { |
845 | 721 pixbuf = tl->fd->thumb_pixbuf; |
9 | 722 g_object_ref(pixbuf); |
723 } | |
724 else | |
725 { | |
864 | 726 pixbuf = pixbuf_fallback(NULL, tl->requested_width, tl->requested_height); |
9 | 727 } |
728 | |
729 return pixbuf; | |
730 } | |
731 | |
732 | |
733 typedef struct _ThumbValidate ThumbValidate; | |
734 struct _ThumbValidate | |
735 { | |
736 ThumbLoaderStd *tl; | |
737 gchar *path; | |
738 gint days; | |
739 | |
740 void (*func_valid)(const gchar *path, gint valid, gpointer data); | |
741 gpointer data; | |
742 | |
743 gint idle_id; | |
744 }; | |
745 | |
746 static void thumb_loader_std_thumb_file_validate_free(ThumbValidate *tv) | |
747 { | |
748 thumb_loader_std_free(tv->tl); | |
749 g_free(tv->path); | |
750 g_free(tv); | |
751 } | |
752 | |
753 void thumb_loader_std_thumb_file_validate_cancel(ThumbLoaderStd *tl) | |
754 { | |
755 ThumbValidate *tv; | |
756 | |
757 if (!tl) return; | |
758 | |
759 tv = tl->data; | |
760 | |
761 if (tv->idle_id != -1) g_source_remove(tv->idle_id); | |
762 tv->idle_id = -1; | |
763 | |
764 thumb_loader_std_thumb_file_validate_free(tv); | |
765 } | |
766 | |
767 static void thumb_loader_std_thumb_file_validate_finish(ThumbValidate *tv, gint valid) | |
768 { | |
769 if (tv->func_valid) tv->func_valid(tv->path, valid, tv->data); | |
770 | |
771 thumb_loader_std_thumb_file_validate_free(tv); | |
772 } | |
773 | |
774 static void thumb_loader_std_thumb_file_validate_done_cb(ThumbLoaderStd *tl, gpointer data) | |
775 { | |
776 ThumbValidate *tv = data; | |
777 GdkPixbuf *pixbuf; | |
778 gint valid = FALSE; | |
779 | |
864 | 780 /* this function is called on success, so the pixbuf should not be a fallback*/ |
781 pixbuf = thumb_loader_std_get_pixbuf(tv->tl); | |
9 | 782 if (pixbuf) |
783 { | |
784 const gchar *uri; | |
785 const gchar *mtime_str; | |
786 | |
787 uri = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_URI); | |
788 mtime_str = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_MTIME); | |
789 if (uri && mtime_str) | |
790 { | |
791 if (strncmp(uri, "file:", strlen("file:")) == 0) | |
792 { | |
793 struct stat st; | |
794 gchar *target; | |
795 | |
796 target = g_filename_from_uri(uri, NULL, NULL); | |
797 if (stat(target, &st) == 0 && | |
798 st.st_mtime == strtol(mtime_str, NULL, 10)) | |
799 { | |
800 valid = TRUE; | |
801 } | |
802 g_free(target); | |
803 } | |
804 else | |
805 { | |
806 struct stat st; | |
807 | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
808 DEBUG_1("thumb uri foreign, doing day check: %s", uri); |
9 | 809 |
810 if (stat_utf8(tv->path, &st)) | |
811 { | |
812 time_t now; | |
813 | |
814 now = time(NULL); | |
815 if (st.st_atime >= now - (time_t)tv->days * 24 * 60 * 60) | |
816 { | |
817 valid = TRUE; | |
818 } | |
819 } | |
820 } | |
821 } | |
822 | |
823 g_object_unref(pixbuf); | |
824 } | |
825 | |
826 thumb_loader_std_thumb_file_validate_finish(tv, valid); | |
827 } | |
828 | |
829 static void thumb_loader_std_thumb_file_validate_error_cb(ThumbLoaderStd *tl, gpointer data) | |
830 { | |
831 ThumbValidate *tv = data; | |
832 | |
833 thumb_loader_std_thumb_file_validate_finish(tv, FALSE); | |
834 } | |
835 | |
836 static gint thumb_loader_std_thumb_file_validate_idle_cb(gpointer data) | |
837 { | |
838 ThumbValidate *tv = data; | |
839 | |
840 tv->idle_id = -1; | |
841 thumb_loader_std_thumb_file_validate_finish(tv, FALSE); | |
842 | |
843 return FALSE; | |
844 } | |
845 | |
846 ThumbLoaderStd *thumb_loader_std_thumb_file_validate(const gchar *thumb_path, gint allowed_days, | |
847 void (*func_valid)(const gchar *path, gint valid, gpointer data), | |
848 gpointer data) | |
849 { | |
850 ThumbValidate *tv; | |
851 | |
852 tv = g_new0(ThumbValidate, 1); | |
853 | |
854 tv->tl = thumb_loader_std_new(THUMB_SIZE_LARGE, THUMB_SIZE_LARGE); | |
855 thumb_loader_std_set_callbacks(tv->tl, | |
856 thumb_loader_std_thumb_file_validate_done_cb, | |
857 thumb_loader_std_thumb_file_validate_error_cb, | |
858 NULL, | |
859 tv); | |
860 thumb_loader_std_reset(tv->tl); | |
861 | |
862 tv->path = g_strdup(thumb_path); | |
863 tv->days = allowed_days; | |
864 tv->func_valid = func_valid; | |
865 tv->data = data; | |
866 | |
867 if (!thumb_loader_std_setup(tv->tl, thumb_path)) | |
868 { | |
869 tv->idle_id = g_idle_add(thumb_loader_std_thumb_file_validate_idle_cb, tv); | |
870 } | |
871 else | |
872 { | |
873 tv->idle_id = -1; | |
874 } | |
875 | |
876 return tv->tl; | |
877 } | |
878 | |
879 static void thumb_std_maint_remove_one(const gchar *source, const gchar *uri, gint local, | |
880 const gchar *subfolder) | |
881 { | |
882 gchar *thumb_path; | |
883 | |
884 thumb_path = thumb_std_cache_path(source, | |
885 (local) ? filename_from_path(uri) : uri, | |
886 local, subfolder); | |
887 if (isfile(thumb_path)) | |
888 { | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
889 DEBUG_1("thumb removing: %s", thumb_path); |
9 | 890 unlink_file(thumb_path); |
891 } | |
892 g_free(thumb_path); | |
893 } | |
894 | |
895 /* this also removes local thumbnails (the source is gone so it makes sense) */ | |
896 void thumb_std_maint_removed(const gchar *source) | |
897 { | |
898 gchar *uri; | |
899 gchar *sourcel; | |
900 | |
901 sourcel = path_from_utf8(source); | |
902 uri = g_filename_to_uri(sourcel, NULL, NULL); | |
903 g_free(sourcel); | |
904 | |
905 /* all this to remove a thumbnail? */ | |
906 | |
907 thumb_std_maint_remove_one(source, uri, FALSE, THUMB_FOLDER_NORMAL); | |
908 thumb_std_maint_remove_one(source, uri, FALSE, THUMB_FOLDER_LARGE); | |
909 thumb_std_maint_remove_one(source, uri, FALSE, THUMB_FOLDER_FAIL); | |
910 thumb_std_maint_remove_one(source, uri, TRUE, THUMB_FOLDER_NORMAL); | |
911 thumb_std_maint_remove_one(source, uri, TRUE, THUMB_FOLDER_LARGE); | |
912 | |
913 g_free(uri); | |
914 } | |
915 | |
916 typedef struct _TMaintMove TMaintMove; | |
917 struct _TMaintMove | |
918 { | |
919 gchar *source; | |
920 gchar *dest; | |
921 | |
922 ThumbLoaderStd *tl; | |
923 gchar *source_uri; | |
924 gchar *thumb_path; | |
925 | |
926 gint pass; | |
927 }; | |
928 | |
929 static GList *thumb_std_maint_move_list = NULL; | |
930 static GList *thumb_std_maint_move_tail = NULL; | |
931 | |
932 | |
933 static void thumb_std_maint_move_step(TMaintMove *tm); | |
934 static gint thumb_std_maint_move_idle(gpointer data); | |
935 | |
936 | |
937 static void thumb_std_maint_move_validate_cb(const gchar *path, gint valid, gpointer data) | |
938 { | |
939 TMaintMove *tm = data; | |
940 GdkPixbuf *pixbuf; | |
941 | |
864 | 942 /* this function is called on success, so the pixbuf should not be a fallback*/ |
943 pixbuf = thumb_loader_std_get_pixbuf(tm->tl); | |
9 | 944 if (pixbuf) |
945 { | |
946 const gchar *uri; | |
947 const gchar *mtime_str; | |
948 | |
949 uri = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_URI); | |
950 mtime_str = gdk_pixbuf_get_option(pixbuf, THUMB_MARKER_MTIME); | |
951 | |
952 if (uri && mtime_str && strcmp(uri, tm->source_uri) == 0) | |
953 { | |
954 gchar *pathl; | |
955 | |
956 /* The validation utility abuses ThumbLoader, and we | |
957 * abuse the utility just to load the thumbnail, | |
958 * but the loader needs to look sane for the save to complete. | |
959 */ | |
960 | |
961 tm->tl->cache_enable = TRUE; | |
962 tm->tl->cache_hit = FALSE; | |
963 tm->tl->cache_local = FALSE; | |
964 | |
838 | 965 file_data_unref(tm->tl->fd); |
966 tm->tl->fd = file_data_new_simple(tm->dest); | |
9 | 967 tm->tl->source_mtime = strtol(mtime_str, NULL, 10); |
968 | |
838 | 969 pathl = path_from_utf8(tm->tl->fd->path); |
9 | 970 g_free(tm->tl->thumb_uri); |
971 tm->tl->thumb_uri = g_filename_to_uri(pathl, NULL, NULL); | |
972 tm->tl->local_uri = filename_from_path(tm->tl->thumb_uri); | |
973 g_free(pathl); | |
974 | |
975 g_free(tm->tl->thumb_path); | |
976 tm->tl->thumb_path = NULL; | |
977 tm->tl->thumb_path_local = FALSE; | |
978 | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
979 DEBUG_1("thumb move attempting save:"); |
9 | 980 |
981 thumb_loader_std_save(tm->tl, pixbuf); | |
982 } | |
983 | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
984 DEBUG_1("thumb move unlink: %s", tm->thumb_path); |
9 | 985 unlink_file(tm->thumb_path); |
864 | 986 g_object_unref(pixbuf); |
9 | 987 } |
988 | |
989 thumb_std_maint_move_step(tm); | |
990 } | |
991 | |
992 static void thumb_std_maint_move_step(TMaintMove *tm) | |
993 { | |
994 const gchar *folder; | |
995 | |
996 tm->pass++; | |
997 if (tm->pass > 2) | |
998 { | |
999 g_free(tm->source); | |
1000 g_free(tm->dest); | |
1001 g_free(tm->source_uri); | |
1002 g_free(tm->thumb_path); | |
1003 g_free(tm); | |
1004 | |
1005 if (thumb_std_maint_move_list) | |
1006 { | |
1007 g_idle_add_full(G_PRIORITY_LOW, thumb_std_maint_move_idle, NULL, NULL); | |
1008 } | |
1009 | |
1010 return; | |
1011 } | |
1012 | |
1013 folder = (tm->pass == 1) ? THUMB_FOLDER_NORMAL : THUMB_FOLDER_LARGE; | |
442 | 1014 |
9 | 1015 g_free(tm->thumb_path); |
1016 tm->thumb_path = thumb_std_cache_path(tm->source, tm->source_uri, FALSE, folder); | |
1017 tm->tl = thumb_loader_std_thumb_file_validate(tm->thumb_path, 0, | |
1018 thumb_std_maint_move_validate_cb, tm); | |
1019 } | |
1020 | |
1021 static gint thumb_std_maint_move_idle(gpointer data) | |
1022 { | |
1023 TMaintMove *tm; | |
1024 gchar *pathl; | |
1025 | |
1026 if (!thumb_std_maint_move_list) return FALSE; | |
1027 | |
1028 tm = thumb_std_maint_move_list->data; | |
1029 | |
1030 thumb_std_maint_move_list = g_list_remove(thumb_std_maint_move_list, tm); | |
1031 if (!thumb_std_maint_move_list) thumb_std_maint_move_tail = NULL; | |
1032 | |
1033 pathl = path_from_utf8(tm->source); | |
1034 tm->source_uri = g_filename_to_uri(pathl, NULL, NULL); | |
1035 g_free(pathl); | |
1036 | |
1037 tm->pass = 0; | |
1038 | |
1039 thumb_std_maint_move_step(tm); | |
1040 | |
1041 return FALSE; | |
1042 } | |
1043 | |
1044 /* This will schedule a move of the thumbnail for source image to dest when idle. | |
1045 * We do this so that file renaming or moving speed is not sacrificed by | |
1046 * moving the thumbnails at the same time because: | |
1047 * | |
1048 * This cache design requires the tedious task of loading the png thumbnails and saving them. | |
1049 * | |
1050 * The thumbnails are processed when the app is idle. If the app | |
1051 * exits early well too bad - they can simply be regenerated from scratch. | |
1052 * | |
1053 * This does not manage local thumbnails (fixme ?) | |
1054 */ | |
1055 void thumb_std_maint_moved(const gchar *source, const gchar *dest) | |
1056 { | |
1057 TMaintMove *tm; | |
1058 | |
1059 tm = g_new0(TMaintMove, 1); | |
1060 tm->source = g_strdup(source); | |
1061 tm->dest = g_strdup(dest); | |
1062 | |
1063 if (!thumb_std_maint_move_list) | |
1064 { | |
1065 g_idle_add_full(G_PRIORITY_LOW, thumb_std_maint_move_idle, NULL, NULL); | |
1066 } | |
1067 | |
827 | 1068 if (thumb_std_maint_move_tail) |
1069 { | |
1070 thumb_std_maint_move_tail = g_list_append(thumb_std_maint_move_tail, tm); | |
1071 thumb_std_maint_move_tail = thumb_std_maint_move_tail->next; | |
1072 } | |
1073 else | |
1074 { | |
1075 thumb_std_maint_move_list = g_list_append(thumb_std_maint_move_list, tm); | |
1076 thumb_std_maint_move_tail = thumb_std_maint_move_list; | |
1077 } | |
9 | 1078 } |