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