New: Import/Export of Cineon and DPX image files. The first is Kodak's
[blender.git] / source / blender / imbuf / intern / readimage.c
1 /**
2  *
3  * ***** BEGIN GPL/BL DUAL 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. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  * allocimbuf.c
31  *
32  * $Id$
33  */
34
35 #ifdef WIN32
36 #include <io.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_QUICKTIME
63 #if defined(_WIN32) || defined (__APPLE__)
64 #include "quicktime_import.h"
65 #endif
66 #endif
67
68 /* actually hard coded endianness */
69 #define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
70 #define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
71 #define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
72 #define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
73
74 /* more endianness... should move to a separate file... */
75 #if defined(__sgi) || defined (__sparc) || defined (__sparc__) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
76 #define GET_ID GET_BIG_LONG
77 #define LITTLE_LONG SWAP_LONG
78 #else
79 #define GET_ID GET_LITTLE_LONG
80 #define LITTLE_LONG ENDIAN_NOP
81 #endif
82
83 /* from misc_util: flip the bytes from x  */
84 #define GS(x) (((unsigned char *)(x))[0] << 8 | ((unsigned char *)(x))[1])
85
86 /* this one is only def-ed once, strangely... */
87 #define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
88
89 int IB_verbose = TRUE;
90
91 ImBuf *IMB_ibImageFromMemory(int *mem, int size, int flags) {
92         int len;
93         struct ImBuf *ibuf;
94
95         if (mem == NULL) {
96                 printf("Error in ibImageFromMemory: NULL pointer\n");
97         } else {
98                 if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
99                         return (imb_loadiris((uchar *) mem, flags));
100                 } else if (imb_is_a_jpeg((uchar *)mem)) {
101                         return (imb_ibJpegImageFromMemory((uchar *)mem, size, flags));
102                 }
103                 
104                 if (GET_ID(mem) == CAT){
105                         mem += 3;
106                         size -= 4;
107                         while (size > 0){
108                                 if (GET_ID(mem) == FORM){
109                                         len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
110                                         if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
111                                         mem = (int *)((uchar *)mem +len);
112                                         size -= len;
113                                 } else return(0);
114                         }
115                 }
116         
117                 if (size > 0){
118                         if (GET_ID(mem) == FORM){
119                                 if (GET_ID(mem+2) == ILBM){
120                                         return (imb_loadamiga(mem, flags));
121                                 } else if (GET_ID(mem+5) == ILBM){                      /* animaties */
122                                         return (imb_loadamiga(mem+3, flags));
123                                 } else if (GET_ID(mem+2) == ANIM){
124                                         return (imb_loadanim(mem, flags));
125                                 }
126                         }
127                 }
128
129                 ibuf = imb_loadpng((uchar *)mem, size, flags);
130                 if (ibuf) return(ibuf);
131
132                 ibuf = imb_bmp_decode((uchar *)mem, size, flags);
133                 if (ibuf) return(ibuf);
134
135                 ibuf = imb_loadtarga((uchar *)mem, flags);
136                 if (ibuf) return(ibuf);
137
138                 ibuf = imb_loaddpx((uchar *)mem, size, flags);
139                 if (ibuf) return(ibuf);
140
141                 ibuf = imb_loadcineon((uchar *)mem, size, flags);
142                 if (ibuf) return(ibuf);
143         
144                 if (G.have_libtiff) {
145                         ibuf = imb_loadtiff((uchar *)mem, size, flags);
146                         if (ibuf) return(ibuf);
147                 }
148
149                 ibuf = imb_loadhdr((uchar*)mem, size, flags);
150                 if (ibuf) return (ibuf);
151
152 #ifdef WITH_OPENEXR
153                 ibuf = imb_load_openexr((uchar *)mem, size, flags);
154                 if (ibuf) return (ibuf);
155 #endif
156                 
157 #ifdef WITH_QUICKTIME
158 #if defined(_WIN32) || defined (__APPLE__)
159                 if(G.have_quicktime) {
160                         ibuf = imb_quicktime_decode((uchar *)mem, size, flags);
161                         if (ibuf) return(ibuf);
162                 }
163 #endif
164 #endif  
165
166                 if (IB_verbose) fprintf(stderr, "Unknown fileformat\n");
167         }
168         
169         return (0);
170 }
171
172
173 struct ImBuf *IMB_loadiffmem(int *mem, int flags) {
174         int len,maxlen;
175         struct ImBuf *ibuf;
176
177         // IMB_loadiffmem shouldn't be used anymore in new development
178         // it's still here to be backwards compatible...
179
180         maxlen= (GET_BIG_LONG(mem+1) + 1) & ~1;
181
182         if (GET_ID(mem) == CAT){
183                 mem += 3;
184                 maxlen -= 4;
185                 while(maxlen > 0){
186                         if (GET_ID(mem) == FORM){
187                                 len = ((GET_BIG_LONG(mem+1) + 1) & ~1) + 8;
188                                 if ((GET_ID(mem+2) == ILBM) || (GET_ID(mem+2) == ANIM)) break;
189                                 mem = (int *)((uchar *)mem +len);
190                                 maxlen -= len;
191                         } else return(0);
192                 }
193         }
194
195         if (maxlen > 0){
196                 if (GET_ID(mem) == FORM){
197                         if (GET_ID(mem+2) == ILBM){
198                                 return (imb_loadamiga(mem, flags));
199                         } else if (GET_ID(mem+5) == ILBM){                      /* animaties */
200                                 return (imb_loadamiga(mem+3, flags));
201                         } else if (GET_ID(mem+2) == ANIM){
202                                 return (imb_loadanim(mem, flags));
203                         }
204                 } else if ((GS(mem) == IMAGIC) || (GSS(mem) == IMAGIC)){
205                         return (imb_loadiris((uchar *) mem,flags));
206                 } else if ((BIG_LONG(mem[0]) & 0xfffffff0) == 0xffd8ffe0) {
207                         return (0);
208                 }
209         }
210
211         ibuf = imb_loadtarga((uchar *) mem,flags);
212         if (ibuf) return(ibuf);
213
214         if (IB_verbose) fprintf(stderr,"Unknown fileformat\n");
215         return (0);
216 }
217
218 struct ImBuf *IMB_loadifffile(int file, int flags) {
219         struct ImBuf *ibuf;
220         int size, *mem;
221
222         if (file == -1) return (0);
223
224         size = BLI_filesize(file);
225
226 #if defined(AMIGA) || defined(__BeOS) || defined(WIN32)
227         mem= (int *)malloc(size);
228         if (mem==0) {
229                 printf("Out of mem\n");
230                 return (0);
231         }
232
233         if (read(file, mem, size)!=size){
234                 printf("Read Error\n");
235                 free(mem);
236                 return (0);
237         }
238
239         ibuf = IMB_ibImageFromMemory(mem, size, flags);
240         free(mem);
241
242         /* for jpeg read */
243         lseek(file, 0L, SEEK_SET);
244
245 #else
246         mem= (int *)mmap(0,size,PROT_READ,MAP_SHARED,file,0);
247         if (mem==(int *)-1){
248                 printf("Couldn't get mapping\n");
249                 return (0);
250         }
251
252         ibuf = IMB_ibImageFromMemory(mem, size, flags);
253
254         if (munmap( (void *) mem, size)){
255                 printf("Couldn't unmap file.\n");
256         }
257 #endif
258         return(ibuf);
259 }
260
261
262 struct ImBuf *IMB_loadiffname(char *naam, int flags) {
263         int file;
264         struct ImBuf *ibuf;
265         int buf[1];
266
267         file = open(naam, O_BINARY|O_RDONLY);
268
269         if (file == -1) return (0);
270
271         ibuf= IMB_loadifffile(file, flags);
272
273         if (ibuf == 0) {
274                 if (read(file, buf, 4) != 4) buf[0] = 0;
275                 if ((BIG_LONG(buf[0]) & 0xfffffff0) == 0xffd8ffe0)
276                         ibuf = imb_ibJpegImageFromFilename(naam, flags);                        
277         }
278
279         if (ibuf) {
280                 strncpy(ibuf->name, naam, sizeof(ibuf->name));
281                 if (flags & IB_fields) IMB_de_interlace(ibuf);
282         }
283         close(file);
284         return(ibuf);
285 }
286
287 struct ImBuf *IMB_testiffname(char *naam,int flags) {
288         int file;
289         struct ImBuf *ibuf;
290
291         flags |= IB_test;
292         file = open(naam,O_BINARY|O_RDONLY);
293
294         if (file<=0) return (0);
295
296         ibuf=IMB_loadifffile(file,flags);
297         if (ibuf) {
298                 strncpy(ibuf->name, naam, sizeof(ibuf->name));
299         }
300         close(file);
301         return(ibuf);
302 }