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