Initial revision
[blender.git] / source / blender / imbuf / intern / anim.c
1 /**
2  * anim.c
3  *
4  * $Id$
5  *
6  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version 2
11  * of the License, or (at your option) any later version. The Blender
12  * Foundation also sells licenses for use in proprietary software under
13  * the Blender License.  See http://www.blender.org/BL/ for information
14  * about this.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software Foundation,
23  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  *
25  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
26  * All rights reserved.
27  *
28  * The Original Code is: all of this file.
29  *
30  * Contributor(s): none yet.
31  *
32  * ***** END GPL/BL DUAL LICENSE BLOCK *****
33  */
34
35 #ifdef _WIN32
36 #define INC_OLE2
37 #include <windows.h>
38 #include <windowsx.h>
39 #include <mmsystem.h>
40 #include <memory.h>
41 #include <commdlg.h>
42 #include <vfw.h>
43
44 #undef AVIIF_KEYFRAME // redefined in AVI_avi.h
45 #undef AVIIF_LIST // redefined in AVI_avi.h
46
47 #define FIXCC(fcc)  if (fcc == 0)       fcc = mmioFOURCC('N', 'o', 'n', 'e'); \
48                     if (fcc == BI_RLE8) fcc = mmioFOURCC('R', 'l', 'e', '8');
49 #endif
50
51 #include <sys/types.h>
52 #include <ctype.h>
53 #include <stdlib.h>
54 #include <stdio.h>
55 #ifndef _WIN32
56 #include <dirent.h>
57 #else
58 #include <io.h>
59 #include "BLI_winstuff.h"
60 #endif
61
62 #include "BLI_blenlib.h" /* BLI_remlink BLI_filesize BLI_addtail
63                             BLI_countlist BLI_stringdec */
64
65 #include "imbuf.h"
66 #include "imbuf_patch.h"
67
68 #include "AVI_avi.h"
69 #include "IMB_imbuf_types.h"
70 #include "IMB_imbuf.h"
71
72 #include "IMB_allocimbuf.h"
73 #include "IMB_bitplanes.h"
74
75
76 /* actually hard coded endianness */
77 #define GET_BIG_LONG(x) (((uchar *) (x))[0] << 24 | ((uchar *) (x))[1] << 16 | ((uchar *) (x))[2] << 8 | ((uchar *) (x))[3])
78 #define GET_LITTLE_LONG(x) (((uchar *) (x))[3] << 24 | ((uchar *) (x))[2] << 16 | ((uchar *) (x))[1] << 8 | ((uchar *) (x))[0])
79 #define SWAP_L(x) (((x << 24) & 0xff000000) | ((x << 8) & 0xff0000) | ((x >> 8) & 0xff00) | ((x >> 24) & 0xff))
80 #define SWAP_S(x) (((x << 8) & 0xff00) | ((x >> 8) & 0xff))
81
82 /* more endianness... should move to a separate file... */
83 #if defined(__sgi) || defined (__sparc) || defined (__PPC__) || defined (__ppc__) || defined (__BIG_ENDIAN__)
84 #define GET_ID GET_BIG_LONG
85 #define LITTLE_LONG SWAP_LONG
86 #else
87 #define GET_ID GET_LITTLE_LONG
88 #define LITTLE_LONG ENDIAN_NOP
89 #endif
90
91 /****/
92
93 typedef struct Anhd{
94         unsigned char type, mask;
95         unsigned short w, h;
96         unsigned short x, y;
97         unsigned short abs16, abs, reala6, real;
98         unsigned char interleave, pad0;
99         unsigned short bits16, bits;
100         unsigned char pad[16];
101 }Anhd;
102
103 typedef struct Anim5Delta {
104         struct Anim5Delta * next, * prev;
105         void * data;
106         int type;
107 }Anim5Delta;
108
109 #define ANIM_NONE               (0)
110 #define ANIM_SEQUENCE   (1 << 0)
111 #define ANIM_DIR                (1 << 1)
112 #define ANIM_ANIM5              (1 << 2)
113 #define ANIM_TGA                (1 << 3)
114 #define ANIM_MOVIE              (1 << 4)
115 #define ANIM_MDEC               (1 << 5)
116 #define ANIM_AVI                (1 << 6)
117
118 #define ANIM5_MMAP              0
119 #define ANIM5_MALLOC    1
120 #define ANIM5_SNGBUF    2
121 #define ANIM5_XOR               4
122
123 #define MAXNUMSTREAMS   50
124
125 struct anim {
126         int ib_flags;
127         int curtype;
128         int curposition;        /* index  0 = 1e,  1 = 2e, enz. */
129         int duration;
130         int x, y;
131         
132                 /* voor op nummer */
133         char name[256];
134                 /* voor sequence */
135         char first[256];
136         
137                 /* anim5 */
138         struct ListBase anim5base;
139         void            * anim5mmap;
140         int             anim5len;
141         struct Anim5Delta *anim5curdlta;
142         void            (*anim5decode)(struct ImBuf *, unsigned char *);
143         int             anim5flags;
144         
145                 /* movie */
146         void *movie;
147         void *track;
148         void *params;
149         int orientation; 
150         size_t framesize;
151         int interlacing;
152         
153                 /* data */
154         struct ImBuf * ibuf1, * ibuf2;
155         
156                 /* avi */
157         struct _AviMovie *avi;
158
159 #ifdef _WIN32
160                 /* windows avi */
161         int avistreams;
162         int firstvideo;
163         int pfileopen;
164         PAVIFILE        pfile;
165         PAVISTREAM  pavi[MAXNUMSTREAMS];        // the current streams
166         PGETFRAME         pgf;
167 #endif
168 };
169
170 /****/
171
172 #ifdef __sgi
173
174 #include <dmedia/moviefile.h>
175
176 static void movie_printerror(char * str) {
177         const char * errstr = mvGetErrorStr(mvGetErrno());
178
179         if (str) {
180                 if (errstr) printf("%s: %s\n", str, errstr);
181                 else printf("%s: returned error\n", str);
182         } else printf("%s\n", errstr);
183 }
184
185 static int startmovie(struct anim * anim) {
186         if (anim == 0) return(-1);
187
188         if ( mvOpenFile (anim->name, O_BINARY|O_RDONLY, &anim->movie ) != DM_SUCCESS ) {
189                 printf("Can't open movie: %s\n", anim->name);
190                 return(-1);
191         }
192         if ( mvFindTrackByMedium (anim->movie, DM_IMAGE, &anim->track) != DM_SUCCESS ) {
193                 printf("No image track in movie: %s\n", anim->name);
194                 mvClose(anim->movie);
195                 return(-1);
196         }
197
198         anim->duration = mvGetTrackLength (anim->track);
199         anim->params = mvGetParams( anim->track );
200
201         anim->x = dmParamsGetInt( anim->params, DM_IMAGE_WIDTH);
202         anim->y = dmParamsGetInt( anim->params, DM_IMAGE_HEIGHT);
203         anim->interlacing = dmParamsGetEnum (anim->params, DM_IMAGE_INTERLACING);
204         anim->orientation = dmParamsGetEnum (anim->params, DM_IMAGE_ORIENTATION);
205         anim->framesize = dmImageFrameSize(anim->params);
206
207         anim->curposition = 0;
208
209         /*printf("x:%d y:%d size:%d interl:%d dur:%d\n", anim->x, anim->y, anim->framesize, anim->interlacing, anim->duration);*/
210         return (0);
211 }
212
213 static ImBuf * movie_fetchibuf(struct anim * anim, int position) {
214         ImBuf * ibuf;
215 /*      extern rectcpy(); */
216         int size;
217         unsigned int *rect1, *rect2;
218
219         if (anim == 0) return (0);
220
221         ibuf = IMB_allocImBuf(anim->x, anim->y, 24, IB_rect, 0);
222
223         if ( mvReadFrames(anim->track, position, 1, ibuf->x * ibuf->y * 
224             sizeof(int), ibuf->rect ) != DM_SUCCESS ) {
225                 movie_printerror("mvReadFrames");
226                 IMB_freeImBuf(ibuf);
227                 return(0);
228         }
229
230         /*
231     if (anim->interlacing == DM_IMAGE_INTERLACED_EVEN)
232     {
233     rect1 = ibuf->rect + (ibuf->x * ibuf->y) - 1;
234     rect2 = rect1 - ibuf->x;
235     
236     for (size = ibuf->x * (ibuf->y - 1); size > 0; size--){
237     *rect1-- = *rect2--;
238     }
239     }
240     */
241
242         if (anim->interlacing == DM_IMAGE_INTERLACED_EVEN)
243         {
244                 rect1 = ibuf->rect;
245                 rect2 = rect1 + ibuf->x;
246
247                 for (size = ibuf->x * (ibuf->y - 1); size > 0; size--){
248                         *rect1++ = *rect2++;
249                 }
250         }
251         /*if (anim->orientation == DM_TOP_TO_BOTTOM) IMB_flipy(ibuf);*/
252
253
254         return(ibuf);
255 }
256
257 static void free_anim_movie(struct anim * anim) {
258         if (anim == NULL) return;
259
260         if (anim->movie) {
261                 mvClose(anim->movie);
262                 anim->movie = NULL;
263         }
264         anim->duration = 0;
265 }
266
267 static int ismovie(char *name) {
268         return (mvIsMovieFile(name) == DM_TRUE);
269 }
270
271 #else
272
273 static int ismovie(char *name) {
274         return 0;
275 }
276
277         /* never called, just keep the linker happy */
278 static int startmovie(struct anim * anim) { return 1; }
279 static ImBuf * movie_fetchibuf(struct anim * anim, int position) { return NULL; }
280 static void free_anim_movie(struct anim * anim) { ; }
281
282 #endif
283
284 static int an_stringdec(char *string, char* kop, char *staart,unsigned short *numlen) {
285         unsigned short len,nums,nume;
286         short i,found=FALSE;
287
288         len=strlen(string);
289
290         for(i=len-1;i>=0;i--){
291                 if (string[i]=='/') break;
292                 if (isdigit(string[i])) {
293                         if (found){
294                                 nums=i;
295                         } else{
296                                 nume=i;
297                                 nums=i;
298                                 found=TRUE;
299                         }
300                 } else{
301                         if (found) break;
302                 }
303         }
304         if (found){
305                 strcpy(staart,&string[nume+1]);
306                 strcpy(kop,string);
307                 kop[nums]=0;
308                 *numlen=nume-nums+1;
309                 return ((int)atoi(&(string[nums])));
310         }
311         staart[0]=0;
312         strcpy(kop,string);
313         *numlen=0;
314         return (1);
315 }
316
317
318 static void an_stringenc(char *string, char *kop, char *staart, 
319 unsigned short numlen, int pic) {
320         char numstr[10];
321         unsigned short len,i;
322
323         len=sprintf(numstr,"%d",pic);
324
325         strcpy(string,kop);
326         for(i=len;i<numlen;i++){
327                 strcat(string,"0");
328         }
329         strcat(string,numstr);
330         strcat(string,staart);
331 }
332
333 /* om anim5's te kunnen lezen, moet een aantal gegevens bijgehouden worden:
334  * Een lijst van pointers naar delta's, in geheugen of ge'mmap'ed
335  * 
336  * Mogelijk kan er ook een 'skiptab' aangelegd worden, om sneller
337  * sprongen te kunnen maken.
338  * 
339  * Er moeten niet direct al plaatjes gegenereed worden, dit maakt de 
340  * routines onbruikbaar om snel naar het goede plaatje te springen.
341  * Een routine voert dus de delta's uit, een andere routine maakt van
342  * voorgrondplaatje een ibuf;
343  */
344
345
346 /*
347    een aantal functie pointers moet geinporteerd worden, zodat er niet
348    nog meer library's / objects meegelinkt hoeven te worden.
349
350    Dezelfde structuur moet ook gebruikt kunnen worden voor het wegschrijven
351    van animaties. Hoe geef je dit aan ?
352    
353    Hoe snel kunnen 10 .dlta's gedecomprimeerd worden
354    (zonder omzetten naar rect).
355    
356    1 - zoek naar 1e plaatje, animatie die aan de eisen voldoet
357    2 - probeer volgende plaatje te vinden:
358                 anim5 - decomprimeer
359                 sequence - teller ophogen
360                 directory - volgende entry
361    3 - geen succes ? ga naar 1.
362    
363    
364 */
365
366 /*
367         1. Initialiseer routine met toegestane reeksen, en eerste naam
368                 - series op naam (.0001)
369                 - directories
370                 - anim5 animaties
371                 - TGA delta's
372                 - iff 24bits delta's (.delta)
373         
374         2. haal volgende (vorige ?) plaatje op.
375         
376         3. vrijgeven
377 */
378
379 /* selectie volgorde is:
380         1 - anim5()
381         2 - name
382         3 - dir
383 */
384
385
386 static void free_anim_anim5(struct anim * anim) {
387         ListBase * animbase;
388         Anim5Delta * delta, * next;
389
390         if (anim == NULL) return;
391
392         animbase = &anim->anim5base;
393         delta = animbase->first;
394
395         while (delta) {
396                 next = delta->next;
397
398                 if (delta->type == ANIM5_MALLOC) free(delta->data);
399                 BLI_remlink(animbase, delta);
400                 free(delta);
401
402                 delta = next;
403         }
404
405         if (anim->anim5mmap && anim->anim5len) {
406                 MEM_freeN(anim->anim5mmap);
407         }
408
409         anim->anim5mmap = NULL;
410         anim->anim5len = 0;
411         anim->anim5curdlta = 0;
412         anim->duration = 0;
413 }
414
415 static void free_anim_avi (struct anim *anim) {
416         int i;
417
418         if (anim == NULL) return;
419         if (anim->avi == NULL) return;
420
421         AVI_close (anim->avi);
422         MEM_freeN (anim->avi);
423         anim->avi = NULL;
424
425 #ifdef _WIN32
426
427         if (anim->pgf) {
428                 AVIStreamGetFrameClose(anim->pgf);
429                 anim->pgf = NULL;
430         }
431
432         for (i = 0; i < anim->avistreams; i++){
433                 AVIStreamRelease(anim->pavi[i]);
434         }
435         anim->avistreams = 0;
436
437         if (anim->pfileopen) {
438                 AVIFileRelease(anim->pfile);
439                 anim->pfileopen = 0;
440                 AVIFileExit();
441         }
442 #endif
443
444         anim->duration = 0;
445 }
446
447 static void free_anim_ibuf(struct anim * anim) {
448         if (anim == NULL) return;
449
450         if (anim->ibuf1) IMB_freeImBuf(anim->ibuf1);
451         if (anim->ibuf2) IMB_freeImBuf(anim->ibuf2);
452
453         anim->ibuf1 = anim->ibuf2 = NULL;
454 }
455
456
457 void IMB_free_anim(struct anim * anim) {
458         if (anim == NULL) {
459                 printf("free anim, anim == NULL\n");
460                 return;
461         }
462
463         free_anim_ibuf(anim);
464         free_anim_anim5(anim);
465         free_anim_movie(anim);
466         free_anim_avi(anim);
467
468         free(anim);
469 }
470
471 void IMB_close_anim(struct anim * anim) {
472         if (anim == 0) return;
473
474         IMB_free_anim(anim);
475 }
476
477
478 struct anim * IMB_open_anim(char * name, int ib_flags) {
479         struct anim * anim;
480
481         anim = (struct anim*)MEM_callocN(sizeof(struct anim), "anim struct");
482         if (anim != NULL) {
483                 strcpy(anim->name, name);
484                 anim->ib_flags = ib_flags;
485         }
486         return(anim);
487 }
488
489
490 static int isavi (char *name) {
491     return AVI_is_avi (name);
492 }
493
494 static int imb_get_anim_type(char * name) {
495         int type;
496         struct stat st;
497
498         if (ib_stat(name,&st) == -1) return(0);
499         if (((st.st_mode) & S_IFMT) != S_IFREG) return(0);
500
501         if (isavi(name)) return (ANIM_AVI);
502         if (ismovie(name)) return (ANIM_MOVIE);
503  
504         type = IMB_ispic(name);
505         if (type == ANIM) return (ANIM_ANIM5);
506         if (type) return(ANIM_SEQUENCE);
507         return(0);
508 }
509  
510 int IMB_isanim(char * name) {
511         int type= imb_get_anim_type(name);
512         
513         return (type && type!=ANIM_SEQUENCE);
514 }
515
516 static void planes_to_rect(struct ImBuf * ibuf, int flags) {
517         if (ibuf == 0) return;
518
519         /* dit komt regelrecht uit de amiga.c */
520
521         if (flags & IB_rect && ibuf->rect == 0) {
522                 imb_addrectImBuf(ibuf);
523                 imb_bptolong(ibuf);
524                 IMB_flipy(ibuf);
525                 imb_freeplanesImBuf(ibuf);
526
527                 if (ibuf->cmap){
528                         if ((flags & IB_cmap) == 0) {
529                                 IMB_applycmap(ibuf);
530                                 IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
531                         }
532                 } else if (ibuf->depth == 18){
533                         int i,col;
534                         unsigned int *rect;
535
536                         rect = ibuf->rect;
537                         for(i=ibuf->x * ibuf->y ; i>0 ; i--){
538                                 col = *rect;
539                                 col = ((col & 0x3f000) << 6) + ((col & 0xfc0) << 4)
540                                     + ((col & 0x3f) << 2);
541                                 col += (col & 0xc0c0c0) >> 6;
542                                 *rect++ = col;
543                         }
544                         ibuf->depth = 24;
545                 } else if (ibuf->depth <= 8) {
546                         /* geen colormap en geen 24 bits: zwartwit */
547                         uchar *rect;
548                         int size, shift;
549
550                         if (ibuf->depth < 8){
551                                 rect = (uchar *) ibuf->rect;
552                                 rect += 3;
553                                 shift = 8 - ibuf->depth;
554                                 for (size = ibuf->x * ibuf->y; size > 0; size --){
555                                         rect[0] <<= shift;
556                                         rect += 4;
557                                 }
558                         }
559                         rect = (uchar *) ibuf->rect;
560                         for (size = ibuf->x * ibuf->y; size > 0; size --){
561                                 rect[1] = rect[2] = rect[3];
562                                 rect += 4;
563                         }
564                         ibuf->depth = 8;
565                 }
566         }
567 }
568
569
570 static void anim5decode(struct ImBuf * ibuf, uchar * dlta) {
571         uchar depth;
572         int skip;
573         int *ofspoint;
574         uchar **planes;
575
576         /*      samenstelling delta:
577                 lijst met ofsets voor delta's per bitplane (ofspoint)
578                 per kolom in delta (point)
579                         aantal handelingen (noops)
580                                 code
581                                         bijbehorende data
582                                 ...
583                         ...
584         */
585
586         dlta += 8;
587
588         ofspoint = (int *)dlta;
589         skip = ibuf->skipx * sizeof(int *);
590         planes = (uchar **)ibuf->planes;
591
592         for(depth=ibuf->depth ; depth>0 ; depth--){
593                 if (GET_BIG_LONG(ofspoint)){
594                         uchar *planestart;
595                         uchar *point;
596                         uchar x;
597
598                         point = dlta + GET_BIG_LONG(ofspoint);
599                         planestart = planes[0];
600                         x = (ibuf->x + 7) >> 3;
601
602                         do{
603                                 uchar noop;
604
605                                 if (noop = *(point++)){
606                                         uchar *plane;
607                                         uchar code;
608
609                                         plane = planestart;
610                                         do{
611                                                 if ((code = *(point++))==0){
612                                                         uchar val;
613
614                                                         code = *(point++);
615                                                         val = *(point++);
616                                                         do {
617                                                                 plane[0] = val;
618                                                                 plane += skip;
619                                                         } while(--code);
620
621                                                 } else if (code & 128){
622
623                                                         code &= 0x7f;
624                                                         do{
625                                                                 plane[0] = *(point++);
626                                                                 plane += skip;
627                                                         } while(--code);
628
629                                                 } else plane += code * skip;
630
631                                         } while(--noop);
632                                 }
633                                 planestart++;
634                         } while(--x);
635                 }
636                 ofspoint++;
637                 planes++;
638         }
639 }
640
641
642 static void anim5xordecode(struct ImBuf * ibuf, uchar * dlta) {
643         uchar depth;
644         int skip;
645         int *ofspoint;
646         uchar **planes;
647
648         /*      samenstelling delta:
649                 lijst met ofsets voor delta's per bitplane (ofspoint)
650                 per kolom in delta (point)
651                         aantal handelingen (noops)
652                                 code
653                                         bijbehorende data
654                                 ...
655                         ...
656         */
657
658         dlta += 8;
659
660         ofspoint = (int *)dlta;
661         skip = ibuf->skipx * sizeof(int *);
662         planes = (uchar **)ibuf->planes;
663
664         for(depth=ibuf->depth ; depth>0 ; depth--){
665
666                 if (GET_BIG_LONG(ofspoint)){
667                         uchar *planestart;
668                         uchar *point;
669                         uchar x;
670
671                         point = dlta + GET_BIG_LONG(ofspoint);
672                         planestart = planes[0];
673                         x = (ibuf->x + 7) >> 3;
674
675                         do{
676                                 uchar noop;
677
678                                 if (noop = *(point++)){
679                                         uchar *plane;
680                                         uchar code;
681
682                                         plane = planestart;
683                                         do{
684                                                 if ((code = *(point++))==0){
685                                                         uchar val;
686
687                                                         code = *(point++);
688                                                         val = *(point++);
689                                                         do{
690                                                                 plane[0] ^= val;
691                                                                 plane += skip;
692                                                         }while(--code);
693
694                                                 } else if (code & 128){
695
696                                                         code &= 0x7f;
697                                                         do{
698                                                                 plane[0] ^= *(point++);
699                                                                 plane += skip;
700                                                         }while(--code);
701
702                                                 } else plane += code * skip;
703
704                                         }while(--noop);
705                                 }
706                                 planestart++;
707                         }while(--x);
708                 }
709                 ofspoint++;
710                 planes++;
711         }
712 }
713
714 static int nextanim5(struct anim * anim) {
715         Anim5Delta * delta;
716         struct ImBuf * ibuf;
717
718         if (anim == 0) return(-1);
719
720         delta = anim->anim5curdlta;
721
722         if (delta == 0) return (-1);
723
724         if (anim->anim5flags & ANIM5_SNGBUF) {
725                 ibuf = anim->ibuf1;
726                 if (ibuf == 0) return (0);
727                 anim->anim5decode(ibuf, delta->data);
728         } else {
729                 ibuf = anim->ibuf2;
730                 if (ibuf == 0) return (0);
731                 anim->anim5decode(ibuf, delta->data);
732                 anim->ibuf2 = anim->ibuf1;
733                 anim->ibuf1 = ibuf;
734         }
735
736         anim->anim5curdlta = anim->anim5curdlta->next;
737         anim->curposition++;
738
739         return(0);
740 }
741
742 static int rewindanim5(struct anim * anim) {
743         Anim5Delta * delta;
744         struct ImBuf * ibuf;
745
746         if (anim == 0) return (-1);
747
748         free_anim_ibuf(anim);
749
750         delta = anim->anim5base.first;
751         if (delta == 0) return (-1);
752
753         ibuf = IMB_loadiffmem(delta->data, IB_planes);
754         if (ibuf == 0) return(-1);
755
756         anim->ibuf1 = ibuf;
757         if ((anim->anim5flags & ANIM5_SNGBUF) == 0) anim->ibuf2 = IMB_dupImBuf(ibuf);
758
759         anim->anim5curdlta = delta->next;
760         anim->curposition = 0;
761
762         return(0);
763 }
764
765
766 static int startanim5(struct anim * anim) {
767         int file, buf[20], totlen;
768         unsigned int len;
769         short * mem;
770         ListBase * animbase;
771         Anim5Delta * delta;
772         Anhd anhd;
773
774         /* Controles */
775
776         if (anim == 0) return(-1);
777
778         file = open(anim->name,O_BINARY|O_RDONLY);
779         if (file < 0) return (-1);
780
781         if (read(file, buf, 24) != 24) {
782                 close(file);
783                 return(-1);
784         }
785
786         if ((GET_ID(buf) != FORM) || (GET_ID(buf + 2) != ANIM)
787             || (GET_ID(buf + 3) != FORM) || (GET_ID(buf + 5) != ILBM)){
788                 printf("No anim5 file %s\n",anim->name);
789                 close(file);
790                 return (-1);
791         }
792
793         /* de hele file wordt in het geheugen gemapped */
794
795         totlen = BLI_filesize(file);
796         if (totlen && file>=0) {
797                 lseek(file, 0L, SEEK_SET);
798                 
799                 mem= MEM_mallocN(totlen, "mmap");
800                 if (read(file, mem, totlen) != totlen) {
801                         MEM_freeN(mem);
802                         mem = NULL;
803                 }
804         } else {
805                 mem = NULL;
806         }
807         close (file);
808
809         if (!mem) return (-1);
810
811         anhd.interleave = 0;
812         anhd.bits = 0;
813         anhd.type = 5;
814
815         anim->anim5mmap = mem;
816         anim->anim5len = totlen;
817         anim->anim5flags = 0;
818         anim->duration = 0;
819
820         animbase = & anim->anim5base;
821         animbase->first = animbase->last = 0;
822
823         /* eerste plaatje inlezen */
824
825         mem = mem + 6;
826         totlen -= 12;
827
828         len = GET_BIG_LONG(mem + 2);
829         len = (len + 8 + 1) & ~1;
830         delta = NEW(Anim5Delta);
831
832         delta->data = mem;
833         delta->type = ANIM5_MMAP;
834
835         BLI_addtail(animbase, delta);
836
837         mem += (len >> 1);
838         totlen -= len;
839
840         while (totlen > 0) {
841                 len = GET_BIG_LONG(mem + 2);
842                 len = (len + 8 + 1) & ~1;
843
844                 switch(GET_ID(mem)){
845                 case FORM:
846                         len = 12;
847                         break;
848                 case ANHD:
849                         memcpy(&anhd, mem + 4, sizeof(Anhd));
850                         break;
851                 case DLTA:
852                         delta = NEW(Anim5Delta);
853                         delta->data = mem;
854                         delta->type = ANIM5_MMAP;
855                         BLI_addtail(animbase, delta);
856                         break;
857                 }
858
859                 mem += (len >> 1);
860                 totlen -= len;
861         }
862
863         if (anhd.interleave == 1) anim->anim5flags |= ANIM5_SNGBUF;
864         if (BIG_SHORT(anhd.bits) & 2) anim->anim5decode = anim5xordecode;
865         else anim->anim5decode = anim5decode;
866
867         /* laatste twee delta's wissen */
868
869         delta = animbase->last;
870         if (delta) {
871                 BLI_remlink(animbase, delta);
872                 free(delta);
873         }
874
875         if ((anim->anim5flags & ANIM5_SNGBUF) == 0) {
876                 delta = animbase->last;
877                 if (delta) {
878                         BLI_remlink(animbase, delta);
879                         free(delta);
880                 }
881         }
882
883         anim->duration = BLI_countlist(animbase);
884
885         return(rewindanim5(anim));
886 }
887
888
889 static struct ImBuf * anim5_fetchibuf(struct anim * anim) {
890         struct ImBuf * ibuf;
891
892         if (anim == 0) return (0);
893
894         ibuf = IMB_dupImBuf(anim->ibuf1);
895         planes_to_rect(ibuf, anim->ib_flags);
896
897         return(ibuf);
898 }
899
900 static int startavi (struct anim *anim) {
901
902         AviError avierror;
903 #ifdef _WIN32
904         HRESULT hr;
905         int i, firstvideo = -1;
906         BYTE abFormat[1024];
907         LONG l;
908         LPBITMAPINFOHEADER lpbi;
909         AVISTREAMINFO avis;
910 #endif
911
912         anim->avi = MEM_callocN (sizeof(AviMovie),"animavi");
913
914         if (anim->avi == NULL) {
915                 printf("Can't open avi: %s\n", anim->name);
916                 return -1;
917         }
918
919         avierror = AVI_open_movie (anim->name, anim->avi);
920
921 #ifdef _WIN32
922         if (avierror == AVI_ERROR_COMPRESSION) {
923                 AVIFileInit();
924                 hr = AVIFileOpen(&anim->pfile, anim->name, OF_READ, 0L);
925                 if (hr == 0) {
926                         anim->pfileopen = 1;
927                         for (i = 0; i < MAXNUMSTREAMS; i++) {
928                                 if (AVIFileGetStream(anim->pfile, &anim->pavi[i], 0L, i) != AVIERR_OK) {
929                                         break;
930                                 }
931                                 
932                                 AVIStreamInfo(anim->pavi[i], &avis, sizeof(avis));
933                                 if ((avis.fccType == streamtypeVIDEO) && (firstvideo == -1)) {
934                                         anim->pgf = AVIStreamGetFrameOpen(anim->pavi[i], NULL);
935                                         if (anim->pgf) {
936                                                 firstvideo = i;
937
938                                                 // get stream length
939                                                 anim->avi->header->TotalFrames = AVIStreamLength(anim->pavi[i]);
940                                                 
941                                                 // get information about images inside the stream
942                                                 l = sizeof(abFormat);
943                                                 AVIStreamReadFormat(anim->pavi[i], 0, &abFormat, &l);
944                                                 lpbi = (LPBITMAPINFOHEADER)abFormat;
945                                                 anim->avi->header->Height = lpbi->biHeight;
946                                                 anim->avi->header->Width = lpbi->biWidth;
947                                         } else {
948                                                 FIXCC(avis.fccHandler);
949                                                 FIXCC(avis.fccType);
950                                                 printf("Can't find AVI decoder for type : %4.4hs/%4.4hs\n",
951                                                         (LPSTR)&avis.fccType,
952                                                         (LPSTR)&avis.fccHandler);
953                                         }
954                                 }
955                         }
956
957                         // register number of opened avistreams
958                         anim->avistreams = i;
959
960                         //
961                         // Couldn't get any video streams out of this file
962                         //
963                         if ((anim->avistreams == 0) || (firstvideo == -1)) {
964                                 avierror = AVI_ERROR_FORMAT;
965                         } else {
966                                 avierror = AVI_ERROR_NONE;
967                                 anim->firstvideo = firstvideo;
968                         }
969                 } else {
970                         AVIFileExit();
971                 }
972         }
973 #endif
974
975         if (avierror != AVI_ERROR_NONE) {
976                 AVI_print_error(avierror);
977                 printf ("Error loading avi: %s\n", anim->name);         
978                 free_anim_avi(anim);
979                 return -1;
980         }
981         
982         anim->duration = anim->avi->header->TotalFrames;
983         anim->params = 0;
984
985         anim->x = anim->avi->header->Width;
986         anim->y = anim->avi->header->Height;
987         anim->interlacing = 0;
988         anim->orientation = 0;
989         anim->framesize = anim->x * anim->y * 4;
990
991         anim->curposition = 0;
992
993         /*  printf("x:%d y:%d size:%d interl:%d dur:%d\n", anim->x, anim->y, anim->framesize, anim->interlacing, anim->duration);*/
994
995         return 0;
996 }
997
998 static ImBuf * avi_fetchibuf (struct anim *anim, int position) {
999         ImBuf *ibuf = NULL;
1000         int *tmp;
1001         int y;
1002         
1003         if (anim == NULL) return (NULL);
1004
1005 #ifdef _WIN32
1006         if (anim->avistreams) {
1007                 LPBITMAPINFOHEADER lpbi;
1008
1009                 if (anim->pgf) {
1010                     lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
1011                         if (lpbi) {
1012                                 ibuf = IMB_ibImageFromMemory((int *) lpbi, 100, IB_rect);
1013                         }
1014                 }
1015         } else {
1016 #else
1017         if (1) {
1018 #endif
1019                 ibuf = IMB_allocImBuf (anim->x, anim->y, 24, IB_rect, 0);
1020
1021                 tmp = AVI_read_frame (anim->avi, AVI_FORMAT_RGB32, position,
1022                         AVI_get_stream(anim->avi, AVIST_VIDEO, 0));
1023                 
1024                 if (tmp == NULL) {
1025                         printf ("Error reading frame from AVI");
1026                         IMB_freeImBuf (ibuf);
1027                         return NULL;
1028                 }
1029
1030                 for (y=0; y < anim->y; y++) {
1031                         memcpy (&(ibuf->rect)[((anim->y-y)-1)*anim->x],  &tmp[y*anim->x],  
1032                                         anim->x * 4);
1033                 }
1034                 
1035                 MEM_freeN (tmp);
1036         }
1037
1038         return ibuf;
1039 }
1040
1041 /* probeer volgende plaatje te lezen */
1042 /* Geen plaatje, probeer dan volgende animatie te openen */
1043 /* gelukt, haal dan eerste plaatje van animatie */
1044
1045 static struct ImBuf * anim_getnew(struct anim * anim) {
1046         struct ImBuf *ibuf = 0;
1047
1048         if (anim == NULL) return(0);
1049
1050         free_anim_anim5(anim);
1051         free_anim_movie(anim);
1052         free_anim_avi(anim);
1053
1054         if (anim->curtype != 0) return (0);
1055         anim->curtype = imb_get_anim_type(anim->name);  
1056
1057         switch (anim->curtype) {
1058         case ANIM_ANIM5:
1059                 if (startanim5(anim)) return (0);
1060                 ibuf = anim5_fetchibuf(anim);
1061                 break;
1062         case ANIM_SEQUENCE:
1063                 ibuf = IMB_loadiffname(anim->name, anim->ib_flags);
1064                 if (ibuf) {
1065                         strcpy(anim->first, anim->name);
1066                         anim->duration = 1;
1067                 }
1068                 break;
1069         case ANIM_MOVIE:
1070                 if (startmovie(anim)) return (0);
1071                 ibuf = IMB_allocImBuf (anim->x, anim->y, 24, 0, 0); /* fake */
1072                 break;
1073         case ANIM_AVI:
1074                 if (startavi(anim)) return (0);
1075                 ibuf = IMB_allocImBuf (anim->x, anim->y, 24, 0, 0);
1076                 break;
1077         }
1078
1079         return(ibuf);
1080 }
1081
1082
1083 struct ImBuf * IMB_anim_absolute(struct anim * anim, int position) {
1084         struct ImBuf * ibuf = 0;
1085         char head[256], tail[256];
1086         unsigned short digits;
1087         int pic;
1088
1089         if (anim == NULL) return(0);
1090
1091         if (anim->curtype == 0) {
1092                 ibuf = anim_getnew(anim);
1093                 if (ibuf == NULL) return (0);
1094                 IMB_freeImBuf(ibuf); /* ???? */
1095         }
1096
1097         if (position < 0) return(0);
1098         if (position >= anim->duration) return(0);
1099
1100         switch(anim->curtype) {
1101         case ANIM_ANIM5:
1102                 if (anim->curposition > position) rewindanim5(anim);
1103                 while (anim->curposition < position) {
1104                         if (nextanim5(anim)) return (0);
1105                 }
1106                 ibuf = anim5_fetchibuf(anim);
1107                 break;
1108         case ANIM_SEQUENCE:
1109                 pic = an_stringdec(anim->first, head, tail, &digits);
1110                 pic += position;
1111                 an_stringenc(anim->name, head, tail, digits, pic);
1112                 ibuf = IMB_loadiffname(anim->name, LI_rect);
1113                 if (ibuf) {
1114                         anim->curposition = position;
1115                         /* patch... by freeing the cmap you prevent a double apply cmap... */
1116                         /* probably the IB_CMAP option isn't working proper
1117                          * after the abgr->rgba reconstruction
1118                          */
1119                         IMB_freecmapImBuf(ibuf);
1120                 }
1121                 break;
1122         case ANIM_MOVIE:
1123                 ibuf = movie_fetchibuf(anim, position);
1124                 if (ibuf) {
1125                         anim->curposition = position;
1126                         IMB_convert_rgba_to_abgr(ibuf->x*ibuf->y, ibuf->rect);
1127                 }
1128                 break;
1129         case ANIM_AVI:
1130                 ibuf = avi_fetchibuf(anim, position);
1131                 if (ibuf) anim->curposition = position;
1132                 break;
1133         }
1134
1135         if (ibuf) {
1136                 if (anim->ib_flags & IB_ttob) IMB_flipy(ibuf);
1137                 sprintf(ibuf->name, "%s.%04d", anim->name, anim->curposition + 1);
1138                 
1139         }
1140         return(ibuf);
1141 }
1142
1143 struct ImBuf * IMB_anim_nextpic(struct anim * anim) {
1144         struct ImBuf * ibuf = 0;
1145
1146         if (anim == 0) return(0);
1147
1148         ibuf = IMB_anim_absolute(anim, anim->curposition + 1);
1149
1150         return(ibuf);
1151 }
1152
1153 /***/
1154
1155 int IMB_anim_get_duration(struct anim *anim) {
1156         return anim->duration;
1157 }