Finally change SConscript tabs to spaces.
[blender.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 #ifdef _WIN32
33 #include <io.h>
34 #include <stddef.h>
35 #include <sys/types.h>
36 #include "mmap_win.h"
37 #define open _open
38 #define read _read
39 #define close _close
40 #endif
41
42 #include "BLI_blenlib.h"
43
44 #include "imbuf.h"
45 #include "IMB_imbuf_types.h"
46 #include "IMB_imbuf.h"
47 #include "IMB_filetype.h"
48
49 ImBuf *IMB_ibImageFromMemory(unsigned char *mem, int size, int flags)
50 {
51         ImBuf *ibuf;
52         ImFileType *type;
53
54         if(mem == NULL) {
55                 printf("Error in ibImageFromMemory: NULL pointer\n");
56                 return NULL;
57         }
58
59         for(type=IMB_FILE_TYPES; type->is_a; type++) {
60                 if(type->load) {
61                         ibuf= type->load(mem, size, 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         fprintf(stderr, "Unknown fileformat\n");
74         
75         return NULL;
76 }
77
78 ImBuf *IMB_loadifffile(int file, int flags)
79 {
80         ImBuf *ibuf;
81         unsigned char *mem;
82         int size;
83
84         if(file == -1) return 0;
85
86         size= BLI_filesize(file);
87
88         mem= mmap(0, size, PROT_READ, MAP_SHARED, file, 0);
89         if(mem==(unsigned char*)-1) {
90                 fprintf(stderr, "Couldn't get mapping\n");
91                 return 0;
92         }
93
94         ibuf= IMB_ibImageFromMemory(mem, size, flags);
95
96         if(munmap(mem, size))
97                 fprintf(stderr, "Couldn't unmap file.\n");
98
99         return ibuf;
100 }
101
102 static void imb_cache_filename(char *filename, const char *name, int flags)
103 {
104         /* read .tx instead if it exists and is not older */
105         if(flags & IB_tilecache) {
106                 BLI_strncpy(filename, name, IB_FILENAME_SIZE);
107                 if(!BLI_replace_extension(filename, IB_FILENAME_SIZE, ".tx"))
108                         return;
109
110                 if(BLI_file_older(name, filename))
111                         return;
112         }
113
114         BLI_strncpy(filename, name, IB_FILENAME_SIZE);
115 }
116
117 ImBuf *IMB_loadiffname(const char *name, int flags)
118 {
119         ImBuf *ibuf;
120         int file, a;
121         char filename[IB_FILENAME_SIZE];
122
123         imb_cache_filename(filename, name, flags);
124
125         file = open(filename, O_BINARY|O_RDONLY);
126         if(file < 0) return 0;
127
128         ibuf= IMB_loadifffile(file, flags);
129
130         if(ibuf) {
131                 BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
132                 BLI_strncpy(ibuf->cachename, filename, sizeof(ibuf->cachename));
133                 for(a=1; a<ibuf->miptot; a++)
134                         BLI_strncpy(ibuf->mipmap[a-1]->cachename, filename, sizeof(ibuf->cachename));
135                 if(flags & IB_fields) IMB_de_interlace(ibuf);
136         }
137
138         close(file);
139
140         return ibuf;
141 }
142
143 ImBuf *IMB_testiffname(char *name, int flags)
144 {
145         ImBuf *ibuf;
146         int file;
147         char filename[IB_FILENAME_SIZE];
148
149         imb_cache_filename(filename, name, flags);
150
151         file = open(filename,O_BINARY|O_RDONLY);
152         if(file < 0) return 0;
153
154         ibuf=IMB_loadifffile(file, flags|IB_test);
155         if(ibuf) {
156                 BLI_strncpy(ibuf->name, name, sizeof(ibuf->name));
157                 BLI_strncpy(ibuf->cachename, filename, sizeof(ibuf->cachename));
158         }
159
160         close(file);
161
162         return ibuf;
163 }
164
165 static void imb_loadtilefile(ImBuf *ibuf, int file, int tx, int ty, unsigned int *rect)
166 {
167         ImFileType *type;
168         unsigned char *mem;
169         int size;
170
171         if(file == -1) return;
172
173         size= BLI_filesize(file);
174
175         mem= mmap(0, size, PROT_READ, MAP_SHARED, file, 0);
176         if(mem==(unsigned char*)-1) {
177                 fprintf(stderr, "Couldn't get memory mapping for %s\n", ibuf->cachename);
178                 return;
179         }
180
181         for(type=IMB_FILE_TYPES; type->is_a; type++)
182                 if(type->load_tile && type->ftype(type, ibuf))
183                         type->load_tile(ibuf, mem, size, tx, ty, rect);
184
185         if(munmap(mem, size))
186                 fprintf(stderr, "Couldn't unmap memory for %s.\n", ibuf->cachename);
187 }
188
189 void imb_loadtile(ImBuf *ibuf, int tx, int ty, unsigned int *rect)
190 {
191         int file;
192
193         file = open(ibuf->cachename, O_BINARY|O_RDONLY);
194         if(file < 0) return;
195
196         imb_loadtilefile(ibuf, file, tx, ty, rect);
197
198         close(file);
199 }
200