This commit reverses the OpenEXR specific stuff in the OpenEXR commit I
[blender-staging.git] / source / blender / blenkernel / intern / image.c
1 /*  image.c        
2  * 
3  * $Id$
4  *
5  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version. The Blender
11  * Foundation also sells licenses for use in proprietary software under
12  * the Blender License.  See http://www.blender.org/BL/ for information
13  * about this.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
25  * All rights reserved.
26  *
27  * The Original Code is: all of this file.
28  *
29  * Contributor(s): none yet.
30  *
31  * ***** END GPL/BL DUAL LICENSE BLOCK *****
32  */
33
34 #include <stdio.h>
35 #include <string.h>
36 #include <fcntl.h>
37 #include <math.h>
38 #ifndef WIN32 
39 #include <unistd.h>
40 #else
41 #include <io.h>
42 #endif
43
44 #include "MEM_guardedalloc.h"
45
46 #include "IMB_imbuf_types.h"
47 #include "IMB_imbuf.h"
48
49 #include "DNA_image_types.h"
50 #include "DNA_texture_types.h"
51 #include "DNA_packedFile_types.h"
52
53 #include "BLI_blenlib.h"
54
55 #include "BKE_bmfont.h"
56 #include "BKE_packedFile.h"
57 #include "BKE_library.h"
58 #include "BKE_global.h"
59 #include "BKE_main.h"
60 #include "BKE_image.h"
61 #include "BKE_scene.h"
62 #include "BKE_texture.h"
63 #include "BKE_utildefines.h"
64
65 /* bad level; call to free_realtime_image */
66 #include "BKE_bad_level_calls.h"        
67
68 void free_image_buffers(Image *ima)
69 {
70         int a;
71
72         if(ima->ibuf) {
73                 if (ima->ibuf->userdata) {
74                         MEM_freeN(ima->ibuf->userdata);
75                         ima->ibuf->userdata = 0;
76                 }
77                 IMB_freeImBuf(ima->ibuf);
78                 ima->ibuf= 0;
79         }
80         if(ima->anim) IMB_free_anim(ima->anim);
81         ima->anim= 0;
82         
83         for(a=0; a<BLI_ARRAY_NELEMS(ima->mipmap); a++) {
84                 if(ima->mipmap[a]) IMB_freeImBuf(ima->mipmap[a]);
85                 ima->mipmap[a]= 0;
86         }
87         
88         free_realtime_image(ima);
89 }
90
91
92 void free_image(Image *ima)
93 {
94
95         free_image_buffers(ima);
96         if (ima->packedfile) {
97                 freePackedFile(ima->packedfile);
98                 ima->packedfile = NULL;
99         }
100 }
101
102
103 Image *add_image(char *name)
104 {
105         Image *ima;
106         int file, len;
107         char *libname, str[256], strtest[256];
108         
109         strcpy(str, name);
110         BLI_convertstringcode(str, G.sce, G.scene->r.cfra);
111         
112         file= open(str, O_BINARY|O_RDONLY);
113         if(file== -1) return 0;
114         close(file);
115         
116         /* first search an identical image */
117         ima= G.main->image.first;
118         while(ima) {
119                 strcpy(strtest, ima->name);
120                 BLI_convertstringcode(strtest, G.sce, G.scene->r.cfra);
121                 if( strcmp(strtest, str)==0 ) {
122                         if(ima->anim==0 || ima->id.us==0) {
123                                 strcpy(ima->name, name);        /* for stringcode */
124                                 ima->id.us++;
125                                 ima->ok= 1;
126                                 return ima;
127                         }
128                 }
129                 ima= ima->id.next;
130         }
131
132         len= strlen(name);
133         
134         while (len > 0 && name[len - 1] != '/' && name[len - 1] != '\\') len--;
135         libname= name+len;
136         
137         ima= alloc_libblock(&G.main->image, ID_IM, libname);
138         strcpy(ima->name, name);
139         ima->ok= 1;
140         
141         ima->xrep= ima->yrep= 1;
142         
143         return ima;
144 }
145
146 void free_unused_animimages()
147 {
148         Image *ima, *nima;
149
150         ima= G.main->image.first;
151         while(ima) {
152                 nima= ima->id.next;
153                 if(ima->id.us==0) {
154                         if(ima->flag & IMA_FROMANIM) free_libblock(&G.main->image, ima);
155                 }
156                 ima= nima;
157         }
158 }
159
160
161 /* *********** READ AND WRITE ************** */
162
163 void makepicstring(char *string, int frame)
164 {
165         short i,len;
166         char num[10], *extension;
167
168         if (string==0) return;
169
170         extension= "";
171
172         strcpy(string, G.scene->r.pic);
173         BLI_convertstringcode(string, G.sce, G.scene->r.cfra);
174
175                         len= strlen(string);
176                         
177         /* can also: sprintf(num, "%04d", frame); */
178
179         i=4-sprintf(num,"%d",frame);
180         for(;i>0;i--){
181                 string[len]='0';
182                 len++;
183         }
184         string[len]=0;
185         strcat(string,num);
186
187         if(G.scene->r.imtype== R_IRIS) {
188                 extension= ".rgb";
189         }
190         else if(G.scene->r.imtype==R_IRIZ) {
191                 extension= ".rgb";
192         }
193         else if(G.scene->r.imtype==R_PNG) {
194                 extension= ".png";
195         }
196         else if(G.scene->r.imtype==R_TARGA) {
197                 extension= ".tga";
198         }
199         else if(G.scene->r.imtype==R_RAWTGA) {
200                 extension= ".tga";
201         }
202         else if(G.scene->r.imtype==R_JPEG90) {
203                 extension= ".jpg";
204         }
205         else if(G.scene->r.imtype==R_BMP) {
206                 extension= ".bmp";
207         }
208         
209         if(G.scene->r.scemode & R_EXTENSION) strcat(string, extension);
210                 
211 }
212
213 /* ******** IMAGE WRAPPING INIT ************* */
214
215 /* used by sequencer, texture */
216 void converttopremul(struct ImBuf *ibuf)
217 {
218         int x, y, val;
219         char *cp;
220         
221         if(ibuf==0) return;
222         if(ibuf->depth==24) {   /* put alpha at 255 */
223
224                 cp= (char *)(ibuf->rect);
225                 for(y=0; y<ibuf->y; y++) {
226                         for(x=0; x<ibuf->x; x++, cp+=4) {
227                                 cp[3]= 255;
228                         }
229                 }
230                 return;
231         }
232         
233         cp= (char *)(ibuf->rect);
234         for(y=0; y<ibuf->y; y++) {
235                 for(x=0; x<ibuf->x; x++, cp+=4) {
236                         if(cp[3]==0) {
237                                 cp[0]= cp[1]= cp[2]= 0;
238                         }
239                         else if(cp[3]!=255) {
240                                 val= cp[3];
241                                 cp[0]= (cp[0]*val)>>8;
242                                 cp[1]= (cp[1]*val)>>8;
243                                 cp[2]= (cp[2]*val)>>8;
244                         }
245                 }
246         }
247 }
248
249 /* used by sequencer, texture */
250 struct anim *openanim(char * name, int flags)
251 {
252         struct anim * anim;
253         struct ImBuf * ibuf;
254         
255         anim = IMB_open_anim(name, flags);
256         if (anim == 0) return(0);
257
258         
259         ibuf = IMB_anim_absolute(anim, 0);
260         if (ibuf == 0) {
261                 printf("anim_absolute 0 failed\n");
262                 IMB_free_anim(anim);
263                 return(0);
264         }
265         IMB_freeImBuf(ibuf);
266         
267         return(anim);
268 }
269
270
271 /*
272 load_image handles reading the image from disk or from the packedfile.
273 */
274
275 void load_image(Image * ima, int flags, char *relabase, int framenum)
276 {
277         char name[FILE_MAXDIR + FILE_MAXFILE];
278
279         if (ima->ibuf == NULL) {
280
281                 // is there a PackedFile with this image ?;
282                 if (ima->packedfile) {
283                         ima->ibuf = IMB_ibImageFromMemory((int *) ima->packedfile->data, ima->packedfile->size, flags);
284                 } else {
285                         strcpy(name, ima->name);
286                         BLI_convertstringcode(name, relabase, framenum);
287
288                         ima->ibuf = IMB_loadiffname(name , flags);
289                 }
290                 // check if the image is a font image...
291                 // printf("Checking for font\n");
292
293                 if (ima->ibuf) {
294                         detectBitmapFont(ima->ibuf);
295                 }
296         }
297 }
298
299
300 static void de_interlace_ng(struct ImBuf *ibuf) /* neogeo fields */
301 {
302         struct ImBuf * tbuf1, * tbuf2;
303         
304         if (ibuf == 0) return;
305         if (ibuf->flags & IB_fields) return;
306         ibuf->flags |= IB_fields;
307         
308         if (ibuf->rect) {
309                 /* make copies */
310                 tbuf1 = IMB_allocImBuf(ibuf->x, (short)(ibuf->y >> 1), (unsigned char)32, (int)IB_rect, (unsigned char)0);
311                 tbuf2 = IMB_allocImBuf(ibuf->x, (short)(ibuf->y >> 1), (unsigned char)32, (int)IB_rect, (unsigned char)0);
312                 
313                 ibuf->x *= 2;
314                 /* These rectop calls are broken!!! I added a trailing 0 arg... */
315                 IMB_rectop(tbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
316                 IMB_rectop(tbuf2, ibuf, 0, 0, tbuf2->x, 0, 32767, 32767, IMB_rectcpy, 0);
317                 
318                 ibuf->x /= 2;
319                 IMB_rectop(ibuf, tbuf1, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
320                 IMB_rectop(ibuf, tbuf2, 0, tbuf2->y, 0, 0, 32767, 32767, IMB_rectcpy, 0);
321                 
322                 IMB_freeImBuf(tbuf1);
323                 IMB_freeImBuf(tbuf2);
324         }
325         ibuf->y /= 2;
326 }
327
328 static void de_interlace_st(struct ImBuf *ibuf) /* standard fields */
329 {
330         struct ImBuf * tbuf1, * tbuf2;
331         
332         if (ibuf == 0) return;
333         if (ibuf->flags & IB_fields) return;
334         ibuf->flags |= IB_fields;
335         
336         if (ibuf->rect) {
337                 /* make copies */
338                 tbuf1 = IMB_allocImBuf(ibuf->x, (short)(ibuf->y >> 1), (unsigned char)32, IB_rect, 0);
339                 tbuf2 = IMB_allocImBuf(ibuf->x, (short)(ibuf->y >> 1), (unsigned char)32, IB_rect, 0);
340                 
341                 ibuf->x *= 2;
342                 /* These are brolenm as well... */
343                 IMB_rectop(tbuf1, ibuf, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
344                 IMB_rectop(tbuf2, ibuf, 0, 0, tbuf2->x, 0, 32767, 32767, IMB_rectcpy, 0);
345                 
346                 ibuf->x /= 2;
347                 IMB_rectop(ibuf, tbuf2, 0, 0, 0, 0, 32767, 32767, IMB_rectcpy, 0);
348                 IMB_rectop(ibuf, tbuf1, 0, tbuf2->y, 0, 0, 32767, 32767, IMB_rectcpy, 0);
349                 
350                 IMB_freeImBuf(tbuf1);
351                 IMB_freeImBuf(tbuf2);
352         }
353         ibuf->y /= 2;
354 }
355
356
357 void ima_ibuf_is_nul(Tex *tex)
358 {
359         void (*de_interlacefunc)(struct ImBuf *ibuf);
360         Image *ima;
361         int a, fra, dur;
362         char str[FILE_MAXDIR+FILE_MAXFILE], *cp;
363         
364         ima= tex->ima;
365         if(ima==0) return;
366         
367         strcpy(str, ima->name);
368         BLI_convertstringcode(str, G.sce, G.scene->r.cfra);
369         
370         if(tex->imaflag & TEX_STD_FIELD) de_interlacefunc= de_interlace_st;
371         else de_interlacefunc= de_interlace_ng;
372         
373         if(tex->imaflag & TEX_ANIM5) {
374                 
375                 if(ima->anim==0) ima->anim = openanim(str, IB_cmap | IB_rect);
376                 if (ima->anim) {
377                         dur = IMB_anim_get_duration(ima->anim);
378                         
379                         ima->lastquality= R.osa;
380                         fra= ima->lastframe-1;
381                         
382                         if(fra<0) fra = 0;
383                         if(fra>(dur-1)) fra= dur-1;
384                         ima->ibuf = IMB_anim_absolute(ima->anim, fra);
385                         
386                         /* patch for textbutton with name ima (B_NAMEIMA) */
387                         if(ima->ibuf) {
388                                 strcpy(ima->ibuf->name, ima->name);
389                                 if (tex->imaflag & TEX_FIELDS) de_interlacefunc(ima->ibuf);
390                         }
391                 }
392                 else printf("Not an anim");
393                 
394         } else {
395                 // create a packedfile for this image when autopack is on
396                 // for performance (IMB_loadiffname uses mmap) we don't do this by default
397                 if ((ima->packedfile == NULL) && (G.fileflags & G_AUTOPACK)) {
398                         ima->packedfile = newPackedFile(str);
399                 }
400                 
401                 load_image(ima, IB_rect, G.sce, G.scene->r.cfra);
402                 
403                 if (tex->imaflag & TEX_FIELDS) de_interlacefunc(ima->ibuf);
404                 
405                 ima->lastquality= R.osa;
406         }
407         
408         if(ima->ibuf) {
409                 
410                 /* stringcodes also in ibuf. ibuf->name is used as 'undo' (buttons.c) */
411                 strcpy(ima->ibuf->name, ima->name);
412                 
413                 if(ima->ibuf->cmap) {
414                         
415                         if(tex->imaflag & TEX_ANIM5) {
416                                 
417                                 if(tex->imaflag & TEX_MORKPATCH) {
418                                         /**** PATCH TO SET COLOR 2 RIGHT (neogeo..) */
419                                         if(ima->ibuf->maxcol > 4) {
420                                                 cp= (char *)(ima->ibuf->cmap+2);
421                                                 cp[0]= 0x80;
422                                         }
423                                 }
424                                 
425                                 IMB_applycmap(ima->ibuf);
426                                 IMB_convert_rgba_to_abgr(ima->ibuf->x*ima->ibuf->y, ima->ibuf->rect);
427                                 
428                         }
429                         
430                         converttopremul(ima->ibuf);
431                 }
432                 
433                 if(R.osa) {
434                         
435                         if(tex->imaflag & TEX_ANTISCALE) {
436                                 IMB_clever_double(ima->ibuf);
437                                 IMB_antialias(ima->ibuf);
438                         }
439                         else if(tex->imaflag & TEX_ANTIALI) IMB_antialias(ima->ibuf);
440                 }
441         }
442         
443         if(ima->ibuf==0) ima->ok= 0;
444         
445         for(a=0; a<BLI_ARRAY_NELEMS(ima->mipmap); a++) {
446                 if(ima->mipmap[a]) IMB_freeImBuf(ima->mipmap[a]);
447                 ima->mipmap[a]= 0;
448         }
449         
450 }
451
452
453