merge trunk 17122:17213
[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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 #endif
38
39 #include "BLI_blenlib.h"
40
41 #include "imbuf.h"
42 #include "imbuf_patch.h"
43 #include "IMB_imbuf_types.h"
44 #include "IMB_imbuf.h"
45
46 #include "IMB_amiga.h"
47 #include "IMB_iris.h"
48 #include "IMB_targa.h"
49 #include "IMB_png.h"
50 #include "IMB_hamx.h"
51 #include "IMB_jpeg.h"
52 #include "IMB_bmp.h"
53 #include "IMB_tiff.h"
54 #include "IMB_radiance_hdr.h"
55 #include "IMB_dpxcineon.h"
56 #include "BKE_global.h"
57
58 #ifdef WITH_OPENEXR
59 #include "openexr/openexr_api.h"
60 #endif
61
62 #ifdef WITH_DDS
63 #include "dds/dds_api.h"
64 #endif
65
66 #ifdef WITH_QUICKTIME
67 #if defined(_WIN32) || defined (__APPLE__)
68 #include "quicktime_import.h"
69 #endif
70 #endif
71
72 /* actually hard coded endianness */
73 #define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
74 #define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
75 #define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
76 #define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
77
78 /* more endianness... should move to a separate file... */
79 #if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined(__hppa__) || defined (__BIG_ENDIAN__)
80 #define GET_ID GET_BIG_LONG
81 #define LITTLE_LONG SWAP_LONG
82 #else
83 #define GET_ID GET_LITTLE_LONG
84 #define LITTLE_LONG ENDIAN_NOP
85 #endif
86
87 /* from misc_util: flip the bytes from x  */
88 #define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
89
90 /* this one is only def-ed once, strangely... */
91 #define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
92
93 int IB_verbose = TRUE;
94
95 ImBuf *IMB_ibImageFromMemory(int *mem, int size, int flags) {
96         int len;
97         struct ImBuf *ibuf;
98
99         if (mem == NULL) {
100                 printf("Error in ibImageFromMemory: NULL pointer\n");
101         } else {
102                 if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
103                         return (imb_loadiris((uchar *) mem, flags));
104                 } else if (imb_is_a_jpeg((uchar *)mem)) {
105                         return (imb_ibJpegImageFromMemory((uchar *)mem, size, flags));
106                 }
107                 
108                 if (GET_ID(mem) == CAT){
109                         mem += 3;
110                         size -= 4;
111                         while (size > 0){
112                                 if (GET_ID(mem) == FORM){
113                                         len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
114                                         if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
115                                         mem = (int *)((uchar *)mem +len);
116                                         size -= len;
117                                 } else return(0);
118                         }
119                 }
120         
121                 if (size > 0){
122                         if (GET_ID(mem) == FORM){
123                                 if (GET_ID(mem+2) == ILBM){
124                                         return (imb_loadamiga(mem, flags));
125                                 } else if (GET_ID(mem+5) == ILBM){                      /* animaties */
126                                         return (imb_loadamiga(mem+3, flags));
127                                 } else if (GET_ID(mem+2) == ANIM){
128                                         return (imb_loadanim(mem, flags));
129                                 }
130                         }
131                 }
132
133                 ibuf = imb_loadpng((uchar *)mem, size, flags);
134                 if (ibuf) return(ibuf);
135
136                 ibuf = imb_bmp_decode((uchar *)mem, size, flags);
137                 if (ibuf) return(ibuf);
138
139                 ibuf = imb_loadtarga((uchar *)mem, flags);
140                 if (ibuf) return(ibuf);
141
142                 ibuf = imb_loaddpx((uchar *)mem, size, flags);
143                 if (ibuf) return(ibuf);
144
145                 ibuf = imb_loadcineon((uchar *)mem, size, flags);
146                 if (ibuf) return(ibuf);
147         
148                 if (G.have_libtiff) {
149                         ibuf = imb_loadtiff((uchar *)mem, size, flags);
150                         if (ibuf) return(ibuf);
151                 }
152
153                 ibuf = imb_loadhdr((uchar*)mem, size, flags);
154                 if (ibuf) return (ibuf);
155
156 #ifdef WITH_OPENEXR
157                 ibuf = imb_load_openexr((uchar *)mem, size, flags);
158                 if (ibuf) return (ibuf);
159 #endif
160
161 #ifdef WITH_DDS
162                 ibuf = imb_load_dds((uchar *)mem, size, flags);
163                 if (ibuf) return (ibuf);
164 #endif
165                 
166 #ifdef WITH_QUICKTIME
167 #if defined(_WIN32) || defined (__APPLE__)
168                 if(G.have_quicktime) {
169                         ibuf = imb_quicktime_decode((uchar *)mem, size, flags);
170                         if (ibuf) return(ibuf);
171                 }
172 #endif
173 #endif  
174
175                 if (IB_verbose) fprintf(stderr, "Unknown fileformat\n");
176         }
177         
178         return (0);
179 }
180
181
182 struct ImBuf *IMB_loadiffmem(int *mem, int flags) {
183         int len,maxlen;
184         struct ImBuf *ibuf;
185
186         // IMB_loadiffmem shouldn't be used anymore in new development
187         // it's still here to be backwards compatible...
188
189         maxlen= (GET_BIG_LONG(mem+1) + 1) & ~1;
190
191         if (GET_ID(mem) == CAT){
192                 mem += 3;
193                 maxlen -= 4;
194                 while(maxlen > 0){
195                         if (GET_ID(mem) == FORM){
196                                 len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
197                                 if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
198                                 mem = (int *)((uchar *)mem +len);
199                                 maxlen -= len;
200                         } else return(0);
201                 }
202         }
203
204         if (maxlen > 0){
205                 if (GET_ID(mem) == FORM){
206                         if (GET_ID(mem+2) == ILBM){
207                                 return (imb_loadamiga(mem, flags));
208                         } else if (GET_ID(mem+5) == ILBM){                      /* animaties */
209                                 return (imb_loadamiga(mem+3, flags));
210                         } else if (GET_ID(mem+2) == ANIM){
211                                 return (imb_loadanim(mem, flags));
212                         }
213                 } else if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
214                         return (imb_loadiris((uchar *) mem,flags));
215                 } else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
216                         return (0);
217                 }
218         }
219
220         ibuf = imb_loadtarga((uchar *) mem,flags);
221         if (ibuf) return(ibuf);
222
223         if (IB_verbose) fprintf(stderr,"Unknown fileformat\n");
224         return (0);
225 }
226
227 struct ImBuf *IMB_loadifffile(int file, int flags) {
228         struct ImBuf *ibuf;
229         int size, *mem;
230
231         if (file == -1) return (0);
232
233         size = BLI_filesize(file);
234
235 #if defined(AMIGA) || defined(__BeOS)
236         mem= (int *)malloc(size);
237         if (mem==0) {
238                 printf("Out of mem\n");
239                 return (0);
240         }
241
242         if (read(file, mem, size)!=size){
243                 printf("Read Error\n");
244                 free(mem);
245                 return (0);
246         }
247
248         ibuf = IMB_ibImageFromMemory(mem, size, flags);
249         free(mem);
250
251         /* for jpeg read */
252         lseek(file, 0L, SEEK_SET);
253
254 #else
255         mem= (int *)mmap(0,size,PROT_READ,MAP_SHARED,file,0);
256         if (mem==(int *)-1){
257                 printf("Couldn't get mapping\n");
258                 return (0);
259         }
260
261         ibuf = IMB_ibImageFromMemory(mem, size, flags);
262
263         if (munmap( (void *) mem, size)){
264                 printf("Couldn't unmap file.\n");
265         }
266 #endif
267         return(ibuf);
268 }
269
270
271 struct ImBuf *IMB_loadiffname(const char *naam, int flags) {
272         int file;
273         struct ImBuf *ibuf;
274         int buf[1];
275
276         file = open(naam, O_BINARY|O_RDONLY);
277
278         if (file == -1) return (0);
279
280         ibuf= IMB_loadifffile(file, flags);
281
282         if (ibuf == NULL) {
283                 if (read(file, buf, 4) != 4) buf[0] = 0;
284                 if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
285                         ibuf = imb_ibJpegImageFromFilename(naam, flags);                        
286         }
287
288         if (ibuf) {
289                 strncpy(ibuf->name, naam, sizeof(ibuf->name));
290                 if (flags & IB_fields) IMB_de_interlace(ibuf);
291         }
292         close(file);
293         return(ibuf);
294 }
295
296 struct ImBuf *IMB_testiffname(char *naam,int flags) {
297         int file;
298         struct ImBuf *ibuf;
299
300         flags |= IB_test;
301         file = open(naam,O_BINARY|O_RDONLY);
302
303         if (file<=0) return (0);
304
305         ibuf=IMB_loadifffile(file,flags);
306         if (ibuf) {
307                 strncpy(ibuf->name, naam, sizeof(ibuf->name));
308         }
309         close(file);
310         return(ibuf);
311 }