src/thumb.cc

   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) */
  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
 115 static void thumb_loader_percent_cb(ImageLoader *UNUSED(il), gdouble percent, gpointer data)
 116 {
 117         ThumbLoader *tl = static_cast<ThumbLoader *>(data);
 118
 119         tl->percent_done = percent;
 120
 121         if (tl->func_progress) tl->func_progress(tl, tl->data);
 122 }
 123
 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
 130 static void thumb_loader_done_cb(ImageLoader *il, gpointer data)
 131 {
 132         ThumbLoader *tl = static_cast<ThumbLoader *>(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         if(!tl->cache_hit)
 149                 {
 150                         // apply color correction, if required
 151                         thumb_loader_std_calibrate_pixbuf(tl->fd, pixbuf);
 152                 }
 153
 154         if (!tl->cache_hit && options->image.exif_rotate_enable)
 155                 {
 156                 if (!tl->fd->exif_orientation)
 157                         {
 158                         if (g_strcmp0(il->fd->format_name, "heif") != 0)
 159                                 {
 160                                 tl->fd->exif_orientation = metadata_read_int(tl->fd, ORIENTATION_KEY, EXIF_ORIENTATION_TOP_LEFT);
 161                                 }
 162                         else
 163                                 {
 164                                 tl->fd->exif_orientation = EXIF_ORIENTATION_TOP_LEFT;
 165                                 }
 166                         }
 167
 168                 if (tl->fd->exif_orientation != EXIF_ORIENTATION_TOP_LEFT)
 169                         {
 170                         rotated = pixbuf_apply_orientation(pixbuf, tl->fd->exif_orientation);
 171                         pixbuf = rotated;
 172                         }
 173                 }
 174
 175         pw = gdk_pixbuf_get_width(pixbuf);
 176         ph = gdk_pixbuf_get_height(pixbuf);
 177
 178         if (tl->cache_hit && pw != tl->max_w && ph != tl->max_h)
 179                 {
 180                 /* requested thumbnail size may have changed, load original */
 181                 DEBUG_1("thumbnail size mismatch, regenerating: %s", tl->fd->path);
 182                 tl->cache_hit = FALSE;
 183
 184                 thumb_loader_setup(tl, tl->fd);
 185
 186                 g_signal_connect(G_OBJECT(tl->il), "done", (GCallback)thumb_loader_done_cb, tl);
 187
 188                 if (!image_loader_start(tl->il))
 189                         {
 190                         image_loader_free(tl->il);
 191                         tl->il = NULL;
 192
 193                         DEBUG_1("regeneration failure: %s", tl->fd->path);
 194                         thumb_loader_error_cb(tl->il, tl);
 195                         }
 196                 return;
 197                 }
 198
 199         /* scale ?? */
 200
 201         if (pw > tl->max_w || ph > tl->max_h)
 202                 {
 203                 gint w, h;
 204
 205                 if (((gdouble)tl->max_w / pw) < ((gdouble)tl->max_h / ph))
 206                         {
 207                         w = tl->max_w;
 208                         h = (gdouble)w / pw * ph;
 209                         if (h < 1) h = 1;
 210                         }
 211                 else
 212                         {
 213                         h = tl->max_h;
 214                         w = (gdouble)h / ph * pw;
 215                         if (w < 1) w = 1;
 216                         }
 217
 218                 if (tl->fd)
 219                         {
 220                         if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
 221                         tl->fd->thumb_pixbuf = gdk_pixbuf_scale_simple(pixbuf, w, h, (GdkInterpType)options->thumbnails.quality);
 222                         }
 223                 save = TRUE;
 224                 }
 225         else
 226                 {
 227                 if (tl->fd)
 228                         {
 229                         if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
 230                         tl->fd->thumb_pixbuf = pixbuf;
 231
 232                         g_object_ref(tl->fd->thumb_pixbuf);
 233                         }
 234                 save = image_loader_get_shrunk(il);
 235                 }
 236
 237         if (rotated) g_object_unref(rotated);
 238
 239         /* save it ? */
 240         if (tl->cache_enable && save)
 241                 {
 242                 thumb_loader_save_thumbnail(tl, FALSE);
 243                 }
 244
 245         if (tl->func_done) tl->func_done(tl, tl->data);
 246 }
 247
 248 static void thumb_loader_error_cb(ImageLoader *il, gpointer data)
 249 {
 250         ThumbLoader *tl = static_cast<ThumbLoader *>(data);
 251
 252         /* if at least some of the image is available, go to done_cb */
 253         if (image_loader_get_pixbuf(tl->il) != NULL)
 254                 {
 255                 thumb_loader_done_cb(il, data);
 256                 return;
 257                 }
 258
 259         DEBUG_1("thumb error: %s", tl->fd->path);
 260
 261         image_loader_free(tl->il);
 262         tl->il = NULL;
 263
 264         thumb_loader_set_fallback(tl);
 265
 266         if (tl->func_error) tl->func_error(tl, tl->data);
 267 }
 268
 269 static gboolean thumb_loader_done_delay_cb(gpointer data)
 270 {
 271         ThumbLoader *tl = static_cast<ThumbLoader *>(data);
 272
 273         tl->idle_done_id = 0;
 274
 275         if (tl->func_done) tl->func_done(tl, tl->data);
 276
 277         return FALSE;
 278 }
 279
 280 static void thumb_loader_delay_done(ThumbLoader *tl)
 281 {
 282         if (!tl->idle_done_id) tl->idle_done_id = g_idle_add(thumb_loader_done_delay_cb, tl);
 283 }
 284
 285 static void thumb_loader_setup(ThumbLoader *tl, FileData *fd)
 286 {
 287         image_loader_free(tl->il);
 288         tl->il = image_loader_new(fd);
 289         image_loader_set_priority(tl->il, G_PRIORITY_LOW);
 290
 291         /* this will speed up jpegs by up to 3x in some cases */
 292         image_loader_set_requested_size(tl->il, tl->max_w, tl->max_h);
 293
 294         g_signal_connect(G_OBJECT(tl->il), "error", (GCallback)thumb_loader_error_cb, tl);
 295         if (tl->func_progress) g_signal_connect(G_OBJECT(tl->il), "percent", (GCallback)thumb_loader_percent_cb, tl);
 296 }
 297
 298 void thumb_loader_set_callbacks(ThumbLoader *tl,
 299                                 ThumbLoaderFunc func_done,
 300                                 ThumbLoaderFunc func_error,
 301                                 ThumbLoaderFunc func_progress,
 302                                 gpointer data)
 303 {
 304         if (!tl) return;
 305
 306         if (tl->standard_loader)
 307                 {
 308                 thumb_loader_std_set_callbacks((ThumbLoaderStd *)tl,
 309                                                (ThumbLoaderStdFunc) func_done,
 310                                                (ThumbLoaderStdFunc) func_error,
 311                                                (ThumbLoaderStdFunc) func_progress,
 312                                                data);
 313                 return;
 314                 }
 315
 316         tl->func_done = func_done;
 317         tl->func_error = func_error;
 318         tl->func_progress = func_progress;
 319
 320         tl->data = data;
 321 }
 322
 323 void thumb_loader_set_cache(ThumbLoader *tl, gboolean enable_cache, gboolean local, gboolean retry_failed)
 324 {
 325         if (!tl) return;
 326
 327         if (tl->standard_loader)
 328                 {
 329                 thumb_loader_std_set_cache((ThumbLoaderStd *)tl, enable_cache, local, retry_failed);
 330                 return;
 331                 }
 332
 333         tl->cache_enable = enable_cache;
 334 }
 335
 336
 337 gboolean thumb_loader_start(ThumbLoader *tl, FileData *fd)
 338 {
 339         gchar *cache_path = NULL;
 340
 341         if (!tl) return FALSE;
 342
 343         if (tl->standard_loader)
 344                 {
 345                 return thumb_loader_std_start((ThumbLoaderStd *)tl, fd);
 346                 }
 347
 348         if (!tl->fd && !fd) return FALSE;
 349
 350         if (!tl->fd) tl->fd = file_data_ref(fd);
 351
 352         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)
 353                 {
 354                 thumb_loader_set_fallback(tl);
 355                 return FALSE;
 356                 }
 357
 358         if (tl->cache_enable)
 359                 {
 360                 cache_path = cache_find_location(CACHE_TYPE_THUMB, tl->fd->path);
 361
 362                 if (cache_path)
 363                         {
 364                         if (cache_time_valid(cache_path, tl->fd->path))
 365                                 {
 366                                 DEBUG_1("Found in cache:%s", tl->fd->path);
 367
 368                                 if (filesize(cache_path) == 0)
 369                                         {
 370                                         DEBUG_1("Broken image mark found:%s", cache_path);
 371                                         g_free(cache_path);
 372                                         thumb_loader_set_fallback(tl);
 373                                         return FALSE;
 374                                         }
 375
 376                                 DEBUG_1("Cache location:%s", cache_path);
 377                                 }
 378                         else
 379                                 {
 380                                 g_free(cache_path);
 381                                 cache_path = NULL;
 382                                 }
 383                         }
 384                 }
 385
 386         if (!cache_path && options->thumbnails.use_xvpics)
 387                 {
 388                 if (tl->fd->thumb_pixbuf) g_object_unref(tl->fd->thumb_pixbuf);
 389                 tl->fd->thumb_pixbuf = get_xv_thumbnail(tl->fd->path, tl->max_w, tl->max_h);
 390                 if (tl->fd->thumb_pixbuf)
 391                         {
 392                         thumb_loader_delay_done(tl);
 393                         return TRUE;
 394                         }
 395                 }
 396
 397         if (cache_path)
 398                 {
 399                 FileData *fd = file_data_new_no_grouping(cache_path);
 400                 thumb_loader_setup(tl, fd);
 401                 file_data_unref(fd);
 402                 g_free(cache_path);
 403                 tl->cache_hit = TRUE;
 404                 }
 405         else
 406                 {
 407                 thumb_loader_setup(tl, tl->fd);
 408                 }
 409
 410         g_signal_connect(G_OBJECT(tl->il), "done", (GCallback)thumb_loader_done_cb, tl);
 411         if (!image_loader_start(tl->il))
 412                 {
 413                 /* try from original if cache attempt */
 414                 if (tl->cache_hit)
 415                         {
 416                         tl->cache_hit = FALSE;
 417                         log_printf("%s", _("Thumbnail image in cache failed to load, trying to recreate.\n"));
 418
 419                         thumb_loader_setup(tl, tl->fd);
 420                         g_signal_connect(G_OBJECT(tl->il), "done", (GCallback)thumb_loader_done_cb, tl);
 421                         if (image_loader_start(tl->il)) return TRUE;
 422                         }
 423                 /* mark failed thumbnail in cache with 0 byte file */
 424                 if (tl->cache_enable)
 425                         {
 426                         thumb_loader_save_thumbnail(tl, TRUE);
 427                         }
 428
 429                 image_loader_free(tl->il);
 430                 tl->il = NULL;
 431                 thumb_loader_set_fallback(tl);
 432                 return FALSE;
 433                 }
 434
 435         return TRUE;
 436 }
 437
 438 GdkPixbuf *thumb_loader_get_pixbuf(ThumbLoader *tl)
 439 {
 440         GdkPixbuf *pixbuf;
 441
 442         if (tl && tl->standard_loader)
 443                 {
 444                 return thumb_loader_std_get_pixbuf((ThumbLoaderStd *)tl);
 445                 }
 446
 447         if (tl && tl->fd && tl->fd->thumb_pixbuf)
 448                 {
 449                 pixbuf = tl->fd->thumb_pixbuf;
 450                 g_object_ref(pixbuf);
 451                 }
 452         else
 453                 {
 454                 pixbuf = pixbuf_fallback(NULL, tl->max_w, tl->max_h);
 455                 }
 456
 457         return pixbuf;
 458 }
 459
 460 ThumbLoader *thumb_loader_new(gint width, gint height)
 461 {
 462         ThumbLoader *tl;
 463
 464         /* non-std thumb loader is more effective for configurations with disabled caching
 465            because it loads the thumbnails at the required size. loader_std loads
 466            the thumbnails at the sizes appropriate for standard cache (typically 256x256 pixels)
 467            and then performs one additional scaling */
 468         if (options->thumbnails.spec_standard && options->thumbnails.enable_caching)
 469                 {
 470                 return (ThumbLoader *)thumb_loader_std_new(width, height);
 471                 }
 472
 473         tl = g_new0(ThumbLoader, 1);
 474
 475         tl->cache_enable = options->thumbnails.enable_caching;
 476         tl->percent_done = 0.0;
 477         tl->max_w = width;
 478         tl->max_h = height;
 479
 480         return tl;
 481 }
 482
 483 void thumb_loader_free(ThumbLoader *tl)
 484 {
 485         if (!tl) return;
 486
 487         if (tl->standard_loader)
 488                 {
 489                 thumb_loader_std_free((ThumbLoaderStd *)tl);
 490                 return;
 491                 }
 492
 493         image_loader_free(tl->il);
 494         file_data_unref(tl->fd);
 495
 496         if (tl->idle_done_id) g_source_remove(tl->idle_done_id);
 497
 498         g_free(tl);
 499 }
 500
 501 /* release thumb_pixbuf on file change - this forces reload. */
 502 void thumb_notify_cb(FileData *fd, NotifyType type, gpointer UNUSED(data))
 503 {
 504         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE)) && fd->thumb_pixbuf)
 505                 {
 506                 DEBUG_1("Notify thumb: %s %04x", fd->path, type);
 507                 g_object_unref(fd->thumb_pixbuf);
 508                 fd->thumb_pixbuf = NULL;
 509                 }
 510 }
 511
 512
 513 /*
 514  *-----------------------------------------------------------------------------
 515  * xvpics thumbnail support, read-only (private)
 516  *-----------------------------------------------------------------------------
 517  */
 518
 519 /*
 520  * xvpics code originally supplied by:
 521  * "Diederen Damien" <D.Diederen@student.ulg.ac.be>
 522  *
 523  * Note: Code has been modified to fit the style of the other code, and to use
 524  *       a few more glib-isms.
 525  * 08-28-2000: Updated to return a gdk_pixbuf, Imlib is dying a death here.
 526  */
 527
 528 #define XV_BUFFER 2048
 529 static guchar *load_xv_thumbnail(gchar *filename, gint *widthp, gint *heightp)
 530 {
 531         FILE *file;
 532         gchar buffer[XV_BUFFER];
 533         guchar *data = NULL;
 534
 535         file = fopen(filename, "rt");
 536         if (!file) return NULL;
 537
 538         if (fgets(buffer, XV_BUFFER, file) != NULL
 539             && strncmp(buffer, "P7 332", 6) == 0)
 540                 {
 541                 gint width, height, depth;
 542
 543                 while (fgets(buffer, XV_BUFFER, file) && buffer[0] == '#') /* do_nothing() */;
 544
 545                 if (sscanf(buffer, "%d %d %d", &width, &height, &depth) == 3)
 546                         {
 547                         gsize size = width * height;
 548
 549                         data = g_new(guchar, size);
 550                         if (data && fread(data, 1, size, file) == size)
 551                                 {
 552                                 *widthp = width;
 553                                 *heightp = height;
 554                                 }
 555                         }
 556                 }
 557
 558         fclose(file);
 559         return data;
 560 }
 561 #undef XV_BUFFER
 562
 563 static void free_rgb_buffer(guchar *pixels, gpointer UNUSED(data))
 564 {
 565         g_free(pixels);
 566 }
 567
 568 static GdkPixbuf *get_xv_thumbnail(gchar *thumb_filename, gint max_w, gint max_h)
 569 {
 570         gint width, height;
 571         gchar *thumb_name;
 572         gchar *path;
 573         gchar *directory;
 574         gchar *name;
 575         guchar *packed_data;
 576
 577         path = path_from_utf8(thumb_filename);
 578         directory = g_path_get_dirname(path);
 579         name = g_path_get_basename(path);
 580
 581         thumb_name = g_build_filename(directory, ".xvpics", name, NULL);
 582
 583         g_free(name);
 584         g_free(directory);
 585         g_free(path);
 586
 587         packed_data = load_xv_thumbnail(thumb_name, &width, &height);
 588         g_free(thumb_name);
 589
 590         if (packed_data)
 591                 {
 592                 guchar *rgb_data;
 593                 GdkPixbuf *pixbuf;
 594                 gint i;
 595
 596                 rgb_data = g_new(guchar, width * height * 3);
 597                 for (i = 0; i < width * height; i++)
 598                         {
 599                         rgb_data[i * 3 + 0] = (packed_data[i] >> 5) * 36;
 600                         rgb_data[i * 3 + 1] = ((packed_data[i] & 28) >> 2) * 36;
 601                         rgb_data[i * 3 + 2] = (packed_data[i] & 3) * 85;
 602                         }
 603                 g_free(packed_data);
 604
 605                 pixbuf = gdk_pixbuf_new_from_data(rgb_data, GDK_COLORSPACE_RGB, FALSE, 8,
 606                                                   width, height, 3 * width, free_rgb_buffer, NULL);
 607
 608                 if (pixbuf_scale_aspect(width, height, max_w, max_h, &width, &height))
 609                         {
 610                         /* scale */
 611                         GdkPixbuf *tmp;
 612
 613                         tmp = pixbuf;
 614                         pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_NEAREST);
 615                         g_object_unref(tmp);
 616                         }
 617
 618                 return pixbuf;
 619                 }
 620
 621         return NULL;
 622 }
 623 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */