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