src/image-load-libraw.cc

   1 /*
   2  * Copyright (C) 2021 The Geeqie Team
   3  *
   4  * Authors: Colin Clark
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 /**
  22  * @file
  23  * This uses libraw to extract a thumbnail from a raw image. The exiv2 library
  24  * does not (yet) extract thumbnails from .cr3 images.
  25  * LibRaw seems to be slower than exiv2, so let exiv2 have priority.
  26  */
  27
  28 #include "image-load-libraw.h"
  29
  30 #include <config.h>
  31
  32 #include "image-load.h"
  33
  34 #ifdef HAVE_RAW
  35
  36 #include <fcntl.h>
  37 #include <sys/mman.h>
  38 #include <sys/stat.h>
  39
  40 #include <libraw/libraw.h>
  41
  42 #include "debug.h"
  43 #include "filedata.h"
  44 #include "filefilter.h"
  45
  46 struct UnmapData
  47 {
  48         guchar *ptr;
  49         guchar *map_data;
  50         size_t map_len;
  51         libraw_data_t *lrdt;
  52 };
  53
  54 static GList *libraw_unmap_list = nullptr;
  55
  56 void libraw_free_preview(const guchar *buf)
  57 {
  58         GList *work = libraw_unmap_list;
  59
  60         while (work)
  61                 {
  62                 auto ud = static_cast<UnmapData *>(work->data);
  63                 if (ud->ptr == buf)
  64                         {
  65                         munmap(ud->map_data, ud->map_len);
  66                         libraw_close(ud->lrdt);
  67                         libraw_unmap_list = g_list_remove_link(libraw_unmap_list, work);
  68                         g_free(ud);
  69                         return;
  70                         }
  71                 work = work->next;
  72                 }
  73         g_assert_not_reached();
  74 }
  75
  76 guchar *libraw_get_preview(ImageLoader *il, guint *data_len)
  77 {
  78         libraw_data_t *lrdt;
  79         int ret;
  80         UnmapData *ud;
  81         struct stat st;
  82         guchar *map_data;
  83         size_t map_len;
  84         int fd;
  85
  86         if (!filter_file_class(il->fd->path, FORMAT_CLASS_RAWIMAGE)) return nullptr;
  87
  88         fd = open(il->fd->path, O_RDONLY);
  89         if (fd == -1)
  90                 {
  91                 return nullptr;
  92                 }
  93
  94         if (fstat(fd, &st) == -1)
  95                 {
  96                 close(fd);
  97                 return nullptr;
  98                 }
  99
 100         map_len = st.st_size;
 101         map_data = static_cast<guchar *>(mmap(nullptr, map_len, PROT_READ, MAP_PRIVATE, fd, 0));
 102         close(fd);
 103
 104         if (map_data == MAP_FAILED)
 105                 {
 106                 return nullptr;
 107                 }
 108
 109         lrdt = libraw_init(0);
 110         if (!lrdt)
 111                 {
 112                 log_printf("Warning: Cannot create libraw handle\n");
 113                 return nullptr;
 114                 }
 115
 116         ret = libraw_open_buffer(lrdt, map_data, map_len);
 117         if (ret == LIBRAW_SUCCESS)
 118                 {
 119                 ret = libraw_unpack_thumb(lrdt);
 120                 if (ret == LIBRAW_SUCCESS)
 121                         {
 122                         il->mapped_file = reinterpret_cast<guchar *>(lrdt->thumbnail.thumb);
 123                         *data_len = lrdt->thumbnail.tlength;
 124
 125                         ud = g_new(UnmapData, 1);
 126                         ud->ptr =reinterpret_cast<guchar *>(lrdt->thumbnail.thumb);
 127                         ud->map_data = map_data;
 128                         ud->map_len = lrdt->thumbnail.tlength;
 129                         ud->lrdt = lrdt;
 130
 131                         libraw_unmap_list = g_list_prepend(libraw_unmap_list, ud);
 132
 133                         return reinterpret_cast<guchar *>(lrdt->thumbnail.thumb);
 134                         }
 135                 }
 136
 137         libraw_close(lrdt);
 138
 139         return nullptr;
 140 }
 141
 142 #else /* !define HAVE_RAW */
 143
 144 void libraw_free_preview(const guchar *)
 145 {
 146 }
 147
 148 guchar *libraw_get_preview(ImageLoader *, guint *)
 149 {
 150         return nullptr;
 151 }
 152
 153 #endif
 154
 155 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */