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