Cycles: svn merge -r41182:41205 ^/trunk/blender
[blender-staging.git] / 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