Mercurial > geeqie.yaz
annotate src/thumb.c @ 853:b54e3fc9cafb
optimized marks drawing
author | nadvornik |
---|---|
date | Sun, 22 Jun 2008 20:07:32 +0000 |
parents | 06929cbcd796 |
children | 0c3f6ef17d18 |
rev | line source |
---|---|
1 | 1 /* |
196 | 2 * Geeqie |
9 | 3 * (C) 2004 John Ellis |
475 | 4 * Copyright (C) 2008 The Geeqie Team |
1 | 5 * |
6 * Author: John Ellis | |
7 * | |
9 | 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! | |
1 | 11 */ |
12 | |
9 | 13 |
281 | 14 #include "main.h" |
9 | 15 #include "thumb.h" |
1 | 16 |
9 | 17 #include "cache.h" |
18 #include "image-load.h" | |
586 | 19 #include "filedata.h" |
9 | 20 #include "pixbuf_util.h" |
21 #include "thumb_standard.h" | |
22 #include "ui_fileops.h" | |
839 | 23 #include "exif.h" |
1 | 24 |
9 | 25 #include <utime.h> |
26 | |
27 | |
28 static void thumb_loader_error_cb(ImageLoader *il, gpointer data); | |
838 | 29 static void thumb_loader_setup(ThumbLoader *tl, const gchar *path); |
9 | 30 |
31 static gint normalize_thumb(gint *width, gint *height, gint max_w, gint max_h); | |
32 static GdkPixbuf *get_xv_thumbnail(gchar *thumb_filename, gint max_w, gint max_h); | |
33 | |
1 | 34 |
35 /* | |
36 *----------------------------------------------------------------------------- | |
37 * thumbnail routines: creation, caching, and maintenance (public) | |
38 *----------------------------------------------------------------------------- | |
39 */ | |
40 | |
9 | 41 static gint thumb_loader_save_to_cache(ThumbLoader *tl) |
1 | 42 { |
9 | 43 gchar *cache_dir; |
44 gint success = FALSE; | |
45 mode_t mode = 0755; | |
1 | 46 |
845 | 47 if (!tl || !tl->fd || !tl->fd->thumb_pixbuf) return FALSE; |
1 | 48 |
838 | 49 cache_dir = cache_get_location(CACHE_TYPE_THUMB, tl->fd->path, FALSE, &mode); |
1 | 50 |
9 | 51 if (cache_ensure_dir_exists(cache_dir, mode)) |
1 | 52 { |
53 gchar *cache_path; | |
9 | 54 gchar *pathl; |
838 | 55 gchar *name = g_strconcat(filename_from_path(tl->fd->path), GQ_CACHE_EXT_THUMB, NULL); |
9 | 56 |
715 | 57 cache_path = g_build_filename(cache_dir, name, NULL); |
58 g_free(name); | |
1 | 59 |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
60 DEBUG_1("Saving thumb: %s", cache_path); |
9 | 61 |
62 pathl = path_from_utf8(cache_path); | |
845 | 63 success = pixbuf_to_file_as_png(tl->fd->thumb_pixbuf, pathl); |
9 | 64 if (success) |
1 | 65 { |
9 | 66 struct utimbuf ut; |
67 /* set thumb time to that of source file */ | |
68 | |
838 | 69 ut.actime = ut.modtime = filetime(tl->fd->path); |
9 | 70 if (ut.modtime > 0) |
1 | 71 { |
9 | 72 utime(pathl, &ut); |
1 | 73 } |
74 } | |
75 else | |
76 { | |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
77 DEBUG_1("Saving failed: %s", pathl); |
1 | 78 } |
9 | 79 |
80 g_free(pathl); | |
81 g_free(cache_path); | |
82 } | |
83 | |
84 g_free(cache_dir); | |
85 | |
86 return success; | |
87 } | |
1 | 88 |
9 | 89 static gint thumb_loader_mark_failure(ThumbLoader *tl) |
90 { | |
91 gchar *cache_dir; | |
92 gint success = FALSE; | |
93 mode_t mode = 0755; | |
442 | 94 |
9 | 95 if (!tl) return FALSE; |
96 | |
838 | 97 cache_dir = cache_get_location(CACHE_TYPE_THUMB, tl->fd->path, FALSE, &mode); |
1 | 98 |
9 | 99 if (cache_ensure_dir_exists(cache_dir, mode)) |
100 { | |
101 gchar *cache_path; | |
102 gchar *pathl; | |
103 FILE *f; | |
838 | 104 gchar *name = g_strconcat(filename_from_path(tl->fd->path), GQ_CACHE_EXT_THUMB, NULL); |
9 | 105 |
715 | 106 cache_path = g_build_filename(cache_dir, name, NULL); |
107 g_free(name); | |
9 | 108 |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
109 DEBUG_1("marking thumb failure: %s", cache_path); |
9 | 110 |
111 pathl = path_from_utf8(cache_path); | |
112 f = fopen(pathl, "w"); | |
113 if (f) | |
1 | 114 { |
9 | 115 struct utimbuf ut; |
116 | |
512
f9bf33be53ff
Remove whitespace between function name and first parenthesis for the sake of consistency.
zas_
parents:
507
diff
changeset
|
117 fclose(f); |
1 | 118 |
838 | 119 ut.actime = ut.modtime = filetime(tl->fd->path); |
9 | 120 if (ut.modtime > 0) |
1 | 121 { |
9 | 122 utime(pathl, &ut); |
1 | 123 } |
124 | |
9 | 125 success = TRUE; |
126 } | |
127 | |
128 g_free(pathl); | |
129 g_free(cache_path); | |
130 } | |
131 | |
132 g_free(cache_dir); | |
133 return success; | |
134 } | |
135 | |
136 static void thumb_loader_percent_cb(ImageLoader *il, gdouble percent, gpointer data) | |
137 { | |
138 ThumbLoader *tl = data; | |
139 | |
140 tl->percent_done = percent; | |
141 | |
142 if (tl->func_progress) tl->func_progress(tl, tl->data); | |
143 } | |
144 | |
145 static void thumb_loader_done_cb(ImageLoader *il, gpointer data) | |
146 { | |
147 ThumbLoader *tl = data; | |
148 GdkPixbuf *pixbuf; | |
149 gint pw, ph; | |
150 gint save; | |
839 | 151 GdkPixbuf *rotated = NULL; |
9 | 152 |
838 | 153 DEBUG_1("thumb done: %s", tl->fd->path); |
1 | 154 |
9 | 155 pixbuf = image_loader_get_pixbuf(tl->il); |
156 if (!pixbuf) | |
157 { | |
838 | 158 DEBUG_1("...but no pixbuf: %s", tl->fd->path); |
9 | 159 thumb_loader_error_cb(tl->il, tl); |
160 return; | |
161 } | |
162 | |
839 | 163 |
164 if (!tl->cache_hit && options->image.exif_rotate_enable) | |
165 { | |
166 if (!tl->fd->exif_orientation) | |
167 { | |
168 ExifData *exif = exif_read_fd(tl->fd); | |
169 gint orientation; | |
170 | |
171 if (exif && exif_get_integer(exif, "Exif.Image.Orientation", &orientation)) | |
172 tl->fd->exif_orientation = orientation; | |
173 else | |
842
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
174 tl->fd->exif_orientation = EXIF_ORIENTATION_TOP_LEFT; |
844 | 175 exif_free_fd(tl->fd, exif); |
839 | 176 } |
177 | |
842
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
178 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
|
179 { |
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
180 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
|
181 pixbuf = rotated; |
94048d7843ba
do not allocate new buffer for thumbnails with correct orientation
nadvornik
parents:
841
diff
changeset
|
182 } |
839 | 183 } |
184 | |
9 | 185 pw = gdk_pixbuf_get_width(pixbuf); |
186 ph = gdk_pixbuf_get_height(pixbuf); | |
187 | |
188 if (tl->cache_hit && pw != tl->max_w && ph != tl->max_h) | |
189 { | |
190 /* requested thumbnail size may have changed, load original */ | |
838 | 191 DEBUG_1("thumbnail size mismatch, regenerating: %s", tl->fd->path); |
9 | 192 tl->cache_hit = FALSE; |
193 | |
838 | 194 thumb_loader_setup(tl, tl->fd->path); |
1 | 195 |
9 | 196 if (!image_loader_start(tl->il, thumb_loader_done_cb, tl)) |
197 { | |
198 image_loader_free(tl->il); | |
199 tl->il = NULL; | |
200 | |
838 | 201 DEBUG_1("regeneration failure: %s", tl->fd->path); |
9 | 202 thumb_loader_error_cb(tl->il, tl); |
203 } | |
204 return; | |
205 } | |
1 | 206 |
9 | 207 /* scale ?? */ |
208 | |
209 if (pw > tl->max_w || ph > tl->max_h) | |
210 { | |
211 gint w, h; | |
212 | |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
213 if (((double)tl->max_w / pw) < ((double)tl->max_h / ph)) |
9 | 214 { |
215 w = tl->max_w; | |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
216 h = (double)w / pw * ph; |
9 | 217 if (h < 1) h = 1; |
1 | 218 } |
219 else | |
220 { | |
9 | 221 h = tl->max_h; |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
222 w = (double)h / ph * pw; |
9 | 223 if (w < 1) w = 1; |
1 | 224 } |
838 | 225 |
226 if (tl->fd) | |
227 { | |
845 | 228 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf); |
229 tl->fd->thumb_pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, (GdkInterpType)options->thumbnails.quality); | |
838 | 230 } |
9 | 231 save = TRUE; |
1 | 232 } |
233 else | |
234 { | |
838 | 235 if (tl->fd) |
236 { | |
845 | 237 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf); |
238 tl->fd->thumb_pixbuf = pixbuf; | |
239 gdk_pixbuf_ref(tl->fd->thumb_pixbuf); | |
838 | 240 } |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
241 save = il->shrunk; |
9 | 242 } |
243 | |
839 | 244 if (rotated) gdk_pixbuf_unref(rotated); |
245 | |
9 | 246 /* save it ? */ |
247 if (tl->cache_enable && save) | |
248 { | |
249 thumb_loader_save_to_cache(tl); | |
250 } | |
251 | |
252 if (tl->func_done) tl->func_done(tl, tl->data); | |
253 } | |
254 | |
255 static void thumb_loader_error_cb(ImageLoader *il, gpointer data) | |
256 { | |
257 ThumbLoader *tl = data; | |
258 | |
259 /* if at least some of the image is available, go to done_cb */ | |
260 if (image_loader_get_pixbuf(tl->il) != NULL) | |
261 { | |
262 thumb_loader_done_cb(il, data); | |
263 return; | |
1 | 264 } |
9 | 265 |
838 | 266 DEBUG_1("thumb error: %s", tl->fd->path); |
9 | 267 |
268 image_loader_free(tl->il); | |
269 tl->il = NULL; | |
270 | |
271 if (tl->func_error) tl->func_error(tl, tl->data); | |
272 } | |
273 | |
274 static gint thumb_loader_done_delay_cb(gpointer data) | |
275 { | |
276 ThumbLoader *tl = data; | |
277 | |
278 tl->idle_done_id = -1; | |
279 | |
280 if (tl->func_done) tl->func_done(tl, tl->data); | |
281 | |
282 return FALSE; | |
283 } | |
284 | |
285 static void thumb_loader_delay_done(ThumbLoader *tl) | |
286 { | |
287 if (tl->idle_done_id == -1) tl->idle_done_id = g_idle_add(thumb_loader_done_delay_cb, tl); | |
288 } | |
289 | |
838 | 290 static void thumb_loader_setup(ThumbLoader *tl, const gchar *path) |
9 | 291 { |
838 | 292 FileData *fd = file_data_new_simple(path); |
9 | 293 image_loader_free(tl->il); |
838 | 294 tl->il = image_loader_new(fd); |
295 file_data_unref(fd); | |
9 | 296 |
333 | 297 if (options->thumbnails.fast) |
14
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
298 { |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
299 /* 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
|
300 image_loader_set_requested_size(tl->il, tl->max_w, tl->max_h); |
25335c62cd9b
##### Note: GQview CVS on sourceforge is not always up to date, please use #####
gqview
parents:
9
diff
changeset
|
301 } |
9 | 302 |
303 image_loader_set_error_func(tl->il, thumb_loader_error_cb, tl); | |
304 if (tl->func_progress) image_loader_set_percent_func(tl->il, thumb_loader_percent_cb, tl); | |
305 } | |
306 | |
307 void thumb_loader_set_callbacks(ThumbLoader *tl, | |
308 ThumbLoaderFunc func_done, | |
309 ThumbLoaderFunc func_error, | |
310 ThumbLoaderFunc func_progress, | |
311 gpointer data) | |
312 { | |
313 if (!tl) return; | |
314 | |
315 if (tl->standard_loader) | |
316 { | |
317 thumb_loader_std_set_callbacks((ThumbLoaderStd *)tl, | |
318 (ThumbLoaderStdFunc) func_done, | |
319 (ThumbLoaderStdFunc) func_error, | |
320 (ThumbLoaderStdFunc) func_progress, | |
321 data); | |
322 return; | |
323 } | |
324 | |
325 tl->func_done = func_done; | |
326 tl->func_error = func_error; | |
327 tl->func_progress = func_progress; | |
328 | |
329 tl->data = data; | |
330 } | |
331 | |
332 void thumb_loader_set_cache(ThumbLoader *tl, gint enable_cache, gint local, gint retry_failed) | |
333 { | |
442 | 334 if (!tl) return; |
9 | 335 |
336 if (tl->standard_loader) | |
337 { | |
338 thumb_loader_std_set_cache((ThumbLoaderStd *)tl, enable_cache, local, retry_failed); | |
339 return; | |
340 } | |
341 | |
342 tl->cache_enable = enable_cache; | |
343 #if 0 | |
344 tl->cache_local = local; | |
345 tl->cache_retry = retry_failed; | |
346 #endif | |
1 | 347 } |
348 | |
349 | |
838 | 350 gint thumb_loader_start(ThumbLoader *tl, FileData *fd) |
9 | 351 { |
352 gchar *cache_path = NULL; | |
1 | 353 |
9 | 354 if (!tl) return FALSE; |
1 | 355 |
9 | 356 if (tl->standard_loader) |
1 | 357 { |
838 | 358 return thumb_loader_std_start((ThumbLoaderStd *)tl, fd); |
9 | 359 } |
360 | |
838 | 361 if (!tl->fd && !fd) return FALSE; |
1 | 362 |
838 | 363 if (!tl->fd) tl->fd = file_data_ref(fd); |
1 | 364 |
9 | 365 if (tl->cache_enable) |
366 { | |
838 | 367 cache_path = cache_find_location(CACHE_TYPE_THUMB, tl->fd->path); |
9 | 368 |
369 if (cache_path) | |
1 | 370 { |
838 | 371 if (cache_time_valid(cache_path, tl->fd->path)) |
9 | 372 { |
838 | 373 DEBUG_1("Found in cache:%s", tl->fd->path); |
1 | 374 |
9 | 375 if (filesize(cache_path) == 0) |
1 | 376 { |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
377 DEBUG_1("Broken image mark found:%s", cache_path); |
9 | 378 g_free(cache_path); |
379 return FALSE; | |
1 | 380 } |
9 | 381 |
506
fc9c8a3e1a8b
Handle the newline in DEBUG_N() macro instead of adding one
zas_
parents:
495
diff
changeset
|
382 DEBUG_1("Cache location:%s", cache_path); |
9 | 383 } |
384 else | |
385 { | |
386 g_free(cache_path); | |
387 cache_path = NULL; | |
1 | 388 } |
389 } | |
9 | 390 } |
391 | |
333 | 392 if (!cache_path && options->thumbnails.use_xvpics) |
9 | 393 { |
845 | 394 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf); |
395 tl->fd->thumb_pixbuf = get_xv_thumbnail(tl->fd->path, tl->max_w, tl->max_h); | |
396 if (tl->fd->thumb_pixbuf) | |
9 | 397 { |
398 thumb_loader_delay_done(tl); | |
399 return TRUE; | |
400 } | |
401 } | |
402 | |
403 if (cache_path) | |
404 { | |
405 thumb_loader_setup(tl, cache_path); | |
406 g_free(cache_path); | |
407 tl->cache_hit = TRUE; | |
408 } | |
409 else | |
410 { | |
838 | 411 thumb_loader_setup(tl, tl->fd->path); |
9 | 412 } |
413 | |
414 if (!image_loader_start(tl->il, thumb_loader_done_cb, tl)) | |
415 { | |
416 /* try from original if cache attempt */ | |
417 if (tl->cache_hit) | |
418 { | |
419 tl->cache_hit = FALSE; | |
694 | 420 log_printf("%s", _("Thumbnail image in cache failed to load, trying to recreate.\n")); |
9 | 421 |
838 | 422 thumb_loader_setup(tl, tl->fd->path); |
9 | 423 if (image_loader_start(tl->il, thumb_loader_done_cb, tl)) return TRUE; |
424 } | |
425 /* mark failed thumbnail in cache with 0 byte file */ | |
426 if (tl->cache_enable) | |
427 { | |
428 thumb_loader_mark_failure(tl); | |
429 } | |
442 | 430 |
9 | 431 image_loader_free(tl->il); |
432 tl->il = NULL; | |
433 return FALSE; | |
434 } | |
435 | |
436 return TRUE; | |
437 } | |
438 | |
439 #if 0 | |
440 gint thumb_loader_to_pixmap(ThumbLoader *tl, GdkPixmap **pixmap, GdkBitmap **mask) | |
441 { | |
442 if (!tl || !tl->pixbuf) return -1; | |
443 | |
444 gdk_pixbuf_render_pixmap_and_mask(tl->pixbuf, pixmap, mask, 128); | |
445 | |
446 return thumb_loader_get_space(tl); | |
447 } | |
448 #endif | |
449 | |
450 GdkPixbuf *thumb_loader_get_pixbuf(ThumbLoader *tl, gint with_fallback) | |
451 { | |
452 GdkPixbuf *pixbuf; | |
453 | |
454 if (tl && tl->standard_loader) | |
455 { | |
456 return thumb_loader_std_get_pixbuf((ThumbLoaderStd *)tl, with_fallback); | |
457 } | |
458 | |
845 | 459 if (tl && tl->fd && tl->fd->thumb_pixbuf) |
9 | 460 { |
845 | 461 pixbuf = tl->fd->thumb_pixbuf; |
9 | 462 g_object_ref(pixbuf); |
463 } | |
464 else if (with_fallback) | |
465 { | |
466 gint w, h; | |
467 | |
468 pixbuf = pixbuf_inline(PIXBUF_INLINE_BROKEN); | |
469 w = gdk_pixbuf_get_width(pixbuf); | |
470 h = gdk_pixbuf_get_height(pixbuf); | |
471 if ((w > tl->max_w || h > tl->max_h) && | |
472 normalize_thumb(&w, &h, tl->max_w, tl->max_h)) | |
473 { | |
474 GdkPixbuf *tmp; | |
475 | |
476 tmp = pixbuf; | |
477 pixbuf = gdk_pixbuf_scale_simple(tmp, w, h, GDK_INTERP_NEAREST); | |
478 gdk_pixbuf_unref(tmp); | |
479 } | |
1 | 480 } |
9 | 481 else |
482 { | |
483 pixbuf = NULL; | |
484 } | |
485 | |
486 return pixbuf; | |
487 } | |
488 | |
489 #if 0 | |
490 gint thumb_loader_get_space(ThumbLoader *tl) | |
491 { | |
492 if (!tl) return 0; | |
493 | |
494 if (tl->pixbuf) return (tl->max_w - gdk_pixbuf_get_width(tl->pixbuf)); | |
495 | |
496 return tl->max_w; | |
497 } | |
498 #endif | |
499 | |
500 ThumbLoader *thumb_loader_new(gint width, gint height) | |
501 { | |
502 ThumbLoader *tl; | |
503 | |
333 | 504 if (options->thumbnails.spec_standard) |
9 | 505 { |
506 return (ThumbLoader *)thumb_loader_std_new(width, height); | |
507 } | |
508 | |
509 tl = g_new0(ThumbLoader, 1); | |
510 tl->standard_loader = FALSE; | |
838 | 511 tl->fd = NULL; |
333 | 512 tl->cache_enable = options->thumbnails.enable_caching; |
9 | 513 tl->cache_hit = FALSE; |
514 tl->percent_done = 0.0; | |
515 tl->max_w = width; | |
516 tl->max_h = height; | |
517 | |
518 tl->il = NULL; | |
519 | |
520 tl->idle_done_id = -1; | |
521 | |
522 return tl; | |
1 | 523 } |
524 | |
9 | 525 void thumb_loader_free(ThumbLoader *tl) |
526 { | |
527 if (!tl) return; | |
528 | |
529 if (tl->standard_loader) | |
530 { | |
531 thumb_loader_std_free((ThumbLoaderStd *)tl); | |
532 return; | |
533 } | |
534 | |
535 image_loader_free(tl->il); | |
838 | 536 file_data_unref(tl->fd); |
9 | 537 |
538 if (tl->idle_done_id != -1) g_source_remove(tl->idle_done_id); | |
539 | |
540 g_free(tl); | |
541 } | |
542 | |
543 #if 0 | |
544 gint thumb_from_xpm_d(const char **data, gint max_w, gint max_h, GdkPixmap **pixmap, GdkBitmap **mask) | |
545 { | |
546 GdkPixbuf *pixbuf; | |
547 gint w, h; | |
548 | |
549 pixbuf = gdk_pixbuf_new_from_xpm_data(data); | |
550 w = gdk_pixbuf_get_width(pixbuf); | |
551 h = gdk_pixbuf_get_height(pixbuf); | |
552 | |
553 if ((w > max_w || h > max_h) && | |
554 normalize_thumb(&w, &h, max_w, max_h)) | |
555 { | |
556 /* scale */ | |
557 GdkPixbuf *tmp; | |
558 | |
559 tmp = pixbuf; | |
560 pixbuf = gdk_pixbuf_scale_simple(tmp, w, h, GDK_INTERP_NEAREST); | |
561 gdk_pixbuf_unref(tmp); | |
562 } | |
563 | |
564 gdk_pixbuf_render_pixmap_and_mask(pixbuf, pixmap, mask, 128); | |
565 gdk_pixbuf_unref(pixbuf); | |
566 | |
567 return w; | |
568 } | |
569 #endif | |
570 | |
1 | 571 /* |
572 *----------------------------------------------------------------------------- | |
573 * xvpics thumbnail support, read-only (private) | |
574 *----------------------------------------------------------------------------- | |
575 */ | |
576 | |
577 /* | |
578 * xvpics code originally supplied by: | |
579 * "Diederen Damien" <D.Diederen@student.ulg.ac.be> | |
580 * | |
581 * Note: Code has been modified to fit the style of the other code, and to use | |
582 * a few more glib-isms. | |
9 | 583 * 08-28-2000: Updated to return a gdk_pixbuf, Imlib is dieing a death here. |
1 | 584 */ |
585 | |
586 #define XV_BUFFER 2048 | |
587 static guchar *load_xv_thumbnail(gchar *filename, gint *widthp, gint *heightp) | |
588 { | |
589 FILE *file; | |
590 gchar buffer[XV_BUFFER]; | |
591 guchar *data; | |
592 gint width, height, depth; | |
593 | |
594 file = fopen(filename, "rt"); | |
595 if(!file) return NULL; | |
596 | |
597 fgets(buffer, XV_BUFFER, file); | |
598 if(strncmp(buffer, "P7 332", 6) != 0) | |
599 { | |
600 fclose(file); | |
601 return NULL; | |
602 } | |
603 | |
516 | 604 while (fgets(buffer, XV_BUFFER, file) && buffer[0] == '#') /* do_nothing() */; |
1 | 605 |
606 if(sscanf(buffer, "%d %d %d", &width, &height, &depth) != 3) | |
607 { | |
608 fclose(file); | |
609 return NULL; | |
610 } | |
611 | |
612 data = g_new(guchar, width * height); | |
613 fread(data, 1, width * height, file); | |
614 | |
615 fclose(file); | |
616 *widthp = width; | |
617 *heightp = height; | |
618 return data; | |
619 } | |
620 #undef XV_BUFFER | |
621 | |
9 | 622 static gint normalize_thumb(gint *width, gint *height, gint max_w, gint max_h) |
1 | 623 { |
9 | 624 gdouble scale; |
625 gint new_w, new_h; | |
626 | |
627 scale = MIN((gdouble) max_w / *width, (gdouble) max_h / *height); | |
628 new_w = *width * scale; | |
629 new_h = *height * scale; | |
630 | |
631 if (new_w != *width || new_h != *height) | |
1 | 632 { |
9 | 633 *width = new_w; |
634 *height = new_h; | |
635 return TRUE; | |
1 | 636 } |
9 | 637 |
638 return FALSE; | |
1 | 639 } |
640 | |
9 | 641 static void free_rgb_buffer(guchar *pixels, gpointer data) |
642 { | |
643 g_free(pixels); | |
644 } | |
645 | |
646 static GdkPixbuf *get_xv_thumbnail(gchar *thumb_filename, gint max_w, gint max_h) | |
1 | 647 { |
648 gint width, height; | |
649 gchar *thumb_name; | |
715 | 650 gchar *path; |
651 gchar *directory; | |
652 gchar *name; | |
1 | 653 guchar *packed_data; |
654 | |
715 | 655 path = path_from_utf8(thumb_filename); |
656 directory = g_path_get_dirname(path); | |
657 name = g_path_get_basename(path); | |
658 | |
659 thumb_name = g_build_filename(directory, ".xvpics", name, NULL); | |
660 | |
661 g_free(name); | |
662 g_free(directory); | |
663 g_free(path); | |
1 | 664 |
665 packed_data = load_xv_thumbnail(thumb_name, &width, &height); | |
666 g_free(thumb_name); | |
667 | |
668 if(packed_data) | |
669 { | |
670 guchar *rgb_data; | |
9 | 671 GdkPixbuf *pixbuf; |
1 | 672 gint i; |
673 | |
674 rgb_data = g_new(guchar, width * height * 3); | |
517 | 675 for (i = 0; i < width * height; i++) |
1 | 676 { |
677 rgb_data[i * 3 + 0] = (packed_data[i] >> 5) * 36; | |
678 rgb_data[i * 3 + 1] = ((packed_data[i] & 28) >> 2) * 36; | |
679 rgb_data[i * 3 + 2] = (packed_data[i] & 3) * 85; | |
680 } | |
9 | 681 g_free(packed_data); |
1 | 682 |
9 | 683 pixbuf = gdk_pixbuf_new_from_data(rgb_data, GDK_COLORSPACE_RGB, FALSE, 8, |
684 width, height, 3 * width, free_rgb_buffer, NULL); | |
685 | |
686 if (normalize_thumb(&width, &height, max_w, max_h)) | |
687 { | |
688 /* scale */ | |
689 GdkPixbuf *tmp; | |
690 | |
691 tmp = pixbuf; | |
692 pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_NEAREST); | |
693 gdk_pixbuf_unref(tmp); | |
694 } | |
442 | 695 |
9 | 696 return pixbuf; |
1 | 697 } |
698 | |
9 | 699 return NULL; |
1 | 700 } |