src/image-load.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   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
  14 #include "main.h"
  15 #include "image-load.h"
  16
  17 #include "exif.h"
  18 #include "filedata.h"
  19 #include "ui_fileops.h"
  20
  21 #include <fcntl.h>
  22 #include <sys/mman.h>
  23
  24
  25 static const gchar *image_loader_path(ImageLoader *il)
  26 {
  27         if (il->fd)
  28                 return il->fd->path;
  29         return il->path;
  30 }
  31
  32 static void image_loader_sync_pixbuf(ImageLoader *il)
  33 {
  34         GdkPixbuf *pb;
  35
  36         if (!il->loader) return;
  37
  38         pb = gdk_pixbuf_loader_get_pixbuf(il->loader);
  39
  40         if (pb == il->pixbuf) return;
  41
  42         if (il->pixbuf) gdk_pixbuf_unref(il->pixbuf);
  43         il->pixbuf = pb;
  44         if (il->pixbuf) gdk_pixbuf_ref(il->pixbuf);
  45 }
  46
  47 static void image_loader_area_updated_cb(GdkPixbufLoader *loader,
  48                                  guint x, guint y, guint w, guint h,
  49                                  gpointer data)
  50 {
  51         ImageLoader *il = data;
  52
  53         if (il->func_area_ready)
  54                 {
  55                 if (!il->pixbuf)
  56                         {
  57                         image_loader_sync_pixbuf(il);
  58                         if (!il->pixbuf)
  59                                 {
  60                                 log_printf("critical: area_ready signal with NULL pixbuf (out of mem?)\n");
  61                                 }
  62                         }
  63                 il->func_area_ready(il, x, y, w, h, il->data_area_ready);
  64                 }
  65 }
  66
  67 static void image_loader_area_prepared_cb(GdkPixbufLoader *loader, gpointer data)
  68 {
  69         GdkPixbuf *pb;
  70         guchar *pix;
  71         size_t h, rs;
  72
  73         /* a workaround for http://bugzilla.gnome.org/show_bug.cgi?id=547669 */
  74         gchar *format = gdk_pixbuf_format_get_name(gdk_pixbuf_loader_get_format(loader));
  75         if (strcmp(format, "svg") == 0)
  76                 {
  77                 g_free(format);
  78                 return;
  79                 }
  80
  81         g_free(format);
  82
  83         pb = gdk_pixbuf_loader_get_pixbuf(loader);
  84
  85         h = gdk_pixbuf_get_height(pb);
  86         rs = gdk_pixbuf_get_rowstride(pb);
  87         pix = gdk_pixbuf_get_pixels(pb);
  88
  89         memset(pix, 0, rs * h); /*this should be faster than pixbuf_fill */
  90
  91 }
  92
  93 static void image_loader_size_cb(GdkPixbufLoader *loader,
  94                                  gint width, gint height, gpointer data)
  95 {
  96         ImageLoader *il = data;
  97         GdkPixbufFormat *format;
  98         gchar **mime_types;
  99         gint scale = FALSE;
 100         gint n;
 101
 102         if (il->requested_width < 1 || il->requested_height < 1) return;
 103
 104         format = gdk_pixbuf_loader_get_format(loader);
 105         if (!format) return;
 106
 107         mime_types = gdk_pixbuf_format_get_mime_types(format);
 108         n = 0;
 109         while (mime_types[n])
 110                 {
 111                 if (strstr(mime_types[n], "jpeg")) scale = TRUE;
 112                 n++;
 113                 }
 114         g_strfreev(mime_types);
 115
 116         if (!scale) return;
 117
 118         if (width > il->requested_width || height > il->requested_height)
 119                 {
 120                 gint nw, nh;
 121
 122                 if (((gdouble)il->requested_width / width) < ((gdouble)il->requested_height / height))
 123                         {
 124                         nw = il->requested_width;
 125                         nh = (gdouble)nw / width * height;
 126                         if (nh < 1) nh = 1;
 127                         }
 128                 else
 129                         {
 130                         nh = il->requested_height;
 131                         nw = (gdouble)nh / height * width;
 132                         if (nw < 1) nw = 1;
 133                         }
 134
 135                 gdk_pixbuf_loader_set_size(loader, nw, nh);
 136                 il->shrunk = TRUE;
 137                 }
 138 }
 139
 140 static void image_loader_stop(ImageLoader *il)
 141 {
 142         if (!il) return;
 143
 144         if (il->idle_id != -1)
 145                 {
 146                 g_source_remove(il->idle_id);
 147                 il->idle_id = -1;
 148                 }
 149
 150         if (il->loader)
 151                 {
 152                 /* some loaders do not have a pixbuf till close, order is important here */
 153                 gdk_pixbuf_loader_close(il->loader, NULL);
 154                 image_loader_sync_pixbuf(il);
 155                 g_object_unref(G_OBJECT(il->loader));
 156                 il->loader = NULL;
 157                 }
 158
 159         if (il->mapped_file)
 160                 {
 161                 if (il->preview)
 162                         {
 163                         exif_free_preview(il->mapped_file);
 164                         }
 165                 else
 166                         {
 167                         munmap(il->mapped_file, il->bytes_total);
 168                         }
 169                 il->mapped_file = NULL;
 170                 }
 171
 172         il->done = TRUE;
 173 }
 174
 175 static void image_loader_done(ImageLoader *il)
 176 {
 177         image_loader_stop(il);
 178
 179         if (il->func_done) il->func_done(il, il->data_done);
 180 }
 181
 182 static gint image_loader_done_delay_cb(gpointer data)
 183 {
 184         ImageLoader *il = data;
 185
 186         il->idle_done_id = -1;
 187         image_loader_done(il);
 188         return FALSE;
 189 }
 190
 191 static void image_loader_done_delay(ImageLoader *il)
 192 {
 193         if (il->idle_done_id == -1) il->idle_done_id = g_idle_add_full(il->idle_priority,
 194                                                                        image_loader_done_delay_cb, il, NULL);
 195 }
 196
 197 static void image_loader_error(ImageLoader *il)
 198 {
 199         image_loader_stop(il);
 200
 201         DEBUG_1("pixbuf_loader reported load error for: %s", image_loader_path(il));
 202
 203         if (il->func_error) il->func_error(il, il->data_error);
 204 }
 205
 206 static gint image_loader_idle_cb(gpointer data)
 207 {
 208         ImageLoader *il = data;
 209         gint b;
 210         gint c;
 211
 212         if (!il) return FALSE;
 213
 214         if (il->idle_id == -1) return FALSE;
 215
 216         c = il->idle_read_loop_count ? il->idle_read_loop_count : 1;
 217         while (c > 0)
 218                 {
 219                 b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read);
 220
 221                 if (b == 0)
 222                         {
 223                         image_loader_done(il);
 224                         return FALSE;
 225                         }
 226
 227                 if (b < 0 || (b > 0 && !gdk_pixbuf_loader_write(il->loader, il->mapped_file + il->bytes_read, b, NULL)))
 228                         {
 229                         image_loader_error(il);
 230                         return FALSE;
 231                         }
 232
 233                 il->bytes_read += b;
 234
 235                 c--;
 236                 }
 237
 238         if (il->func_percent && il->bytes_total > 0)
 239                 {
 240                 il->func_percent(il, (gdouble)il->bytes_read / il->bytes_total, il->data_percent);
 241                 }
 242
 243         return TRUE;
 244 }
 245
 246 static gint image_loader_begin(ImageLoader *il)
 247 {
 248         gint b;
 249
 250         if (!il->loader || il->pixbuf) return FALSE;
 251
 252         b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read);
 253
 254         if (b < 1)
 255                 {
 256                 image_loader_stop(il);
 257                 return FALSE;
 258                 }
 259
 260         if (!gdk_pixbuf_loader_write(il->loader, il->mapped_file + il->bytes_read, b, NULL))
 261                 {
 262                 image_loader_stop(il);
 263                 return FALSE;
 264                 }
 265
 266         il->bytes_read += b;
 267
 268         /* read until size is known */
 269         while (il->loader && !gdk_pixbuf_loader_get_pixbuf(il->loader) && b > 0)
 270                 {
 271                 b = MIN(il->read_buffer_size, il->bytes_total - il->bytes_read);
 272                 if (b < 0 || (b > 0 && !gdk_pixbuf_loader_write(il->loader, il->mapped_file + il->bytes_read, b, NULL)))
 273                         {
 274                         image_loader_stop(il);
 275                         return FALSE;
 276                         }
 277                 il->bytes_read += b;
 278                 }
 279         if (!il->pixbuf) image_loader_sync_pixbuf(il);
 280
 281         if (il->bytes_read == il->bytes_total || b < 1)
 282                 {
 283                 /* done, handle (broken) loaders that do not have pixbuf till close */
 284                 image_loader_stop(il);
 285
 286                 if (!il->pixbuf) return FALSE;
 287
 288                 image_loader_done_delay(il);
 289                 return TRUE;
 290                 }
 291
 292         if (!il->pixbuf)
 293                 {
 294                 image_loader_stop(il);
 295                 return FALSE;
 296                 }
 297
 298         /* finally, progressive loading :) */
 299         il->idle_id = g_idle_add_full(il->idle_priority, image_loader_idle_cb, il, NULL);
 300
 301         return TRUE;
 302 }
 303
 304 static gint image_loader_setup(ImageLoader *il)
 305 {
 306         struct stat st;
 307         gchar *pathl;
 308
 309         if (!il || il->loader || il->mapped_file) return FALSE;
 310
 311         il->mapped_file = NULL;
 312
 313         if (il->fd)
 314                 {
 315                 ExifData *exif = exif_read_fd(il->fd);
 316
 317                 il->mapped_file = exif_get_preview(exif, &il->bytes_total);
 318
 319                 if (il->mapped_file)
 320                         {
 321                         il->preview = TRUE;
 322                         DEBUG_1("Raw file %s contains embedded image", image_loader_path(il));
 323                         }
 324                 exif_free_fd(il->fd, exif);
 325                 }
 326
 327
 328         if (!il->mapped_file)
 329                 {
 330                 /* normal file */
 331                 gint load_fd;
 332
 333                 pathl = path_from_utf8(image_loader_path(il));
 334                 load_fd = open(pathl, O_RDONLY | O_NONBLOCK);
 335                 g_free(pathl);
 336                 if (load_fd == -1) return FALSE;
 337
 338                 if (fstat(load_fd, &st) == 0)
 339                         {
 340                         il->bytes_total = st.st_size;
 341                         }
 342                 else
 343                         {
 344                         close(load_fd);
 345                         return FALSE;
 346                         }
 347
 348                 il->mapped_file = mmap(0, il->bytes_total, PROT_READ|PROT_WRITE, MAP_PRIVATE, load_fd, 0);
 349                 close(load_fd);
 350                 if (il->mapped_file == MAP_FAILED)
 351                         {
 352                         il->mapped_file = 0;
 353                         return FALSE;
 354                         }
 355                 il->preview = FALSE;
 356                 }
 357
 358
 359         il->loader = gdk_pixbuf_loader_new();
 360         g_signal_connect(G_OBJECT(il->loader), "area_updated",
 361                          G_CALLBACK(image_loader_area_updated_cb), il);
 362         g_signal_connect(G_OBJECT(il->loader), "size_prepared",
 363                          G_CALLBACK(image_loader_size_cb), il);
 364         g_signal_connect(G_OBJECT(il->loader), "area_prepared",
 365                          G_CALLBACK(image_loader_area_prepared_cb), il);
 366
 367         il->shrunk = FALSE;
 368
 369         return image_loader_begin(il);
 370 }
 371
 372 static ImageLoader *image_loader_new_real(FileData *fd, const gchar *path)
 373 {
 374         ImageLoader *il;
 375
 376         if (!fd && !path) return NULL;
 377
 378         il = g_new0(ImageLoader, 1);
 379         if (fd) il->fd = file_data_ref(fd);
 380         if (path) il->path = g_strdup(path);
 381         il->pixbuf = NULL;
 382         il->idle_id = -1;
 383         il->idle_priority = G_PRIORITY_DEFAULT_IDLE;
 384         il->done = FALSE;
 385         il->loader = NULL;
 386
 387         il->bytes_read = 0;
 388         il->bytes_total = 0;
 389
 390         il->idle_done_id = -1;
 391
 392         il->idle_read_loop_count = options->image.idle_read_loop_count;
 393         il->read_buffer_size = options->image.read_buffer_size;
 394         il->mapped_file = NULL;
 395
 396         il->requested_width = 0;
 397         il->requested_height = 0;
 398         il->shrunk = FALSE;
 399         DEBUG_1("new image loader %p, bufsize=%u idle_loop=%u", il, il->read_buffer_size, il->idle_read_loop_count);
 400         return il;
 401 }
 402
 403 ImageLoader *image_loader_new(FileData *fd)
 404 {
 405         return image_loader_new_real(fd, NULL);
 406 }
 407
 408 ImageLoader *image_loader_new_from_path(const gchar *path)
 409 {
 410         return image_loader_new_real(NULL, path);
 411 }
 412
 413 void image_loader_free(ImageLoader *il)
 414 {
 415         if (!il) return;
 416
 417         image_loader_stop(il);
 418         if (il->idle_done_id != -1) g_source_remove(il->idle_done_id);
 419         if (il->pixbuf) gdk_pixbuf_unref(il->pixbuf);
 420         if (il->fd) file_data_unref(il->fd);
 421         if (il->path) g_free(il->path);
 422         DEBUG_1("freeing image loader %p bytes_read=%d", il, il->bytes_read);
 423         g_free(il);
 424 }
 425
 426 /* don't forget to gdk_pixbuf_ref() it if you want to use it after image_loader_free() */
 427 GdkPixbuf *image_loader_get_pixbuf(ImageLoader *il)
 428 {
 429         if (!il) return NULL;
 430
 431         return il->pixbuf;
 432 }
 433
 434 gchar *image_loader_get_format(ImageLoader *il)
 435 {
 436         GdkPixbufFormat *format;
 437         gchar **mimev;
 438         gchar *mime;
 439
 440         if (!il || !il->loader) return NULL;
 441
 442         format = gdk_pixbuf_loader_get_format(il->loader);
 443         if (!format) return NULL;
 444
 445         mimev = gdk_pixbuf_format_get_mime_types(format);
 446         if (!mimev) return NULL;
 447
 448         /* return first member of mimev, as GdkPixbufLoader has no way to tell us which exact one ? */
 449         mime = g_strdup(mimev[0]);
 450         g_strfreev(mimev);
 451
 452         return mime;
 453 }
 454
 455 void image_loader_set_area_ready_func(ImageLoader *il,
 456                                       void (*func_area_ready)(ImageLoader *, guint, guint, guint, guint, gpointer),
 457                                       gpointer data_area_ready)
 458 {
 459         if (!il) return;
 460
 461         il->func_area_ready = func_area_ready;
 462         il->data_area_ready = data_area_ready;
 463 }
 464
 465 void image_loader_set_error_func(ImageLoader *il,
 466                                  void (*func_error)(ImageLoader *, gpointer),
 467                                  gpointer data_error)
 468 {
 469         if (!il) return;
 470
 471         il->func_error = func_error;
 472         il->data_error = data_error;
 473 }
 474
 475 void image_loader_set_done_func(ImageLoader *il,
 476                                 void (*func_done)(ImageLoader *, gpointer),
 477                                 gpointer data_done)
 478 {
 479         if (!il) return;
 480
 481         il->func_done = func_done;
 482         il->data_done = data_done;
 483 }
 484
 485 void image_loader_set_percent_func(ImageLoader *il,
 486                                    void (*func_percent)(ImageLoader *, gdouble, gpointer),
 487                                    gpointer data_percent)
 488 {
 489         if (!il) return;
 490
 491         il->func_percent = func_percent;
 492         il->data_percent = data_percent;
 493 }
 494
 495 void image_loader_set_requested_size(ImageLoader *il, gint width, gint height)
 496 {
 497         if (!il) return;
 498
 499         il->requested_width = width;
 500         il->requested_height = height;
 501 }
 502
 503 void image_loader_set_buffer_size(ImageLoader *il, guint count)
 504 {
 505         if (!il) return;
 506
 507         il->idle_read_loop_count = count ? count : 1;
 508 }
 509
 510 void image_loader_set_priority(ImageLoader *il, gint priority)
 511 {
 512         if (!il) return;
 513
 514         il->idle_priority = priority;
 515 }
 516
 517 gint image_loader_start(ImageLoader *il, void (*func_done)(ImageLoader *, gpointer), gpointer data_done)
 518 {
 519         if (!il) return FALSE;
 520
 521         if (!image_loader_path(il)) return FALSE;
 522
 523         image_loader_set_done_func(il, func_done, data_done);
 524
 525         return image_loader_setup(il);
 526 }
 527
 528 gdouble image_loader_get_percent(ImageLoader *il)
 529 {
 530         if (!il || il->bytes_total == 0) return 0.0;
 531
 532         return (gdouble)il->bytes_read / il->bytes_total;
 533 }
 534
 535 gint image_loader_get_is_done(ImageLoader *il)
 536 {
 537         if (!il) return FALSE;
 538
 539         return il->done;
 540 }
 541
 542 gint image_load_dimensions(FileData *fd, gint *width, gint *height)
 543 {
 544         ImageLoader *il;
 545         gint success;
 546
 547         il = image_loader_new(fd);
 548
 549         success = image_loader_start(il, NULL, NULL);
 550
 551         if (success && il->pixbuf)
 552                 {
 553                 if (width) *width = gdk_pixbuf_get_width(il->pixbuf);
 554                 if (height) *height = gdk_pixbuf_get_height(il->pixbuf);;
 555                 }
 556         else
 557                 {
 558                 if (width) *width = -1;
 559                 if (height) *height = -1;
 560                 }
 561
 562         image_loader_free(il);
 563
 564         return success;
 565 }