source/blender/imbuf/intern/readimage.c

   1 /*
   2  * This program is free software; you can redistribute it and/or
   3  * modify it under the terms of the GNU General Public License
   4  * as published by the Free Software Foundation; either version 2
   5  * of the License, or (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software Foundation,
  14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  15  *
  16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  17  * All rights reserved.
  18  * allocimbuf.c
  19  */
  20
  21 /** \file
  22  * \ingroup imbuf
  23  */
  24
  25 #ifdef _WIN32
  26 #  include <io.h>
  27 #  include <stddef.h>
  28 #  include <sys/types.h>
  29 #  include "mmap_win.h"
  30 #endif
  31
  32 #include <stdlib.h>
  33 #include "BLI_utildefines.h"
  34 #include "BLI_string.h"
  35 #include "BLI_path_util.h"
  36 #include "BLI_fileops.h"
  37
  38 #include "imbuf.h"
  39 #include "IMB_allocimbuf.h"
  40 #include "IMB_imbuf_types.h"
  41 #include "IMB_imbuf.h"
  42 #include "IMB_filetype.h"
  43
  44 #include "IMB_colormanagement.h"
  45 #include "IMB_colormanagement_intern.h"
  46
  47 static void imb_handle_alpha(ImBuf *ibuf,
  48                              int flags,
  49                              char colorspace[IM_MAX_SPACE],
  50                              char effective_colorspace[IM_MAX_SPACE])
  51 {
  52   if (colorspace) {
  53     if (ibuf->rect != NULL && ibuf->rect_float == NULL) {
  54       /* byte buffer is never internally converted to some standard space,
  55        * store pointer to it's color space descriptor instead
  56        */
  57       ibuf->rect_colorspace = colormanage_colorspace_get_named(effective_colorspace);
  58     }
  59
  60     BLI_strncpy(colorspace, effective_colorspace, IM_MAX_SPACE);
  61   }
  62
  63   bool is_data = (colorspace && IMB_colormanagement_space_name_is_data(colorspace));
  64   int alpha_flags = (flags & IB_alphamode_detect) ? ibuf->flags : flags;
  65
  66   if (is_data || (flags & IB_alphamode_channel_packed)) {
  67     /* Don't touch alpha. */
  68     ibuf->flags |= IB_alphamode_channel_packed;
  69   }
  70   else if (flags & IB_alphamode_ignore) {
  71     /* Make opaque. */
  72     IMB_rectfill_alpha(ibuf, 1.0f);
  73     ibuf->flags |= IB_alphamode_ignore;
  74   }
  75   else {
  76     if (alpha_flags & IB_alphamode_premul) {
  77       if (ibuf->rect) {
  78         IMB_unpremultiply_alpha(ibuf);
  79       }
  80       else {
  81         /* pass, floats are expected to be premul */
  82       }
  83     }
  84     else {
  85       if (ibuf->rect_float) {
  86         IMB_premultiply_alpha(ibuf);
  87       }
  88       else {
  89         /* pass, bytes are expected to be straight */
  90       }
  91     }
  92   }
  93
  94   /* OCIO_TODO: in some cases it's faster to do threaded conversion,
  95    *            but how to distinguish such cases */
  96   colormanage_imbuf_make_linear(ibuf, effective_colorspace);
  97 }
  98
  99 ImBuf *IMB_ibImageFromMemory(const unsigned char *mem,
 100                              size_t size,
 101                              int flags,
 102                              char colorspace[IM_MAX_SPACE],
 103                              const char *descr)
 104 {
 105   ImBuf *ibuf;
 106   const ImFileType *type;
 107   char effective_colorspace[IM_MAX_SPACE] = "";
 108
 109   if (mem == NULL) {
 110     fprintf(stderr, "%s: NULL pointer\n", __func__);
 111     return NULL;
 112   }
 113
 114   if (colorspace) {
 115     BLI_strncpy(effective_colorspace, colorspace, sizeof(effective_colorspace));
 116   }
 117
 118   for (type = IMB_FILE_TYPES; type < IMB_FILE_TYPES_LAST; type++) {
 119     if (type->load) {
 120       ibuf = type->load(mem, size, flags, effective_colorspace);
 121       if (ibuf) {
 122         imb_handle_alpha(ibuf, flags, colorspace, effective_colorspace);
 123         return ibuf;
 124       }
 125     }
 126   }
 127
 128   if ((flags & IB_test) == 0) {
 129     fprintf(stderr, "%s: unknown fileformat (%s)\n", __func__, descr);
 130   }
 131
 132   return NULL;
 133 }
 134
 135 static ImBuf *IMB_ibImageFromFile(const char *filepath,
 136                                   int flags,
 137                                   char colorspace[IM_MAX_SPACE],
 138                                   const char *descr)
 139 {
 140   ImBuf *ibuf;
 141   const ImFileType *type;
 142   char effective_colorspace[IM_MAX_SPACE] = "";
 143
 144   if (colorspace) {
 145     BLI_strncpy(effective_colorspace, colorspace, sizeof(effective_colorspace));
 146   }
 147
 148   for (type = IMB_FILE_TYPES; type < IMB_FILE_TYPES_LAST; type++) {
 149     if (type->load_filepath) {
 150       ibuf = type->load_filepath(filepath, flags, effective_colorspace);
 151       if (ibuf) {
 152         imb_handle_alpha(ibuf, flags, colorspace, effective_colorspace);
 153         return ibuf;
 154       }
 155     }
 156   }
 157
 158   if ((flags & IB_test) == 0) {
 159     fprintf(stderr, "%s: unknown fileformat (%s)\n", __func__, descr);
 160   }
 161
 162   return NULL;
 163 }
 164
 165 static bool imb_is_filepath_format(const char *filepath)
 166 {
 167   /* return true if this is one of the formats that can't be loaded from memory */
 168   return BLI_path_extension_check_array(filepath, imb_ext_image_filepath_only);
 169 }
 170
 171 ImBuf *IMB_loadifffile(
 172     int file, const char *filepath, int flags, char colorspace[IM_MAX_SPACE], const char *descr)
 173 {
 174   ImBuf *ibuf;
 175   unsigned char *mem;
 176   size_t size;
 177
 178   if (file == -1) {
 179     return NULL;
 180   }
 181
 182   if (imb_is_filepath_format(filepath)) {
 183     return IMB_ibImageFromFile(filepath, flags, colorspace, descr);
 184   }
 185
 186   size = BLI_file_descriptor_size(file);
 187
 188   imb_mmap_lock();
 189   mem = mmap(NULL, size, PROT_READ, MAP_SHARED, file, 0);
 190   imb_mmap_unlock();
 191
 192   if (mem == (unsigned char *)-1) {
 193     fprintf(stderr, "%s: couldn't get mapping %s\n", __func__, descr);
 194     return NULL;
 195   }
 196
 197   ibuf = IMB_ibImageFromMemory(mem, size, flags, colorspace, descr);
 198
 199   imb_mmap_lock();
 200   if (munmap(mem, size)) {
 201     fprintf(stderr, "%s: couldn't unmap file %s\n", __func__, descr);
 202   }
 203   imb_mmap_unlock();
 204
 205   return ibuf;
 206 }
 207
 208 static void imb_cache_filename(char *filename, const char *name, int flags)
 209 {
 210   /* read .tx instead if it exists and is not older */
 211   if (flags & IB_tilecache) {
 212     BLI_strncpy(filename, name, IMB_FILENAME_SIZE);
 213     if (!BLI_path_extension_replace(filename, IMB_FILENAME_SIZE, ".tx")) {
 214       return;
 215     }
 216
 217     if (BLI_file_older(name, filename)) {
 218       return;
 219     }
 220   }
 221
 222   BLI_strncpy(filename, name, IMB_FILENAME_SIZE);
 223 }
 224
 225 ImBuf *IMB_loadiffname(const char *filepath, int flags, char colorspace[IM_MAX_SPACE])
 226 {
 227   ImBuf *ibuf;
 228   int file, a;
 229   char filepath_tx[IMB_FILENAME_SIZE];
 230
 231   BLI_assert(!BLI_path_is_rel(filepath));
 232
 233   imb_cache_filename(filepath_tx, filepath, flags);
 234
 235   file = BLI_open(filepath_tx, O_BINARY | O_RDONLY, 0);
 236   if (file == -1) {
 237     return NULL;
 238   }
 239
 240   ibuf = IMB_loadifffile(file, filepath, flags, colorspace, filepath_tx);
 241
 242   if (ibuf) {
 243     BLI_strncpy(ibuf->name, filepath, sizeof(ibuf->name));
 244     BLI_strncpy(ibuf->cachename, filepath_tx, sizeof(ibuf->cachename));
 245     for (a = 1; a < ibuf->miptot; a++) {
 246       BLI_strncpy(ibuf->mipmap[a - 1]->cachename, filepath_tx, sizeof(ibuf->cachename));
 247     }
 248   }
 249
 250   close(file);
 251
 252   return ibuf;
 253 }
 254
 255 ImBuf *IMB_testiffname(const char *filepath, int flags)
 256 {
 257   ImBuf *ibuf;
 258   int file;
 259   char filepath_tx[IMB_FILENAME_SIZE];
 260   char colorspace[IM_MAX_SPACE] = "\0";
 261
 262   BLI_assert(!BLI_path_is_rel(filepath));
 263
 264   imb_cache_filename(filepath_tx, filepath, flags);
 265
 266   file = BLI_open(filepath_tx, O_BINARY | O_RDONLY, 0);
 267   if (file == -1) {
 268     return NULL;
 269   }
 270
 271   ibuf = IMB_loadifffile(file, filepath, flags | IB_test | IB_multilayer, colorspace, filepath_tx);
 272
 273   if (ibuf) {
 274     BLI_strncpy(ibuf->name, filepath, sizeof(ibuf->name));
 275     BLI_strncpy(ibuf->cachename, filepath_tx, sizeof(ibuf->cachename));
 276   }
 277
 278   close(file);
 279
 280   return ibuf;
 281 }
 282
 283 static void imb_loadtilefile(ImBuf *ibuf, int file, int tx, int ty, unsigned int *rect)
 284 {
 285   const ImFileType *type;
 286   unsigned char *mem;
 287   size_t size;
 288
 289   if (file == -1) {
 290     return;
 291   }
 292
 293   size = BLI_file_descriptor_size(file);
 294
 295   imb_mmap_lock();
 296   mem = mmap(NULL, size, PROT_READ, MAP_SHARED, file, 0);
 297   imb_mmap_unlock();
 298
 299   if (mem == (unsigned char *)-1) {
 300     fprintf(stderr, "Couldn't get memory mapping for %s\n", ibuf->cachename);
 301     return;
 302   }
 303
 304   for (type = IMB_FILE_TYPES; type < IMB_FILE_TYPES_LAST; type++) {
 305     if (type->load_tile && type->ftype(type, ibuf)) {
 306       type->load_tile(ibuf, mem, size, tx, ty, rect);
 307     }
 308   }
 309
 310   imb_mmap_lock();
 311   if (munmap(mem, size)) {
 312     fprintf(stderr, "Couldn't unmap memory for %s.\n", ibuf->cachename);
 313   }
 314   imb_mmap_unlock();
 315 }
 316
 317 void imb_loadtile(ImBuf *ibuf, int tx, int ty, unsigned int *rect)
 318 {
 319   int file;
 320
 321   file = BLI_open(ibuf->cachename, O_BINARY | O_RDONLY, 0);
 322   if (file == -1) {
 323     return;
 324   }
 325
 326   imb_loadtilefile(ibuf, file, tx, ty, rect);
 327
 328   close(file);
 329 }