source/blender/imbuf/intern/readimage.c

   1 /*
   2  *
   3  * ***** BEGIN GPL LICENSE BLOCK *****
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  20  * All rights reserved.
  21  *
  22  * The Original Code is: all of this file.
  23  *
  24  * Contributor(s): none yet.
  25  *
  26  * ***** END GPL LICENSE BLOCK *****
  27  * allocimbuf.c
  28  *
  29  * $Id$
  30  */
  31
  32 /** \file blender/imbuf/intern/readimage.c
  33  *  \ingroup imbuf
  34  */
  35
  36
  37 #ifdef _WIN32
  38 #include <io.h>
  39 #include <stddef.h>
  40 #include <sys/types.h>
  41 #include "mmap_win.h"
  42 #define open _open
  43 #define read _read
  44 #define close _close
  45 #endif
  46
  47 #include "BLI_blenlib.h"
  48
  49 #include "imbuf.h"
  50 #include "IMB_imbuf_types.h"
  51 #include "IMB_imbuf.h"
  52 #include "IMB_filetype.h"
  53
  54 static ImBuf *imb_ibImageFromFile(const char *filepath, int flags)
  55 {
  56         ImBuf *ibuf;
  57         ImFileType *type;
  58
  59         for(type=IMB_FILE_TYPES; type->is_a; type++) {
  60                 if(type->load_filepath) {
  61                         ibuf= type->load_filepath(filepath, flags);
  62                         if(ibuf) {
  63                                 if(flags & IB_premul) {
  64                                         IMB_premultiply_alpha(ibuf);
  65                                         ibuf->flags |= IB_premul;
  66                                 }
  67
  68                                 return ibuf;
  69                         }
  70                 }
  71         }
  72
  73         return NULL;
  74 }
  75
  76 ImBuf *IMB_ibImageFromMemory(unsigned char *mem, size_t size, int flags)
  77 {
  78         ImBuf *ibuf;
  79         ImFileType *type;
  80
  81         if(mem == NULL) {
  82                 printf("Error in ibImageFromMemory: NULL pointer\n");
  83                 return NULL;
  84         }
  85
  86         for(type=IMB_FILE_TYPES; type->is_a; type++) {
  87                 if(type->load) {
  88                         ibuf= type->load(mem, size, flags);
  89                         if(ibuf) {
  90                                 if(flags & IB_premul) {
  91                                         IMB_premultiply_alpha(ibuf);
  92                                         ibuf->flags |= IB_premul;
  93                                 }
  94
  95                                 return ibuf;
  96                         }
  97                 }
  98         }
  99
 100         fprintf(stderr, "Unknown fileformat\n");
 101
 102         return NULL;
 103 }
 104
 105 ImBuf *IMB_loadifffile(int file, int flags)
 106 {
 107         ImBuf *ibuf;
 108         unsigned char *mem;
 109         size_t size;
 110
 111         if(file == -1) return NULL;
 112
 113         size= BLI_file_descriptor_size(file);
 114
 115         mem= mmap(NULL, size, PROT_READ, MAP_SHARED, file, 0);
 116         if(mem==(unsigned char*)-1) {
 117                 fprintf(stderr, "Couldn't get mapping\n");
 118                 return NULL;
 119         }
 120
 121         ibuf= IMB_ibImageFromMemory(mem, size, flags);
 122
 123         if(munmap(mem, size))
 124                 fprintf(stderr, "Couldn't unmap file.\n");
 125
 126         return ibuf;
 127 }
 128
 129 static void imb_cache_filename(char *filename, const char *name, int flags)
 130 {
 131         /* read .tx instead if it exists and is not older */
 132         if(flags & IB_tilecache) {
 133                 BLI_strncpy(filename, name, IB_FILENAME_SIZE);
 134                 if(!BLI_replace_extension(filename, IB_FILENAME_SIZE, ".tx"))
 135                         return;
 136
 137                 if(BLI_file_older(name, filename))
 138                         return;
 139         }
 140
 141         BLI_strncpy(filename, name, IB_FILENAME_SIZE);
 142 }
 143
 144 ImBuf *IMB_loadiffname(const char *name, int flags)
 145 {
 146         ImBuf *ibuf;
 147         int file, a;
 148         char filename[IB_FILENAME_SIZE];
 149
 150         imb_cache_filename(filename, name, flags);
 151
 152         ibuf= imb_ibImageFromFile(name, flags);
 153
 154         if(!ibuf) {
 155                 file = open(filename, O_BINARY|O_RDONLY);
 156                 if(file < 0) return NULL;
 157
 158                 ibuf= IMB_loadifffile(file, flags);
 159                 close(file);
 160         }
 161
 162         if(ibuf) {
 163                 BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
 164                 BLI_strncpy(ibuf->cachename, filename, sizeof(ibuf->cachename));
 165                 for(a=1; a<ibuf->miptot; a++)
 166                         BLI_strncpy(ibuf->mipmap[a-1]->cachename, filename, sizeof(ibuf->cachename));
 167                 if(flags & IB_fields) IMB_de_interlace(ibuf);
 168         }
 169
 170         return ibuf;
 171 }
 172
 173 ImBuf *IMB_testiffname(char *name, int flags)
 174 {
 175         ImBuf *ibuf;
 176         int file;
 177         char filename[IB_FILENAME_SIZE];
 178
 179         imb_cache_filename(filename, name, flags);
 180
 181         file = open(filename,O_BINARY|O_RDONLY);
 182         if(file < 0) return NULL;
 183
 184         ibuf=IMB_loadifffile(file, flags|IB_test|IB_multilayer);
 185         if(ibuf) {
 186                 BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
 187                 BLI_strncpy(ibuf->cachename, filename, sizeof(ibuf->cachename));
 188         }
 189
 190         close(file);
 191
 192         return ibuf;
 193 }
 194
 195 static void imb_loadtilefile(ImBuf *ibuf, int file, int tx, int ty, unsigned int *rect)
 196 {
 197         ImFileType *type;
 198         unsigned char *mem;
 199         size_t size;
 200
 201         if(file == -1) return;
 202
 203         size= BLI_file_descriptor_size(file);
 204
 205         mem= mmap(NULL, size, PROT_READ, MAP_SHARED, file, 0);
 206         if(mem==(unsigned char*)-1) {
 207                 fprintf(stderr, "Couldn't get memory mapping for %s\n", ibuf->cachename);
 208                 return;
 209         }
 210
 211         for(type=IMB_FILE_TYPES; type->is_a; type++)
 212                 if(type->load_tile && type->ftype && type->ftype(type, ibuf))
 213                         type->load_tile(ibuf, mem, size, tx, ty, rect);
 214
 215         if(munmap(mem, size))
 216                 fprintf(stderr, "Couldn't unmap memory for %s.\n", ibuf->cachename);
 217 }
 218
 219 void imb_loadtile(ImBuf *ibuf, int tx, int ty, unsigned int *rect)
 220 {
 221         int file;
 222
 223         file = open(ibuf->cachename, O_BINARY|O_RDONLY);
 224         if(file < 0) return;
 225
 226         imb_loadtilefile(ibuf, file, tx, ty, rect);
 227
 228         close(file);
 229 }
 230