21b7cfd010c42389dd01033a2fb1385af06c31e3
[blender.git] / source / blender / blenkernel / intern / sequencer.c
1 /**
2 * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): 
24  * - Blender Foundation, 2003-2009
25  * - Peter Schlaile <peter [at] schlaile [dot] de> 2005/2006
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <stddef.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <math.h>
34
35 #include "MEM_guardedalloc.h"
36 #include "MEM_CacheLimiterC-Api.h"
37
38 #include "DNA_sequence_types.h"
39 #include "DNA_scene_types.h"
40 #include "DNA_anim_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_sound_types.h"
43
44 #include "BKE_animsys.h"
45 #include "BKE_global.h"
46 #include "BKE_image.h"
47 #include "BKE_main.h"
48 #include "BKE_sequencer.h"
49 #include "BKE_fcurve.h"
50 #include "BKE_scene.h"
51 #include "RNA_access.h"
52 #include "RE_pipeline.h"
53
54 #include "BLI_math.h"
55 #include "BLI_fileops.h"
56 #include "BLI_listbase.h"
57 #include "BLI_path_util.h"
58 #include "BLI_string.h"
59 #include "BLI_threads.h"
60 #include <pthread.h>
61
62 #include "IMB_imbuf.h"
63 #include "IMB_imbuf_types.h"
64
65
66
67 #include "BKE_context.h"
68 #include "BKE_sound.h"
69 #include "AUD_C-API.h"
70
71 #ifdef WIN32
72 #define snprintf _snprintf
73 #endif
74
75 /* **** XXX ******** */
76 //static void waitcursor(int val) {}
77 //static int blender_test_break() {return 0;}
78
79 /* **** XXX ******** */
80 #define SELECT 1
81 ListBase seqbase_clipboard;
82 int seqbase_clipboard_frame;
83 SequencerDrawView sequencer_view3d_cb= NULL; /* NULL in background mode */
84
85
86 void printf_strip(Sequence *seq)
87 {
88         fprintf(stderr, "name: '%s', len:%d, start:%d, (startofs:%d, endofs:%d), (startstill:%d, endstill:%d), machine:%d, (startdisp:%d, enddisp:%d)\n",
89                         seq->name, seq->len, seq->start, seq->startofs, seq->endofs, seq->startstill, seq->endstill, seq->machine, seq->startdisp, seq->enddisp);
90         fprintf(stderr, "\tseq_tx_set_final_left: %d %d\n\n", seq_tx_get_final_left(seq, 0), seq_tx_get_final_right(seq, 0));
91 }
92
93 int seqbase_recursive_apply(ListBase *seqbase, int (*apply_func)(Sequence *seq, void *), void *arg)
94 {
95         Sequence *iseq;
96         for(iseq= seqbase->first; iseq; iseq= iseq->next) {
97                 if(seq_recursive_apply(iseq, apply_func, arg) == -1)
98                         return -1; /* bail out */
99         }
100         return 1;
101 }
102
103 int seq_recursive_apply(Sequence *seq, int (*apply_func)(Sequence *, void *), void *arg)
104 {
105         int ret= apply_func(seq, arg);
106
107         if(ret == -1)
108                 return -1;  /* bail out */
109
110         if(ret && seq->seqbase.first)
111                 ret = seqbase_recursive_apply(&seq->seqbase, apply_func, arg);
112
113         return ret;
114 }
115
116 /* **********************************************************************
117    alloc / free functions
118    ********************************************************************** */
119
120
121
122 void new_tstripdata(Sequence *seq)
123 {
124         if(seq->strip) {
125                 seq->strip->len= seq->len;
126         }
127 }
128
129
130 /* free */
131
132 static void free_proxy_seq(Sequence *seq)
133 {
134         if (seq->strip && seq->strip->proxy && seq->strip->proxy->anim) {
135                 IMB_free_anim(seq->strip->proxy->anim);
136                 seq->strip->proxy->anim = 0;
137         }
138 }
139
140 void seq_free_strip(Strip *strip)
141 {
142         strip->us--;
143         if(strip->us>0) return;
144         if(strip->us<0) {
145                 printf("error: negative users in strip\n");
146                 return;
147         }
148
149         if (strip->stripdata) {
150                 MEM_freeN(strip->stripdata);
151         }
152
153         if (strip->proxy) {
154                 if (strip->proxy->anim) {
155                         IMB_free_anim(strip->proxy->anim);
156                 }
157
158                 MEM_freeN(strip->proxy);
159         }
160         if (strip->crop) {
161                 MEM_freeN(strip->crop);
162         }
163         if (strip->transform) {
164                 MEM_freeN(strip->transform);
165         }
166         if (strip->color_balance) {
167                 MEM_freeN(strip->color_balance);
168         }
169
170         MEM_freeN(strip);
171 }
172
173 static void seq_free_animdata(Scene *scene, Sequence *seq);
174
175 void seq_free_sequence(Scene *scene, Sequence *seq)
176 {
177         if(seq->strip) seq_free_strip(seq->strip);
178
179         if(seq->anim) IMB_free_anim(seq->anim);
180
181         if (seq->type & SEQ_EFFECT) {
182                 struct SeqEffectHandle sh = get_sequence_effect(seq);
183
184                 sh.free(seq);
185         }
186
187         /* clipboard has no scene and will never have a sound handle or be active */
188         if(scene) {
189                 Editing *ed = scene->ed;
190
191                 if (ed->act_seq==seq)
192                         ed->act_seq= NULL;
193
194                 if(seq->scene_sound)
195                         sound_remove_scene_sound(scene, seq->scene_sound);
196
197                 seq_free_animdata(scene, seq);
198         }
199
200         MEM_freeN(seq);
201 }
202
203 Editing *seq_give_editing(Scene *scene, int alloc)
204 {
205         if (scene->ed == NULL && alloc) {
206                 Editing *ed;
207
208                 ed= scene->ed= MEM_callocN( sizeof(Editing), "addseq");
209                 ed->seqbasep= &ed->seqbase;
210         }
211         return scene->ed;
212 }
213
214 void seq_free_clipboard(void)
215 {
216         Sequence *seq, *nseq;
217
218         for(seq= seqbase_clipboard.first; seq; seq= nseq) {
219                 nseq= seq->next;
220                 seq_free_sequence(NULL, seq);
221         }
222         seqbase_clipboard.first= seqbase_clipboard.last= NULL;
223 }
224
225 void seq_free_editing(Scene *scene)
226 {
227         Editing *ed = scene->ed;
228         MetaStack *ms;
229         Sequence *seq;
230
231         if(ed==NULL)
232                 return;
233
234         SEQ_BEGIN(ed, seq) {
235                 seq_free_sequence(scene, seq);
236         }
237         SEQ_END
238
239         while((ms= ed->metastack.first)) {
240                 BLI_remlink(&ed->metastack, ms);
241                 MEM_freeN(ms);
242         }
243
244         MEM_freeN(ed);
245 }
246
247 /* ************************* itterator ************************** */
248 /* *************** (replaces old WHILE_SEQ) ********************* */
249 /* **************** use now SEQ_BEGIN() SEQ_END ***************** */
250
251 /* sequence strip iterator:
252  * - builds a full array, recursively into meta strips */
253
254 static void seq_count(ListBase *seqbase, int *tot)
255 {
256         Sequence *seq;
257
258         for(seq=seqbase->first; seq; seq=seq->next) {
259                 (*tot)++;
260
261                 if(seq->seqbase.first)
262                         seq_count(&seq->seqbase, tot);
263         }
264 }
265
266 static void seq_build_array(ListBase *seqbase, Sequence ***array, int depth)
267 {
268         Sequence *seq;
269
270         for(seq=seqbase->first; seq; seq=seq->next) {
271                 seq->depth= depth;
272
273                 if(seq->seqbase.first)
274                         seq_build_array(&seq->seqbase, array, depth+1);
275
276                 **array= seq;
277                 (*array)++;
278         }
279 }
280
281 void seq_array(Editing *ed, Sequence ***seqarray, int *tot, int use_pointer)
282 {
283         Sequence **array;
284
285         *seqarray= NULL;
286         *tot= 0;
287
288         if(ed == NULL)
289                 return;
290
291         if(use_pointer)
292                 seq_count(ed->seqbasep, tot);
293         else
294                 seq_count(&ed->seqbase, tot);
295
296         if(*tot == 0)
297                 return;
298
299         *seqarray= array= MEM_mallocN(sizeof(Sequence *)*(*tot), "SeqArray");
300         if(use_pointer)
301                 seq_build_array(ed->seqbasep, &array, 0);
302         else
303                 seq_build_array(&ed->seqbase, &array, 0);
304 }
305
306 void seq_begin(Editing *ed, SeqIterator *iter, int use_pointer)
307 {
308         memset(iter, 0, sizeof(*iter));
309         seq_array(ed, &iter->array, &iter->tot, use_pointer);
310
311         if(iter->tot) {
312                 iter->cur= 0;
313                 iter->seq= iter->array[iter->cur];
314                 iter->valid= 1;
315         }
316 }
317
318 void seq_next(SeqIterator *iter)
319 {
320         if(++iter->cur < iter->tot)
321                 iter->seq= iter->array[iter->cur];
322         else
323                 iter->valid= 0;
324 }
325
326 void seq_end(SeqIterator *iter)
327 {
328         if(iter->array)
329                 MEM_freeN(iter->array);
330
331         iter->valid= 0;
332 }
333
334 /*
335   **********************************************************************
336   * build_seqar
337   **********************************************************************
338   * Build a complete array of _all_ sequencies (including those
339   * in metastrips!)
340   **********************************************************************
341 */
342
343 static void do_seq_count(ListBase *seqbase, int *totseq)
344 {
345         Sequence *seq;
346
347         seq= seqbase->first;
348         while(seq) {
349                 (*totseq)++;
350                 if(seq->seqbase.first) do_seq_count(&seq->seqbase, totseq);
351                 seq= seq->next;
352         }
353 }
354
355 static void do_build_seqar(ListBase *seqbase, Sequence ***seqar, int depth)
356 {
357         Sequence *seq;
358
359         seq= seqbase->first;
360         while(seq) {
361                 seq->depth= depth;
362                 if(seq->seqbase.first) do_build_seqar(&seq->seqbase, seqar, depth+1);
363                 **seqar= seq;
364                 (*seqar)++;
365                 seq= seq->next;
366         }
367 }
368
369 void build_seqar(ListBase *seqbase, Sequence  ***seqar, int *totseq)
370 {
371         Sequence **tseqar;
372
373         *totseq= 0;
374         do_seq_count(seqbase, totseq);
375
376         if(*totseq==0) {
377                 *seqar= 0;
378                 return;
379         }
380         *seqar= MEM_mallocN(sizeof(void *)* *totseq, "seqar");
381         tseqar= *seqar;
382
383         do_build_seqar(seqbase, seqar, 0);
384         *seqar= tseqar;
385 }
386
387 static void do_seq_count_cb(ListBase *seqbase, int *totseq,
388                                 int (*test_func)(Sequence * seq))
389 {
390         Sequence *seq;
391
392         seq= seqbase->first;
393         while(seq) {
394                 int test = test_func(seq);
395                 if (test & BUILD_SEQAR_COUNT_CURRENT) {
396                         (*totseq)++;
397                 }
398                 if(seq->seqbase.first && (test & BUILD_SEQAR_COUNT_CHILDREN)) {
399                         do_seq_count_cb(&seq->seqbase, totseq, test_func);
400                 }
401                 seq= seq->next;
402         }
403 }
404
405 static void do_build_seqar_cb(ListBase *seqbase, Sequence ***seqar, int depth,
406                                   int (*test_func)(Sequence * seq))
407 {
408         Sequence *seq;
409
410         seq= seqbase->first;
411         while(seq) {
412                 int test = test_func(seq);
413                 seq->depth= depth;
414
415                 if(seq->seqbase.first && (test & BUILD_SEQAR_COUNT_CHILDREN)) {
416                         do_build_seqar_cb(&seq->seqbase, seqar, depth+1, 
417                                           test_func);
418                 }
419                 if (test & BUILD_SEQAR_COUNT_CURRENT) {
420                         **seqar= seq;
421                         (*seqar)++;
422                 }
423                 seq= seq->next;
424         }
425 }
426
427 void build_seqar_cb(ListBase *seqbase, Sequence  ***seqar, int *totseq,
428                         int (*test_func)(Sequence * seq))
429 {
430         Sequence **tseqar;
431
432         *totseq= 0;
433         do_seq_count_cb(seqbase, totseq, test_func);
434
435         if(*totseq==0) {
436                 *seqar= 0;
437                 return;
438         }
439         *seqar= MEM_mallocN(sizeof(void *)* *totseq, "seqar");
440         tseqar= *seqar;
441
442         do_build_seqar_cb(seqbase, seqar, 0, test_func);
443         *seqar= tseqar;
444 }
445
446
447 void calc_sequence_disp(Scene *scene, Sequence *seq)
448 {
449         if(seq->startofs && seq->startstill) seq->startstill= 0;
450         if(seq->endofs && seq->endstill) seq->endstill= 0;
451         
452         seq->startdisp= seq->start + seq->startofs - seq->startstill;
453         seq->enddisp= seq->start+seq->len - seq->endofs + seq->endstill;
454         
455         seq->handsize= 10.0;    /* 10 frames */
456         if( seq->enddisp-seq->startdisp < 10 ) {
457                 seq->handsize= (float)(0.5*(seq->enddisp-seq->startdisp));
458         }
459         else if(seq->enddisp-seq->startdisp > 250) {
460                 seq->handsize= (float)((seq->enddisp-seq->startdisp)/25);
461         }
462
463         seq_update_sound(scene, seq);
464 }
465
466 static void seq_update_sound_bounds_recursive(Scene *scene, Sequence *metaseq)
467 {
468         Sequence *seq;
469
470         /* for sound we go over full meta tree to update bounds of the sound strips,
471            since sound is played outside of evaluating the imbufs, */
472         for(seq=metaseq->seqbase.first; seq; seq=seq->next) {
473                 if(seq->type == SEQ_META) {
474                         seq_update_sound_bounds_recursive(scene, seq);
475                 }
476                 else if((seq->type == SEQ_SOUND) || (seq->type == SEQ_SCENE)) {
477                         if(seq->scene_sound) {
478                                 int startofs = seq->startofs;
479                                 int endofs = seq->endofs;
480                                 if(seq->startofs + seq->start < metaseq->start + metaseq->startofs)
481                                         startofs = metaseq->start + metaseq->startofs - seq->start;
482
483                                 if(seq->start + seq->len - seq->endofs > metaseq->start + metaseq->len - metaseq->endofs)
484                                         endofs = seq->start + seq->len - metaseq->start - metaseq->len + metaseq->endofs;
485                                 sound_move_scene_sound(scene, seq->scene_sound, seq->start + startofs, seq->start+seq->len - endofs, startofs);
486                         }
487                 }
488         }
489 }
490
491 void calc_sequence(Scene *scene, Sequence *seq)
492 {
493         Sequence *seqm;
494         int min, max;
495
496         /* check all metas recursively */
497         seqm= seq->seqbase.first;
498         while(seqm) {
499                 if(seqm->seqbase.first) calc_sequence(scene, seqm);
500                 seqm= seqm->next;
501         }
502
503         /* effects and meta: automatic start and end */
504
505         if(seq->type & SEQ_EFFECT) {
506                 /* pointers */
507                 if(seq->seq2==0) seq->seq2= seq->seq1;
508                 if(seq->seq3==0) seq->seq3= seq->seq1;
509
510                 /* effecten go from seq1 -> seq2: test */
511
512                 /* we take the largest start and smallest end */
513
514                 // seq->start= seq->startdisp= MAX2(seq->seq1->startdisp, seq->seq2->startdisp);
515                 // seq->enddisp= MIN2(seq->seq1->enddisp, seq->seq2->enddisp);
516
517                 if (seq->seq1) {
518                         seq->start= seq->startdisp= MAX3(seq->seq1->startdisp, seq->seq2->startdisp, seq->seq3->startdisp);
519                         seq->enddisp= MIN3(seq->seq1->enddisp, seq->seq2->enddisp, seq->seq3->enddisp);
520                         seq->len= seq->enddisp - seq->startdisp;
521                 } else {
522                         calc_sequence_disp(scene, seq);
523                 }
524
525                 if(seq->strip && seq->len!=seq->strip->len) {
526                         new_tstripdata(seq);
527                 }
528
529         }
530         else {
531                 if(seq->type==SEQ_META) {
532                         seqm= seq->seqbase.first;
533                         if(seqm) {
534                                 min=  MAXFRAME * 2;
535                                 max= -MAXFRAME * 2;
536                                 while(seqm) {
537                                         if(seqm->startdisp < min) min= seqm->startdisp;
538                                         if(seqm->enddisp > max) max= seqm->enddisp;
539                                         seqm= seqm->next;
540                                 }
541                                 seq->start= min + seq->anim_startofs;
542                                 seq->len = max-min;
543                                 seq->len -= seq->anim_startofs;
544                                 seq->len -= seq->anim_endofs;
545
546                                 if(seq->strip && seq->len!=seq->strip->len) {
547                                         new_tstripdata(seq);
548                                 }
549                         }
550                         seq_update_sound_bounds_recursive(scene, seq);
551                 }
552                 calc_sequence_disp(scene, seq);
553         }
554 }
555
556 /* note: caller should run calc_sequence(scene, seq) after */
557 void reload_sequence_new_file(Scene *scene, Sequence * seq, int lock_range)
558 {
559         char str[FILE_MAXDIR+FILE_MAXFILE];
560         int prev_startdisp, prev_enddisp;
561         /* note: dont rename the strip, will break animation curves */
562
563         if (!(seq->type == SEQ_MOVIE || seq->type == SEQ_IMAGE ||
564                   seq->type == SEQ_SOUND ||
565                   seq->type == SEQ_SCENE || seq->type == SEQ_META)) {
566                 return;
567         }
568
569         if(lock_range) {
570                 /* keep so we dont have to move the actual start and end points (only the data) */
571                 calc_sequence_disp(scene, seq);
572                 prev_startdisp= seq->startdisp;
573                 prev_enddisp= seq->enddisp;
574         }
575
576
577         new_tstripdata(seq);
578
579         if (seq->type != SEQ_SCENE && seq->type != SEQ_META &&
580                 seq->type != SEQ_IMAGE) {
581                 BLI_join_dirfile(str, seq->strip->dir, seq->strip->stripdata->name);
582                 BLI_path_abs(str, G.main->name);
583         }
584
585         if (seq->type == SEQ_IMAGE) {
586                 /* Hack? */
587                 size_t olen = MEM_allocN_len(seq->strip->stripdata)/sizeof(struct StripElem);
588
589                 seq->len = olen;
590                 seq->len -= seq->anim_startofs;
591                 seq->len -= seq->anim_endofs;
592                 if (seq->len < 0) {
593                         seq->len = 0;
594                 }
595                 seq->strip->len = seq->len;
596         } else if (seq->type == SEQ_MOVIE) {
597                 if(seq->anim) IMB_free_anim(seq->anim);
598                 seq->anim = openanim(str, IB_rect | ((seq->flag & SEQ_FILTERY) ? IB_animdeinterlace : 0));
599
600                 if (!seq->anim) {
601                         return;
602                 }
603         
604                 seq->len = IMB_anim_get_duration(seq->anim);
605                 
606                 seq->anim_preseek = IMB_anim_get_preseek(seq->anim);
607
608                 seq->len -= seq->anim_startofs;
609                 seq->len -= seq->anim_endofs;
610                 if (seq->len < 0) {
611                         seq->len = 0;
612                 }
613                 seq->strip->len = seq->len;
614         } else if (seq->type == SEQ_SOUND) {
615                 seq->len = ceil(AUD_getInfo(seq->sound->playback_handle).length * FPS);
616                 seq->len -= seq->anim_startofs;
617                 seq->len -= seq->anim_endofs;
618                 if (seq->len < 0) {
619                         seq->len = 0;
620                 }
621                 seq->strip->len = seq->len;
622         } else if (seq->type == SEQ_SCENE) {
623                 /* 'seq->scenenr' should be replaced with something more reliable */
624                 Scene * sce = G.main->scene.first;
625                 int nr = 1;
626                 
627                 while(sce) {
628                         if(nr == seq->scenenr) {
629                                 break;
630                         }
631                         nr++;
632                         sce= sce->id.next;
633                 }
634
635                 if (sce) {
636                         seq->scene = sce;
637                 } else {
638                         sce = seq->scene;
639                 }
640                 
641                 seq->len= seq->scene->r.efra - seq->scene->r.sfra + 1;
642                 seq->len -= seq->anim_startofs;
643                 seq->len -= seq->anim_endofs;
644                 if (seq->len < 0) {
645                         seq->len = 0;
646                 }
647                 seq->strip->len = seq->len;
648         }
649
650         free_proxy_seq(seq);
651
652         if(lock_range) {
653                 seq_tx_set_final_left(seq, prev_startdisp);
654                 seq_tx_set_final_right(seq, prev_enddisp);
655                 seq_single_fix(seq);
656         }
657         
658         calc_sequence(scene, seq);
659 }
660
661 void sort_seq(Scene *scene)
662 {
663         /* all strips together per kind, and in order of y location ("machine") */
664         ListBase seqbase, effbase;
665         Editing *ed= seq_give_editing(scene, FALSE);
666         Sequence *seq, *seqt;
667
668         
669         if(ed==NULL) return;
670
671         seqbase.first= seqbase.last= 0;
672         effbase.first= effbase.last= 0;
673
674         while( (seq= ed->seqbasep->first) ) {
675                 BLI_remlink(ed->seqbasep, seq);
676
677                 if(seq->type & SEQ_EFFECT) {
678                         seqt= effbase.first;
679                         while(seqt) {
680                                 if(seqt->machine>=seq->machine) {
681                                         BLI_insertlinkbefore(&effbase, seqt, seq);
682                                         break;
683                                 }
684                                 seqt= seqt->next;
685                         }
686                         if(seqt==0) BLI_addtail(&effbase, seq);
687                 }
688                 else {
689                         seqt= seqbase.first;
690                         while(seqt) {
691                                 if(seqt->machine>=seq->machine) {
692                                         BLI_insertlinkbefore(&seqbase, seqt, seq);
693                                         break;
694                                 }
695                                 seqt= seqt->next;
696                         }
697                         if(seqt==0) BLI_addtail(&seqbase, seq);
698                 }
699         }
700
701         addlisttolist(&seqbase, &effbase);
702         *(ed->seqbasep)= seqbase;
703 }
704
705
706 static int clear_scene_in_allseqs_cb(Sequence *seq, void *arg_pt)
707 {
708         if(seq->scene==(Scene *)arg_pt)
709                 seq->scene= NULL;
710         return 1;
711 }
712
713 void clear_scene_in_allseqs(Main *bmain, Scene *scene)
714 {
715         Scene *scene_iter;
716
717         /* when a scene is deleted: test all seqs */
718         for(scene_iter= bmain->scene.first; scene_iter; scene_iter= scene_iter->id.next) {
719                 if(scene_iter != scene && scene_iter->ed) {
720                         seqbase_recursive_apply(&scene_iter->ed->seqbase, clear_scene_in_allseqs_cb, scene);
721                 }
722         }
723 }
724
725 typedef struct SeqUniqueInfo {
726         Sequence *seq;
727         char name_src[32];
728         char name_dest[32];
729         int count;
730         int match;
731 } SeqUniqueInfo;
732
733 /*
734 static void seqbase_unique_name(ListBase *seqbasep, Sequence *seq)
735 {
736          BLI_uniquename(seqbasep, seq, "Sequence", '.', offsetof(Sequence, name), SEQ_NAME_MAXSTR);
737 }*/
738
739 static void seqbase_unique_name(ListBase *seqbasep, SeqUniqueInfo *sui)
740 {
741         Sequence *seq;
742         for(seq=seqbasep->first; seq; seq= seq->next) {
743                 if (sui->seq != seq && strcmp(sui->name_dest, seq->name+2)==0) {
744                         sprintf(sui->name_dest, "%.17s.%03d",  sui->name_src, sui->count++); /*24 - 2 for prefix, -1 for \0 */
745                         sui->match= 1; /* be sure to re-scan */
746                 }
747         }
748 }
749
750 static int seqbase_unique_name_recursive_cb(Sequence *seq, void *arg_pt)
751 {
752         if(seq->seqbase.first)
753                 seqbase_unique_name(&seq->seqbase, (SeqUniqueInfo *)arg_pt);
754         return 1;
755 }
756
757 void seqbase_unique_name_recursive(ListBase *seqbasep, struct Sequence *seq)
758 {
759         SeqUniqueInfo sui;
760         char *dot;
761         sui.seq= seq;
762         strcpy(sui.name_src, seq->name+2);
763         strcpy(sui.name_dest, seq->name+2);
764
765         sui.count= 1;
766         sui.match= 1; /* assume the worst to start the loop */
767
768         /* Strip off the suffix */
769         if ((dot=strrchr(sui.name_src, '.'))) {
770                 *dot= '\0';
771                 dot++;
772
773                 if(*dot)
774                         sui.count= atoi(dot) + 1;
775         }
776
777         while(sui.match) {
778                 sui.match= 0;
779                 seqbase_unique_name(seqbasep, &sui);
780                 seqbase_recursive_apply(seqbasep, seqbase_unique_name_recursive_cb, &sui);
781         }
782
783         strcpy(seq->name+2, sui.name_dest);
784 }
785
786 static char *give_seqname_by_type(int type)
787 {
788         switch(type) {
789         case SEQ_META:       return "Meta";
790         case SEQ_IMAGE:      return "Image";
791         case SEQ_SCENE:      return "Scene";
792         case SEQ_MOVIE:      return "Movie";
793         case SEQ_SOUND:      return "Audio";
794         case SEQ_CROSS:      return "Cross";
795         case SEQ_GAMCROSS:   return "Gamma Cross";
796         case SEQ_ADD:        return "Add";
797         case SEQ_SUB:        return "Sub";
798         case SEQ_MUL:        return "Mul";
799         case SEQ_ALPHAOVER:  return "Alpha Over";
800         case SEQ_ALPHAUNDER: return "Alpha Under";
801         case SEQ_OVERDROP:   return "Over Drop";
802         case SEQ_WIPE:       return "Wipe";
803         case SEQ_GLOW:       return "Glow";
804         case SEQ_TRANSFORM:  return "Transform";
805         case SEQ_COLOR:      return "Color";
806         case SEQ_MULTICAM:   return "Multicam";
807         case SEQ_SPEED:      return "Speed";
808         default:
809                 return 0;
810         }
811 }
812
813 char *give_seqname(Sequence *seq)
814 {
815         char * name = give_seqname_by_type(seq->type);
816
817         if (!name) {
818                 if(seq->type<SEQ_EFFECT) {
819                         return seq->strip->dir;
820                 } else if(seq->type==SEQ_PLUGIN) {
821                         if(!(seq->flag & SEQ_EFFECT_NOT_LOADED) &&
822                            seq->plugin && seq->plugin->doit) {
823                                 return seq->plugin->pname;
824                         } else {
825                                 return "Plugin";
826                         }
827                 } else {
828                         return "Effect";
829                 }
830         }
831         return name;
832 }
833
834 /* ***************** DO THE SEQUENCE ***************** */
835
836 static void make_black_ibuf(ImBuf *ibuf)
837 {
838         unsigned int *rect;
839         float *rect_float;
840         int tot;
841
842         if(ibuf==0 || (ibuf->rect==0 && ibuf->rect_float==0)) return;
843
844         tot= ibuf->x*ibuf->y;
845
846         rect= ibuf->rect;
847         rect_float = ibuf->rect_float;
848
849         if (rect) {
850                 memset(rect,       0, tot * sizeof(char) * 4);
851         }
852
853         if (rect_float) {
854                 memset(rect_float, 0, tot * sizeof(float) * 4);
855         }
856 }
857
858 static void multibuf(ImBuf *ibuf, float fmul)
859 {
860         char *rt;
861         float *rt_float;
862
863         int a, mul, icol;
864
865         mul= (int)(256.0*fmul);
866         rt= (char *)ibuf->rect;
867         rt_float = ibuf->rect_float;
868
869         if (rt) {
870                 a= ibuf->x*ibuf->y;
871                 while(a--) {
872
873                         icol= (mul*rt[0])>>8;
874                         if(icol>254) rt[0]= 255; else rt[0]= icol;
875                         icol= (mul*rt[1])>>8;
876                         if(icol>254) rt[1]= 255; else rt[1]= icol;
877                         icol= (mul*rt[2])>>8;
878                         if(icol>254) rt[2]= 255; else rt[2]= icol;
879                         icol= (mul*rt[3])>>8;
880                         if(icol>254) rt[3]= 255; else rt[3]= icol;
881                         
882                         rt+= 4;
883                 }
884         }
885         if (rt_float) {
886                 a= ibuf->x*ibuf->y;
887                 while(a--) {
888                         rt_float[0] *= fmul;
889                         rt_float[1] *= fmul;
890                         rt_float[2] *= fmul;
891                         rt_float[3] *= fmul;
892                         
893                         rt_float += 4;
894                 }
895         }
896 }
897
898 static float give_stripelem_index(Sequence *seq, float cfra)
899 {
900         float nr;
901
902         if(seq->len == 0) return -1;
903         if(seq->flag&SEQ_REVERSE_FRAMES) {      
904                 /*reverse frame in this sequence */
905                 if(cfra <= seq->start) nr= seq->len-1;
906                 else if(cfra >= seq->start+seq->len-1) nr= 0;
907                 else nr= (seq->start + seq->len - 1) - cfra;
908         } else {
909                 if(cfra <= seq->start) nr= 0;
910                 else if(cfra >= seq->start+seq->len-1) nr= seq->len-1;
911                 else nr= cfra-seq->start;
912         }
913         if (seq->strobe < 1.0) seq->strobe = 1.0;
914         if (seq->strobe > 1.0) {
915                 nr -= fmod((double)nr, (double)seq->strobe);
916         }
917
918         return nr;
919 }
920
921 StripElem *give_stripelem(Sequence *seq, int cfra)
922 {
923         StripElem *se= seq->strip->stripdata;
924
925         if(seq->type == SEQ_MOVIE) {
926                 /* use the first */
927         }
928         else {
929                 int nr = (int) give_stripelem_index(seq, cfra);
930
931                 if (nr == -1) return 0;
932                 if (se == 0) return 0;
933         
934                 se += nr + seq->anim_startofs;
935         }
936         return se;
937 }
938
939 static int evaluate_seq_frame_gen(Sequence ** seq_arr, ListBase *seqbase, int cfra)
940 {
941         Sequence *seq;
942         int totseq=0;
943
944         memset(seq_arr, 0, sizeof(Sequence*) * (MAXSEQ+1));
945
946         seq= seqbase->first;
947         while(seq) {
948                 if(seq->startdisp <=cfra && seq->enddisp > cfra) {
949                         seq_arr[seq->machine]= seq;
950                         totseq++;
951                 }
952                 seq= seq->next;
953         }
954
955         return totseq;
956 }
957
958 int evaluate_seq_frame(Scene *scene, int cfra)
959 {
960         Editing *ed= seq_give_editing(scene, FALSE);
961         Sequence *seq_arr[MAXSEQ+1];
962
963         if(ed==NULL) return 0;
964         return evaluate_seq_frame_gen(seq_arr, ed->seqbasep, cfra);
965 }
966
967 static int video_seq_is_rendered(Sequence * seq)
968 {
969         return (seq
970                 && !(seq->flag & SEQ_MUTE)
971                 && seq->type != SEQ_SOUND);
972 }
973
974 static int get_shown_sequences( ListBase * seqbasep, int cfra, int chanshown, Sequence ** seq_arr_out)
975 {
976         Sequence *seq_arr[MAXSEQ+1];
977         int b = chanshown;
978         int cnt = 0;
979
980         if (b > MAXSEQ) {
981                 return 0;
982         }
983
984         if(evaluate_seq_frame_gen(seq_arr, seqbasep, cfra)) {
985                 if (b > 0) {
986                         if (seq_arr[b] == 0) {
987                                 return 0;
988                         }
989                 } else {
990                         for (b = MAXSEQ; b > 0; b--) {
991                                 if (video_seq_is_rendered(seq_arr[b])) {
992                                         break;
993                                 }
994                         }
995                 }
996         }
997         
998         chanshown = b;
999
1000         for (;b > 0; b--) {
1001                 if (video_seq_is_rendered(seq_arr[b])) {
1002                         if (seq_arr[b]->blend_mode == SEQ_BLEND_REPLACE) {
1003                                 break;
1004                         }
1005                 }
1006         }
1007
1008         for (;b <= chanshown && b >= 0; b++) {
1009                 if (video_seq_is_rendered(seq_arr[b])) {
1010                         seq_arr_out[cnt++] = seq_arr[b];
1011                 }
1012         }
1013
1014         return cnt;
1015 }
1016  
1017
1018 /* **********************************************************************
1019    proxy management
1020    ********************************************************************** */
1021
1022 #define PROXY_MAXFILE (2*FILE_MAXDIR+FILE_MAXFILE)
1023
1024 static int seq_proxy_get_fname(Scene *UNUSED(scene), Sequence * seq, int cfra, char * name, int render_size)
1025 {
1026         int frameno;
1027         char dir[FILE_MAXDIR];
1028
1029         if (!seq->strip->proxy) {
1030                 return FALSE;
1031         }
1032
1033         if ((seq->flag & SEQ_USE_PROXY_CUSTOM_DIR)
1034             || (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE)) {
1035                 strcpy(dir, seq->strip->proxy->dir);
1036         } else {
1037                 if (seq->type == SEQ_IMAGE || seq->type == SEQ_MOVIE) {
1038                         snprintf(dir, FILE_MAXDIR, "%s/BL_proxy", 
1039                                  seq->strip->dir);
1040                 } else {
1041                         return FALSE;
1042                 }
1043         }
1044
1045         if (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE) {
1046                 BLI_join_dirfile(name, dir, seq->strip->proxy->file);
1047                 BLI_path_abs(name, G.main->name);
1048
1049                 return TRUE;
1050         }
1051
1052         /* generate a separate proxy directory for each preview size */
1053
1054         if (seq->type == SEQ_IMAGE) {
1055                 StripElem * se = give_stripelem(seq, cfra);
1056                 snprintf(name, PROXY_MAXFILE, "%s/images/%d/%s_proxy",
1057                          dir, render_size, se->name);
1058                 frameno = 1;
1059         } else if (seq->type == SEQ_MOVIE) {
1060                 frameno = (int) give_stripelem_index(seq, cfra) 
1061                         + seq->anim_startofs;
1062
1063                 snprintf(name, PROXY_MAXFILE, "%s/%s/%d/####", dir,
1064                          seq->strip->stripdata->name,
1065                          render_size);
1066         } else {
1067                 frameno = (int) give_stripelem_index(seq, cfra) 
1068                         + seq->anim_startofs;
1069
1070                 snprintf(name, PROXY_MAXFILE, "%s/proxy_misc/%d/####", dir,
1071                          render_size);
1072         }
1073
1074         BLI_path_abs(name, G.main->name);
1075         BLI_path_frame(name, frameno, 0);
1076
1077
1078         strcat(name, ".jpg");
1079
1080         return TRUE;
1081 }
1082
1083 static struct ImBuf * seq_proxy_fetch(Scene *scene, Sequence * seq, int cfra, int render_size)
1084 {
1085         char name[PROXY_MAXFILE];
1086
1087         if (!(seq->flag & SEQ_USE_PROXY)) {
1088                 return 0;
1089         }
1090
1091         /* rendering at 100% ? No real sense in proxy-ing, right? */
1092         if (render_size == 100) {
1093                 return 0;
1094         }
1095
1096         if (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE) {
1097                 int frameno = (int) give_stripelem_index(seq, cfra) 
1098                         + seq->anim_startofs;
1099                 if (!seq->strip->proxy->anim) {
1100                         if (!seq_proxy_get_fname(
1101                                     scene, seq, cfra, name, render_size)) {
1102                                 return 0;
1103                         }
1104  
1105                         seq->strip->proxy->anim = openanim(name, IB_rect);
1106                 }
1107                 if (!seq->strip->proxy->anim) {
1108                         return 0;
1109                 }
1110  
1111                 return IMB_anim_absolute(seq->strip->proxy->anim, frameno);
1112         }
1113  
1114         if (!seq_proxy_get_fname(scene, seq, cfra, name, render_size)) {
1115                 return 0;
1116         }
1117
1118         if (BLI_exists(name)) {
1119                 return IMB_loadiffname(name, IB_rect);
1120         } else {
1121                 return 0;
1122         }
1123 }
1124
1125 #if 0
1126 static void do_build_seq_ibuf(Scene *scene, Sequence * seq, TStripElem *se, int cfra,
1127                                   int build_proxy_run, int render_size);
1128
1129 static void seq_proxy_build_frame(Scene *scene, Sequence * seq, int cfra, int render_size, int seqrectx, int seqrecty)
1130 {
1131         char name[PROXY_MAXFILE];
1132         int quality;
1133         TStripElem * se;
1134         int ok;
1135         int rectx, recty;
1136         struct ImBuf * ibuf;
1137
1138         if (!(seq->flag & SEQ_USE_PROXY)) {
1139                 return;
1140         }
1141
1142         /* rendering at 100% ? No real sense in proxy-ing, right? */
1143         if (render_size == 100) {
1144                 return;
1145         }
1146
1147         /* that's why it is called custom... */
1148         if (seq->flag & SEQ_USE_PROXY_CUSTOM_FILE) {
1149                 return;
1150         }
1151
1152         if (!seq_proxy_get_fname(scene, seq, cfra, name, render_size)) {
1153                 return;
1154         }
1155
1156         se = give_tstripelem(seq, cfra);
1157         if (!se) {
1158                 return;
1159         }
1160
1161         if(se->ibuf) {
1162                 IMB_freeImBuf(se->ibuf);
1163                 se->ibuf = 0;
1164         }
1165         
1166         do_build_seq_ibuf(scene, seq, se, cfra, TRUE, render_size,
1167                           seqrectx, seqrecty);
1168
1169         if (!se->ibuf) {
1170                 return;
1171         }
1172
1173         rectx= (render_size*scene->r.xsch)/100;
1174         recty= (render_size*scene->r.ysch)/100;
1175
1176         ibuf = se->ibuf;
1177
1178         if (ibuf->x != rectx || ibuf->y != recty) {
1179                 IMB_scalefastImBuf(ibuf, (short)rectx, (short)recty);
1180         }
1181
1182         /* quality is fixed, otherwise one has to generate separate
1183            directories for every quality...
1184
1185            depth = 32 is intentionally left in, otherwise ALPHA channels
1186            won't work... */
1187         quality = seq->strip->proxy->quality;
1188         ibuf->ftype= JPG | quality;
1189
1190         BLI_make_existing_file(name);
1191         
1192         ok = IMB_saveiff(ibuf, name, IB_rect | IB_zbuf | IB_zbuffloat);
1193         if (ok == 0) {
1194                 perror(name);
1195         }
1196
1197         IMB_freeImBuf(ibuf);
1198         se->ibuf = 0;
1199 }
1200
1201 static void seq_proxy_rebuild(Scene *scene, Sequence * seq, int seqrectx,
1202                               int seqrecty)
1203 {
1204         int cfra;
1205         float rsize = seq->strip->proxy->size;
1206
1207         waitcursor(1);
1208
1209         G.afbreek = 0;
1210
1211         /* flag management tries to account for strobe and 
1212            other "non-linearities", that might come in the future...
1213            better way would be to "touch" the files, so that _really_
1214            no one is rebuild twice.
1215          */
1216
1217         for (cfra = seq->startdisp; cfra < seq->enddisp; cfra++) {
1218                 TStripElem * tse = give_tstripelem(seq, cfra);
1219
1220                 tse->flag &= ~STRIPELEM_PREVIEW_DONE;
1221         }
1222
1223         
1224
1225         /* a _lot_ faster for movie files, if we read frames in
1226            sequential order */
1227         if (seq->flag & SEQ_REVERSE_FRAMES) {
1228                 for (cfra = seq->enddisp-seq->endstill-1; 
1229                          cfra >= seq->startdisp + seq->startstill; cfra--) {
1230                         TStripElem * tse = give_tstripelem(seq, cfra);
1231
1232                         if (!(tse->flag & STRIPELEM_PREVIEW_DONE)) {
1233 //XXX                           set_timecursor(cfra);
1234                                 seq_proxy_build_frame(scene, seq, cfra, rsize,
1235                                                       seqrectx, seqrecty);
1236                                 tse->flag |= STRIPELEM_PREVIEW_DONE;
1237                         }
1238                         if (blender_test_break()) {
1239                                 break;
1240                         }
1241                 }
1242         } else {
1243                 for (cfra = seq->startdisp + seq->startstill; 
1244                          cfra < seq->enddisp - seq->endstill; cfra++) {
1245                         TStripElem * tse = give_tstripelem(seq, cfra);
1246
1247                         if (!(tse->flag & STRIPELEM_PREVIEW_DONE)) {
1248 //XXX                           set_timecursor(cfra);
1249                                 seq_proxy_build_frame(scene, seq, cfra, rsize,
1250                                                       seqrectx, seqrecty);
1251                                 tse->flag |= STRIPELEM_PREVIEW_DONE;
1252                         }
1253                         if (blender_test_break()) {
1254                                 break;
1255                         }
1256                 }
1257         }
1258         waitcursor(0);
1259 }
1260 #endif
1261
1262
1263 /* **********************************************************************
1264    color balance 
1265    ********************************************************************** */
1266
1267 static StripColorBalance calc_cb(StripColorBalance * cb_)
1268 {
1269         StripColorBalance cb = *cb_;
1270         int c;
1271
1272         for (c = 0; c < 3; c++) {
1273                 cb.lift[c] = 2.0f - cb.lift[c];
1274         }
1275
1276         if(cb.flag & SEQ_COLOR_BALANCE_INVERSE_LIFT) {
1277                 for (c = 0; c < 3; c++) {
1278                         /* tweak to give more subtle results
1279                          * values above 1.0 are scaled */
1280                         if(cb.lift[c] > 1.0f)
1281                                 cb.lift[c] = pow(cb.lift[c] - 1.0f, 2.0f) + 1.0f;
1282
1283                         cb.lift[c] = 2.0f - cb.lift[c];
1284                 }
1285         }
1286
1287         if (cb.flag & SEQ_COLOR_BALANCE_INVERSE_GAIN) {
1288                 for (c = 0; c < 3; c++) {
1289                         if (cb.gain[c] != 0.0) {
1290                                 cb.gain[c] = 1.0/cb.gain[c];
1291                         } else {
1292                                 cb.gain[c] = 1000000; /* should be enough :) */
1293                         }
1294                 }
1295         }
1296
1297         if (!(cb.flag & SEQ_COLOR_BALANCE_INVERSE_GAMMA)) {
1298                 for (c = 0; c < 3; c++) {
1299                         if (cb.gamma[c] != 0.0) {
1300                                 cb.gamma[c] = 1.0/cb.gamma[c];
1301                         } else {
1302                                 cb.gamma[c] = 1000000; /* should be enough :) */
1303                         }
1304                 }
1305         }
1306
1307         return cb;
1308 }
1309
1310 /* note: lift is actually 2-lift */
1311 MINLINE float color_balance_fl(float in, const float lift, const float gain, const float gamma, const float mul)
1312 {
1313         float x= (((in - 1.0f) * lift) + 1.0f) * gain;
1314
1315         /* prevent NaN */
1316         if (x < 0.f) x = 0.f;
1317
1318         return powf(x, gamma) * mul;
1319 }
1320
1321 static void make_cb_table_byte(float lift, float gain, float gamma,
1322                                    unsigned char * table, float mul)
1323 {
1324         int y;
1325
1326         for (y = 0; y < 256; y++) {
1327                 float v= color_balance_fl((float)y * (1.0 / 255.0f), lift, gain, gamma, mul);
1328                 CLAMP(v, 0.0f, 1.0f);
1329                 table[y] = v * 255;
1330         }
1331 }
1332
1333 static void make_cb_table_float(float lift, float gain, float gamma,
1334                                 float * table, float mul)
1335 {
1336         int y;
1337
1338         for (y = 0; y < 256; y++) {
1339                 float v= color_balance_fl((float)y * (1.0 / 255.0f), lift, gain, gamma, mul);
1340                 table[y] = v;
1341         }
1342 }
1343
1344 static void color_balance_byte_byte(Sequence * seq, ImBuf* ibuf, float mul)
1345 {
1346         unsigned char cb_tab[3][256];
1347         int c;
1348         unsigned char * p = (unsigned char*) ibuf->rect;
1349         unsigned char * e = p + ibuf->x * 4 * ibuf->y;
1350
1351         StripColorBalance cb = calc_cb(seq->strip->color_balance);
1352
1353         for (c = 0; c < 3; c++) {
1354                 make_cb_table_byte(cb.lift[c], cb.gain[c], cb.gamma[c],
1355                                    cb_tab[c], mul);
1356         }
1357
1358         while (p < e) {
1359                 p[0] = cb_tab[0][p[0]];
1360                 p[1] = cb_tab[1][p[1]];
1361                 p[2] = cb_tab[2][p[2]];
1362                 
1363                 p += 4;
1364         }
1365 }
1366
1367 static void color_balance_byte_float(Sequence * seq, ImBuf* ibuf, float mul)
1368 {
1369         float cb_tab[4][256];
1370         int c,i;
1371         unsigned char * p = (unsigned char*) ibuf->rect;
1372         unsigned char * e = p + ibuf->x * 4 * ibuf->y;
1373         float * o;
1374         StripColorBalance cb;
1375
1376         imb_addrectfloatImBuf(ibuf);
1377
1378         o = ibuf->rect_float;
1379
1380         cb = calc_cb(seq->strip->color_balance);
1381
1382         for (c = 0; c < 3; c++) {
1383                 make_cb_table_float(cb.lift[c], cb.gain[c], cb.gamma[c],
1384                                     cb_tab[c], mul);
1385         }
1386
1387         for (i = 0; i < 256; i++) {
1388                 cb_tab[3][i] = ((float)i)*(1.0f/255.0f);
1389         }
1390
1391         while (p < e) {
1392                 o[0] = cb_tab[0][p[0]];
1393                 o[1] = cb_tab[1][p[1]];
1394                 o[2] = cb_tab[2][p[2]];
1395                 o[3] = cb_tab[3][p[3]];
1396
1397                 p += 4; o += 4;
1398         }
1399 }
1400
1401 static void color_balance_float_float(Sequence * seq, ImBuf* ibuf, float mul)
1402 {
1403         float * p = ibuf->rect_float;
1404         float * e = ibuf->rect_float + ibuf->x * 4* ibuf->y;
1405         StripColorBalance cb = calc_cb(seq->strip->color_balance);
1406
1407         while (p < e) {
1408                 int c;
1409                 for (c = 0; c < 3; c++) {
1410                         p[c]= color_balance_fl(p[c], cb.lift[c], cb.gain[c], cb.gamma[c], mul);
1411                 }
1412                 p += 4;
1413         }
1414 }
1415
1416 static void color_balance(Sequence * seq, ImBuf* ibuf, float mul)
1417 {
1418         if (ibuf->rect_float) {
1419                 color_balance_float_float(seq, ibuf, mul);
1420         } else if(seq->flag & SEQ_MAKE_FLOAT) {
1421                 color_balance_byte_float(seq, ibuf, mul);
1422         } else {
1423                 color_balance_byte_byte(seq, ibuf, mul);
1424         }
1425 }
1426
1427 /*
1428   input preprocessing for SEQ_IMAGE, SEQ_MOVIE and SEQ_SCENE
1429
1430   Do all the things you can't really do afterwards using sequence effects
1431   (read: before rescaling to render resolution has been done)
1432
1433   Order is important!
1434
1435   - Deinterlace
1436   - Crop and transform in image source coordinate space
1437   - Flip X + Flip Y (could be done afterwards, backward compatibility)
1438   - Promote image to float data (affects pipeline operations afterwards)
1439   - Color balance (is most efficient in the byte -> float 
1440         (future: half -> float should also work fine!)
1441         case, if done on load, since we can use lookup tables)
1442   - Premultiply
1443
1444 */
1445
1446 int input_have_to_preprocess(
1447         Scene *UNUSED(scene), Sequence * seq, float UNUSED(cfra), int UNUSED(seqrectx), int UNUSED(seqrecty))
1448 {
1449         float mul;
1450
1451         if ((seq->flag & SEQ_FILTERY) || 
1452             (seq->flag & SEQ_USE_CROP) ||
1453             (seq->flag & SEQ_USE_TRANSFORM) ||
1454             (seq->flag & SEQ_FLIPX) ||
1455             (seq->flag & SEQ_FLIPY) ||
1456             (seq->flag & SEQ_USE_COLOR_BALANCE) ||
1457             (seq->flag & SEQ_MAKE_PREMUL)) {
1458                 return TRUE;
1459         }
1460
1461         mul = seq->mul;
1462
1463         if(seq->blend_mode == SEQ_BLEND_REPLACE) {
1464                 mul *= seq->blend_opacity / 100.0;
1465         }
1466
1467         if (mul != 1.0) {
1468                 return TRUE;
1469         }
1470
1471         if (seq->sat != 1.0) {
1472                 return TRUE;
1473         }
1474                 
1475         return FALSE;
1476 }
1477
1478 static ImBuf * input_preprocess(
1479         Scene *scene, Sequence *seq, float UNUSED(cfra), int seqrectx, int seqrecty,
1480         ImBuf * ibuf)
1481 {
1482         float mul;
1483
1484         seq->strip->orx= ibuf->x;
1485         seq->strip->ory= ibuf->y;
1486
1487         if((seq->flag & SEQ_FILTERY) && seq->type != SEQ_MOVIE) {
1488                 IMB_filtery(ibuf);
1489         }
1490
1491         if(seq->flag & SEQ_USE_CROP || seq->flag & SEQ_USE_TRANSFORM) {
1492                 StripCrop c;
1493                 StripTransform t;
1494                 int sx,sy,dx,dy;
1495
1496                 memset(&c, 0, sizeof(StripCrop));
1497                 memset(&t, 0, sizeof(StripTransform));
1498
1499                 if(seq->flag & SEQ_USE_CROP && seq->strip->crop) {
1500                         c = *seq->strip->crop;
1501                 }
1502                 if(seq->flag & SEQ_USE_TRANSFORM && seq->strip->transform) {
1503                         t = *seq->strip->transform;
1504                 }
1505
1506                 sx = ibuf->x - c.left - c.right;
1507                 sy = ibuf->y - c.top - c.bottom;
1508                 dx = sx;
1509                 dy = sy;
1510
1511                 if (seq->flag & SEQ_USE_TRANSFORM) {
1512                         dx = scene->r.xsch;
1513                         dy = scene->r.ysch;
1514                 }
1515
1516                 if (c.top + c.bottom >= ibuf->y ||
1517                         c.left + c.right >= ibuf->x ||
1518                         t.xofs >= dx || t.yofs >= dy) {
1519                         make_black_ibuf(ibuf);
1520                 } else {
1521                         ImBuf * i;
1522
1523                         if (ibuf->rect_float) {
1524                                 i = IMB_allocImBuf(dx, dy,32, IB_rectfloat);
1525                         } else {
1526                                 i = IMB_allocImBuf(dx, dy,32, IB_rect);
1527                         }
1528
1529                         IMB_rectcpy(i, ibuf, 
1530                                     t.xofs, t.yofs, 
1531                                     c.left, c.bottom, 
1532                                     sx, sy);
1533                         
1534                         IMB_freeImBuf(ibuf);
1535
1536                         ibuf = i;
1537                 }
1538         } 
1539
1540         if(seq->flag & SEQ_FLIPX) {
1541                 IMB_flipx(ibuf);
1542         }
1543         
1544         if(seq->flag & SEQ_FLIPY) {
1545                 IMB_flipy(ibuf);
1546         }
1547
1548         if(seq->sat != 1.0f) {
1549                 /* inline for now, could become an imbuf function */
1550                 int i;
1551                 char *rct= (char *)ibuf->rect;
1552                 float *rctf= ibuf->rect_float;
1553                 const float sat= seq->sat;
1554                 float hsv[3];
1555
1556                 if(rct) {
1557                         float rgb[3];
1558                         for (i = ibuf->x * ibuf->y; i > 0; i--, rct+=4) {
1559                                 rgb_byte_to_float(rct, rgb);
1560                                 rgb_to_hsv(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2);
1561                                 hsv_to_rgb(hsv[0], hsv[1] * sat, hsv[2], rgb, rgb+1, rgb+2);
1562                                 rgb_float_to_byte(rgb, rct);
1563                         }
1564                 }
1565
1566                 if(rctf) {
1567                         for (i = ibuf->x * ibuf->y; i > 0; i--, rctf+=4) {
1568                                 rgb_to_hsv(rctf[0], rctf[1], rctf[2], hsv, hsv+1, hsv+2);
1569                                 hsv_to_rgb(hsv[0], hsv[1] * sat, hsv[2], rctf, rctf+1, rctf+2);
1570                         }
1571                 }
1572         }
1573
1574         mul = seq->mul;
1575
1576         if(seq->blend_mode == SEQ_BLEND_REPLACE) {
1577                 mul *= seq->blend_opacity / 100.0;
1578         }
1579
1580         if(seq->flag & SEQ_USE_COLOR_BALANCE && seq->strip->color_balance) {
1581                 color_balance(seq, ibuf, mul);
1582                 mul = 1.0;
1583         }
1584
1585         if(seq->flag & SEQ_MAKE_FLOAT) {
1586                 if (!ibuf->rect_float)
1587                         IMB_float_from_rect_simple(ibuf);
1588
1589                 if (ibuf->rect) {
1590                         imb_freerectImBuf(ibuf);
1591                 }
1592         }
1593
1594         if(mul != 1.0) {
1595                 multibuf(ibuf, mul);
1596         }
1597
1598         if(seq->flag & SEQ_MAKE_PREMUL) {
1599                 if(ibuf->depth == 32 && ibuf->zbuf == 0) {
1600                         IMB_premultiply_alpha(ibuf);
1601                 }
1602         }
1603
1604
1605         if(ibuf->x != seqrectx || ibuf->y != seqrecty ) {
1606                 if(scene->r.mode & R_OSA) {
1607                         IMB_scaleImBuf(ibuf, 
1608                                        (short)seqrectx, (short)seqrecty);
1609                 } else {
1610                         IMB_scalefastImBuf(ibuf, 
1611                                            (short)seqrectx, (short)seqrecty);
1612                 }
1613         }
1614         return ibuf;
1615 }
1616
1617 static ImBuf * copy_from_ibuf_still(Sequence * seq, float nr,
1618                                     int seqrectx, int seqrecty)
1619 {
1620         ImBuf * rval = 0;
1621         ImBuf * ibuf = 0;
1622
1623         if (nr == 0) {
1624                 ibuf = seq_stripelem_cache_get(
1625                         seq, seqrectx, seqrecty, seq->start, 
1626                         SEQ_STRIPELEM_IBUF_STARTSTILL);
1627         }
1628         if (nr == seq->len - 1) {
1629                 ibuf = seq_stripelem_cache_get(
1630                         seq, seqrectx, seqrecty, seq->start, 
1631                         SEQ_STRIPELEM_IBUF_ENDSTILL);
1632         }
1633
1634         if (ibuf) {
1635                 rval = IMB_dupImBuf(ibuf);
1636                 IMB_freeImBuf(ibuf);
1637         }
1638
1639         return rval;
1640 }
1641
1642 static void copy_to_ibuf_still(Sequence * seq, float nr,
1643                                ImBuf * ibuf)
1644 {
1645         if (nr == 0) {
1646                 seq_stripelem_cache_put(
1647                         seq, 0, 0, seq->start, 
1648                         SEQ_STRIPELEM_IBUF_STARTSTILL, ibuf);
1649         }
1650         if (nr == seq->len - 1) {
1651                 seq_stripelem_cache_put(
1652                         seq, 0, 0, seq->start, 
1653                         SEQ_STRIPELEM_IBUF_ENDSTILL, ibuf);
1654         }
1655 }
1656
1657 /* **********************************************************************
1658    strip rendering functions
1659    ********************************************************************** */
1660
1661 static ImBuf* seq_render_strip_stack(
1662         Main *bmain, Scene *scene,
1663         ListBase *seqbasep, float cfra, int chanshown, int render_size,
1664         int seqrectx, int seqrecty);
1665
1666 static ImBuf * seq_render_strip(Main *bmain, Scene *scene, Sequence * seq, float cfra,
1667                                 int render_size, 
1668                                 int seqrectx, int seqrecty);
1669
1670
1671 static ImBuf* seq_render_effect_strip_impl(
1672         Main *bmain, Scene *scene, float cfra, Sequence *seq, int render_size,
1673         int seqrectx, int seqrecty)
1674 {
1675         float fac, facf;
1676         int early_out;
1677         int i;
1678         int must_preprocess = FALSE;
1679
1680         struct SeqEffectHandle sh = get_sequence_effect(seq);
1681         FCurve *fcu= NULL;
1682         ImBuf * ibuf[3];
1683         ImBuf * out = 0;
1684
1685         ibuf[0] = ibuf[1] = ibuf[2] = 0;
1686
1687         if (!sh.execute) { /* effect not supported in this version... */
1688                 goto finish;
1689         }
1690
1691         if ((seq->flag & SEQ_USE_EFFECT_DEFAULT_FADE) != 0) {
1692                 sh.get_default_fac(seq, cfra, &fac, &facf);
1693                 if( scene->r.mode & R_FIELDS ); else facf= fac;
1694         } else {
1695                 fcu = id_data_find_fcurve(&scene->id, seq, &RNA_Sequence, 
1696                                           "effect_fader", 0);
1697                 if (fcu) {
1698                         fac = facf = evaluate_fcurve(fcu, cfra);
1699                         if( scene->r.mode & R_FIELDS ) {
1700                                 facf = evaluate_fcurve(fcu, cfra + 0.5);
1701                         }
1702                 } else {
1703                         fac = facf = seq->effect_fader;
1704                 }
1705         }
1706
1707         early_out = sh.early_out(seq, fac, facf);
1708
1709         if (early_out == -1) { /* no input needed */
1710                 out = sh.execute(bmain, scene, seq, cfra, fac, facf, 
1711                                  seqrectx, seqrecty, render_size,
1712                                  0, 0, 0);
1713                 goto finish;
1714         }
1715
1716
1717         must_preprocess = input_have_to_preprocess(
1718                 scene, seq, cfra, seqrectx, seqrecty);
1719
1720         switch (early_out) {
1721         case 0:
1722                 break;
1723         case 1:
1724                 if (seq->seq1) {
1725                         ibuf[0] = seq_render_strip(bmain, scene, seq->seq1, cfra,
1726                                                    render_size, 
1727                                                    seqrectx, seqrecty);
1728                 }
1729                 if (ibuf[0]) {
1730                         if (must_preprocess) {
1731                                 out = IMB_dupImBuf(ibuf[0]);
1732                         } else {
1733                                 out = ibuf[0];
1734                                 IMB_refImBuf(out);
1735                         }
1736                 }
1737                 goto finish;
1738         case 2:
1739                 if (seq->seq2) {
1740                         ibuf[1] = seq_render_strip(bmain, scene, seq->seq2, cfra,
1741                                                    render_size, 
1742                                                    seqrectx, seqrecty);
1743                 }
1744                 if (ibuf[1]) {
1745                         if (must_preprocess) {
1746                                 out = IMB_dupImBuf(ibuf[1]);
1747                         } else {
1748                                 out = ibuf[1];
1749                                 IMB_refImBuf(out);
1750                         }
1751                 }
1752                 goto finish;
1753         default:
1754                 goto finish;
1755         }
1756
1757         if (seq->seq1) {
1758                 ibuf[0] = seq_render_strip(bmain, scene, seq->seq1, cfra,
1759                                            render_size, 
1760                                            seqrectx, seqrecty);
1761         } 
1762
1763         if (seq->seq2) {
1764                 ibuf[1] = seq_render_strip(bmain, scene, seq->seq2, cfra,
1765                                            render_size, 
1766                                            seqrectx, seqrecty);
1767         }
1768
1769         if (seq->seq3) {
1770                 ibuf[2] = seq_render_strip(bmain, scene, seq->seq3, cfra,
1771                                            render_size, 
1772                                            seqrectx, seqrecty);
1773         }
1774
1775         if (!ibuf[0] || !ibuf[1]) {
1776                 goto finish;
1777         }
1778
1779         out = sh.execute(bmain, scene, seq, cfra, fac, facf, seqrectx, seqrecty, 
1780                          render_size,
1781                          ibuf[0], ibuf[1], ibuf[2]);
1782
1783 finish:
1784         for (i = 0; i < 3; i++) {
1785                 IMB_freeImBuf(ibuf[i]);
1786         }
1787
1788         if (!out) {
1789                 out = IMB_allocImBuf(
1790                         (short)seqrectx, (short)seqrecty, 32, IB_rect);
1791         }
1792
1793         return out;
1794 }
1795
1796
1797 static ImBuf * seq_render_scene_strip_impl(
1798         Main *bmain, Scene * scene, Sequence * seq, float nr, int seqrectx, int seqrecty)
1799 {
1800         ImBuf * ibuf = 0;
1801         float frame= seq->sfra + nr + seq->anim_startofs;
1802         float oldcfra;
1803         Object *oldcamera;
1804         ListBase oldmarkers;
1805         
1806         /* Hack! This function can be called from do_render_seq(), in that case
1807            the seq->scene can already have a Render initialized with same name,
1808            so we have to use a default name. (compositor uses scene name to
1809            find render).
1810            However, when called from within the UI (image preview in sequencer)
1811            we do want to use scene Render, that way the render result is defined
1812            for display in render/imagewindow
1813            
1814            Hmm, don't see, why we can't do that all the time,
1815            and since G.rendering is uhm, gone... (Peter)
1816         */
1817
1818         int rendering = G.rendering;
1819         int doseq;
1820         int doseq_gl= G.rendering ? /*(scene->r.seq_flag & R_SEQ_GL_REND)*/ 0 : (scene->r.seq_flag & R_SEQ_GL_PREV);
1821         int have_seq= FALSE;
1822         Scene *sce= seq->scene; /* dont refer to seq->scene above this point!, it can be NULL */
1823         int sce_valid= FALSE;
1824
1825         if(sce) {
1826                 have_seq= (sce->r.scemode & R_DOSEQ) && sce->ed && sce->ed->seqbase.first;
1827                 sce_valid= (sce->camera || have_seq);
1828         }
1829
1830         if (!sce_valid)
1831                 return NULL;
1832
1833         oldcfra= seq->scene->r.cfra;
1834         oldcamera= seq->scene->camera;
1835
1836         /* prevent eternal loop */
1837         doseq= scene->r.scemode & R_DOSEQ;
1838         scene->r.scemode &= ~R_DOSEQ;
1839         
1840         seq->scene->r.cfra= frame;
1841         if(seq->scene_camera)   
1842                 seq->scene->camera= seq->scene_camera;
1843         else    
1844                 scene_camera_switch_update(seq->scene);
1845         
1846 #ifdef DURIAN_CAMERA_SWITCH
1847         /* stooping to new low's in hackyness :( */
1848         oldmarkers= seq->scene->markers;
1849         seq->scene->markers.first= seq->scene->markers.last= NULL;
1850 #endif
1851         
1852         if(sequencer_view3d_cb && BLI_thread_is_main() && doseq_gl && (seq->scene == scene || have_seq==0) && seq->scene->camera) {
1853                 /* opengl offscreen render */
1854                 scene_update_for_newframe(bmain, seq->scene, seq->scene->lay);
1855                 ibuf= sequencer_view3d_cb(seq->scene, seqrectx, seqrecty, IB_rect,
1856                                           scene->r.seq_prev_type);
1857         }
1858         else {
1859                 Render *re;
1860                 RenderResult rres;
1861                 
1862                 if(rendering)
1863                         re= RE_NewRender(" do_build_seq_ibuf");
1864                 /* If the top level scene that does the sequencer rendering is included 
1865                  * as a strip the default render name for the strip will conflict with
1866                  * the original render, so override the name in this case.
1867                  * See bugs #22236 and #24160 for examples.
1868                  * XXX: Somebody with deeper insight to the rendering pipeline should
1869                  *      probably check if this is the best way to handle this. -jahka
1870                  */
1871                 else if(seq->scene == scene)
1872                         re= RE_NewRender("scene_conflict_render");
1873                 else
1874                         re= RE_NewRender(sce->id.name);
1875                 
1876                 RE_BlenderFrame(re, bmain, sce, NULL, sce->lay, frame);
1877                 
1878                 RE_AcquireResultImage(re, &rres);
1879                 
1880                 if(rres.rectf) {
1881                         ibuf= IMB_allocImBuf(rres.rectx, rres.recty, 32, IB_rectfloat);
1882                         memcpy(ibuf->rect_float, rres.rectf, 4*sizeof(float)*rres.rectx*rres.recty);
1883                         if(rres.rectz) {
1884                                 addzbuffloatImBuf(ibuf);
1885                                 memcpy(ibuf->zbuf_float, rres.rectz, sizeof(float)*rres.rectx*rres.recty);
1886                         }
1887
1888                         /* float buffers in the sequencer are not linear */
1889                         ibuf->profile= IB_PROFILE_LINEAR_RGB;
1890                         IMB_convert_profile(ibuf, IB_PROFILE_SRGB);                     
1891                 }
1892                 else if (rres.rect32) {
1893                         ibuf= IMB_allocImBuf(rres.rectx, rres.recty, 32, IB_rect);
1894                         memcpy(ibuf->rect, rres.rect32, 4*rres.rectx*rres.recty);
1895                 }
1896                 
1897                 RE_ReleaseResultImage(re);
1898                 
1899                 // BIF_end_render_callbacks();
1900         }
1901         
1902         /* restore */
1903         scene->r.scemode |= doseq;
1904         
1905         seq->scene->r.cfra = oldcfra;
1906         seq->scene->camera= oldcamera;
1907         
1908 #ifdef DURIAN_CAMERA_SWITCH
1909         /* stooping to new low's in hackyness :( */
1910         seq->scene->markers= oldmarkers;
1911 #endif
1912
1913         return ibuf;
1914 }
1915
1916 static ImBuf * seq_render_strip(Main *bmain, Scene *scene, Sequence * seq, float cfra,
1917                                 int render_size, 
1918                                 int seqrectx, int seqrecty)
1919 {
1920         char name[FILE_MAXDIR+FILE_MAXFILE];
1921         int use_preprocess = input_have_to_preprocess(
1922                 scene, seq, cfra, seqrectx, seqrecty);
1923         ImBuf * ibuf = seq_stripelem_cache_get(
1924                 seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF);
1925         float nr = give_stripelem_index(seq, cfra);
1926
1927         /* currently, we cache preprocessed images */
1928         if (ibuf) {
1929                 use_preprocess = FALSE;
1930         }
1931
1932         if(seq->type == SEQ_META) {
1933                 ImBuf * meta_ibuf = 0;
1934
1935                 if (ibuf == 0) {
1936                         ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
1937                 }
1938
1939                 if(!ibuf && seq->seqbase.first) {
1940                         meta_ibuf = seq_render_strip_stack(
1941                                 bmain, scene,
1942                                 &seq->seqbase, seq->start + nr, 0,
1943                                 render_size, seqrectx, seqrecty);
1944                 }
1945
1946                 if(!ibuf && meta_ibuf) {
1947                         ibuf = meta_ibuf;
1948                         if(ibuf && use_preprocess) {
1949                                 struct ImBuf * i = IMB_dupImBuf(ibuf);
1950
1951                                 IMB_freeImBuf(ibuf);
1952
1953                                 ibuf = i;
1954                         }
1955                 }
1956         } else if(seq->type == SEQ_SPEED) {
1957                 ImBuf * child_ibuf = 0;
1958
1959                 if (ibuf == 0) {
1960                         ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
1961                 }
1962
1963                 if (ibuf == 0) {
1964                         float f_cfra;
1965                         SpeedControlVars * s 
1966                                 = (SpeedControlVars *)seq->effectdata;
1967
1968                         sequence_effect_speed_rebuild_map(scene, seq, 0);
1969
1970                         /* weeek! */
1971                         f_cfra = seq->start + s->frameMap[(int) nr];
1972
1973                         child_ibuf = seq_render_strip(bmain, scene, seq->seq1, f_cfra,
1974                                                       render_size, 
1975                                                       seqrectx, seqrecty);
1976                 }
1977
1978                 if (!ibuf && child_ibuf) {
1979                         ibuf = child_ibuf;
1980                         if(ibuf && use_preprocess) {
1981                                 struct ImBuf * i = IMB_dupImBuf(ibuf);
1982
1983                                 IMB_freeImBuf(ibuf);
1984
1985                                 ibuf = i;
1986                         }
1987                 }
1988         } else if(seq->type & SEQ_EFFECT) {
1989                 /* should the effect be recalculated? */
1990                 
1991                 if (ibuf == 0) {
1992                         ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
1993                 }
1994
1995                 if(ibuf == 0) {         
1996                         ibuf = seq_render_effect_strip_impl(
1997                                 bmain, scene, cfra, seq, render_size, 
1998                                 seqrectx, seqrecty);
1999                 }
2000         } else if(seq->type == SEQ_IMAGE) {
2001                 StripElem * s_elem = give_stripelem(seq, cfra);
2002
2003                 if(ibuf == 0 && s_elem) {
2004                         BLI_join_dirfile(name, seq->strip->dir, s_elem->name);
2005                         BLI_path_abs(name, G.main->name);
2006
2007                         ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
2008                 }
2009
2010                 if (ibuf == 0) {
2011                         ibuf = copy_from_ibuf_still(seq,nr,seqrectx,seqrecty);
2012                 }
2013
2014                 if (ibuf == 0 && s_elem && 
2015                     (ibuf = IMB_loadiffname(name, IB_rect))) {
2016                         /* we don't need both (speed reasons)! */
2017                         if (ibuf->rect_float && ibuf->rect)
2018                                 imb_freerectImBuf(ibuf);
2019
2020                         /* all sequencer color is done in SRGB space, linear gives odd crossfades */
2021                         if(ibuf->profile == IB_PROFILE_LINEAR_RGB)
2022                                 IMB_convert_profile(ibuf, IB_PROFILE_NONE);
2023
2024                         copy_to_ibuf_still(seq, nr, ibuf);
2025                 }
2026         } else if(seq->type == SEQ_MOVIE) {
2027                 if(ibuf == 0) {
2028                         ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
2029                         
2030                 }
2031                 
2032                 if (ibuf == 0) {
2033                         ibuf = copy_from_ibuf_still(seq, nr,seqrectx,seqrecty);
2034                 }
2035
2036                 if (ibuf == 0) {
2037                         if(seq->anim==0) {
2038                                 BLI_join_dirfile(name, 
2039                                                  seq->strip->dir, 
2040                                                  seq->strip->stripdata->name);
2041                                 BLI_path_abs(name, G.main->name);
2042                                         
2043                                 seq->anim = openanim(
2044                                         name, IB_rect | 
2045                                         ((seq->flag & SEQ_FILTERY) 
2046                                          ? IB_animdeinterlace : 0));
2047                         }
2048                         if(seq->anim) {
2049                                 IMB_anim_set_preseek(seq->anim, 
2050                                                      seq->anim_preseek);
2051                                 ibuf = IMB_anim_absolute(seq->anim, 
2052                                                          nr 
2053                                                          + seq->anim_startofs);
2054                                 /* we don't need both (speed reasons)! */
2055                                 if (ibuf && ibuf->rect_float 
2056                                     && ibuf->rect) {
2057                                         imb_freerectImBuf(ibuf);
2058                                 }
2059
2060                         }
2061                         copy_to_ibuf_still(seq, nr, ibuf);
2062                 }
2063                         
2064         } else if(seq->type == SEQ_SCENE) {     // scene can be NULL after deletions
2065                 if (ibuf == 0) {
2066                         ibuf = seq_proxy_fetch(scene, seq, cfra, render_size);
2067                 }
2068                 if (ibuf == 0) {
2069                         ibuf = copy_from_ibuf_still(seq, nr,seqrectx,seqrecty);
2070                 }
2071                 
2072                 if (ibuf == 0) {
2073                         ibuf = seq_render_scene_strip_impl(bmain, scene, seq, nr,
2074                                                            seqrectx, seqrecty);
2075
2076                         copy_to_ibuf_still(seq, nr, ibuf);
2077                 }
2078         }
2079
2080         if (!ibuf) {
2081                 ibuf = IMB_allocImBuf(
2082                         (short)seqrectx, (short)seqrecty, 32, IB_rect);
2083         }
2084
2085         if (ibuf->x != seqrectx || ibuf->y != seqrecty) {
2086                 use_preprocess = TRUE;
2087         }
2088
2089         if (use_preprocess) {
2090                 ibuf = input_preprocess(scene, seq, cfra, seqrectx,
2091                                         seqrecty, ibuf);
2092         }
2093
2094         seq_stripelem_cache_put(
2095                 seq, seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF, ibuf);
2096
2097         return ibuf;
2098 }
2099
2100 /* **********************************************************************
2101    strip stack rendering functions
2102    ********************************************************************** */
2103
2104 static int seq_must_swap_input_in_blend_mode(Sequence * seq)
2105 {
2106         int swap_input = FALSE;
2107
2108         /* bad hack, to fix crazy input ordering of 
2109            those two effects */
2110
2111         if (seq->blend_mode == SEQ_ALPHAOVER ||
2112                 seq->blend_mode == SEQ_ALPHAUNDER ||
2113                 seq->blend_mode == SEQ_OVERDROP) {
2114                 swap_input = TRUE;
2115         }
2116         
2117         return swap_input;
2118 }
2119
2120 static int seq_get_early_out_for_blend_mode(Sequence * seq)
2121 {
2122         struct SeqEffectHandle sh = get_sequence_blend(seq);
2123         float facf = seq->blend_opacity / 100.0;
2124         int early_out = sh.early_out(seq, facf, facf);
2125         
2126         if (early_out < 1) {
2127                 return early_out;
2128         }
2129
2130         if (seq_must_swap_input_in_blend_mode(seq)) {
2131                 if (early_out == 2) {
2132                         return 1;
2133                 } else if (early_out == 1) {
2134                         return 2;
2135                 }
2136         }
2137         return early_out;
2138 }
2139
2140 static ImBuf* seq_render_strip_stack(
2141         Main *bmain, Scene *scene, ListBase *seqbasep, float cfra, int chanshown, 
2142         int render_size, int seqrectx, int seqrecty)
2143 {
2144         Sequence* seq_arr[MAXSEQ+1];
2145         int count;
2146         int i;
2147         ImBuf* out = 0;
2148
2149         count = get_shown_sequences(seqbasep, cfra, chanshown, 
2150                                     (Sequence **)&seq_arr);
2151
2152         if (!count) {
2153                 return 0;
2154         }
2155
2156 #if 0 /* commentind since this breaks keyframing, since it resets the value on draw */
2157         if(scene->r.cfra != cfra) {
2158                 // XXX for prefetch and overlay offset!..., very bad!!!
2159                 AnimData *adt= BKE_animdata_from_id(&scene->id);
2160                 BKE_animsys_evaluate_animdata(&scene->id, adt, cfra, ADT_RECALC_ANIM);
2161         }
2162 #endif
2163
2164         out = seq_stripelem_cache_get(
2165                 seq_arr[count - 1], 
2166                 seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP);
2167
2168         if (out) {
2169                 return out;
2170         }
2171         
2172         if(count == 1) {
2173                 out = seq_render_strip(bmain, scene, seq_arr[0],
2174                                         cfra, render_size,
2175                                         seqrectx, seqrecty);
2176                 seq_stripelem_cache_put(
2177                         seq_arr[0], 
2178                         seqrectx, seqrecty, cfra, 
2179                         SEQ_STRIPELEM_IBUF_COMP, out);
2180
2181                 return out;
2182         }
2183
2184
2185         for (i = count - 1; i >= 0; i--) {
2186                 int early_out;
2187                 Sequence * seq = seq_arr[i];
2188
2189                 out = seq_stripelem_cache_get(
2190                         seq, 
2191                         seqrectx, seqrecty, cfra, SEQ_STRIPELEM_IBUF_COMP);
2192
2193                 if (out) {
2194                         break;
2195                 }
2196                 if (seq->blend_mode == SEQ_BLEND_REPLACE) {
2197                         out = seq_render_strip(bmain, scene, seq, cfra,
2198                                                render_size,
2199                                                seqrectx, seqrecty);
2200                         break;
2201                 }
2202
2203                 early_out = seq_get_early_out_for_blend_mode(seq);
2204
2205                 switch (early_out) {
2206                 case -1:
2207                 case 2:
2208                         out = seq_render_strip(bmain, scene, seq, cfra,
2209                                                render_size,
2210                                                seqrectx, seqrecty);
2211                         break;
2212                 case 1:
2213                         if (i == 0) {
2214                                 out = IMB_allocImBuf(
2215                                         (short)seqrectx, (short)seqrecty, 
2216                                         32, IB_rect);
2217                         }
2218                         break;
2219                 case 0:
2220                         if (i == 0) {
2221                                 out = seq_render_strip(bmain, scene, seq, cfra,
2222                                                        render_size,
2223                                                        seqrectx, seqrecty);
2224                         }
2225
2226                         break;
2227                 }
2228                 if (out) {
2229                         break;
2230                 }
2231         }
2232
2233         seq_stripelem_cache_put(
2234                 seq_arr[i], seqrectx, seqrecty, cfra, 
2235                 SEQ_STRIPELEM_IBUF_COMP, out);
2236
2237
2238         i++;
2239
2240         for (; i < count; i++) {
2241                 Sequence * seq = seq_arr[i];
2242
2243                 if (seq_get_early_out_for_blend_mode(seq) == 0) {
2244                         struct SeqEffectHandle sh = get_sequence_blend(seq);
2245                         ImBuf * ibuf1 = out;
2246                         ImBuf * ibuf2 = seq_render_strip(bmain, scene, seq, cfra,
2247                                                          render_size,
2248                                                          seqrectx, seqrecty);
2249
2250                         float facf = seq->blend_opacity / 100.0;
2251                         int swap_input 
2252                                 = seq_must_swap_input_in_blend_mode(seq);
2253
2254                         int x= seqrectx;
2255                         int y= seqrecty;
2256
2257                         if (swap_input) {
2258                                 out = sh.execute(bmain, scene, seq, cfra, 
2259                                                  facf, facf, x, y, render_size,
2260                                                  ibuf2, ibuf1, 0);
2261                         } else {
2262                                 out = sh.execute(bmain, scene, seq, cfra, 
2263                                                  facf, facf, x, y, render_size,
2264                                                  ibuf1, ibuf2, 0);
2265                         }
2266                 
2267                         IMB_freeImBuf(ibuf1);
2268                         IMB_freeImBuf(ibuf2);
2269                 }
2270
2271                 seq_stripelem_cache_put(
2272                         seq_arr[i], seqrectx, seqrecty, cfra, 
2273                         SEQ_STRIPELEM_IBUF_COMP, out);
2274         }
2275
2276         return out;
2277 }
2278
2279 /*
2280  * returned ImBuf is refed!
2281  * you have to free after usage!
2282  */
2283
2284 ImBuf *give_ibuf_seq(Main *bmain, Scene *scene, int rectx, int recty, int cfra, int chanshown, int render_size)
2285 {
2286         Editing *ed= seq_give_editing(scene, FALSE);
2287         int count;
2288         ListBase *seqbasep;
2289         
2290         if(ed==NULL) return NULL;
2291
2292         count = BLI_countlist(&ed->metastack);
2293         if((chanshown < 0) && (count > 0)) {
2294                 count = MAX2(count + chanshown, 0);
2295                 seqbasep= ((MetaStack*)BLI_findlink(&ed->metastack, count))->oldbasep;
2296         } else {
2297                 seqbasep= ed->seqbasep;
2298         }
2299
2300         return seq_render_strip_stack(
2301                 bmain, scene, seqbasep, cfra, chanshown, render_size, rectx, recty);
2302 }
2303
2304 ImBuf *give_ibuf_seqbase(Main *bmain, Scene *scene, int rectx, int recty, int cfra, int chanshown, int render_size, ListBase *seqbasep)
2305 {
2306         return seq_render_strip_stack(bmain, scene, seqbasep, cfra, chanshown, render_size, rectx, recty);
2307 }
2308
2309
2310 ImBuf *give_ibuf_seq_direct(Main *bmain, Scene *scene, int rectx, int recty, int cfra, int render_size, Sequence *seq)
2311 {
2312         return seq_render_strip(bmain, scene, seq, cfra, render_size, rectx, recty);
2313 }
2314
2315 #if 0
2316 /* check used when we need to change seq->blend_mode but not to effect or audio strips */
2317 static int seq_can_blend(Sequence *seq)
2318 {
2319         if (ELEM4(seq->type, SEQ_IMAGE, SEQ_META, SEQ_SCENE, SEQ_MOVIE)) {
2320                 return 1;
2321         } else {
2322                 return 0;
2323         }
2324 }
2325 #endif
2326
2327 /* *********************** threading api ******************* */
2328
2329 static ListBase running_threads;
2330 static ListBase prefetch_wait;
2331 static ListBase prefetch_done;
2332
2333 static pthread_mutex_t queue_lock          = PTHREAD_MUTEX_INITIALIZER;
2334 static pthread_mutex_t wakeup_lock         = PTHREAD_MUTEX_INITIALIZER;
2335 static pthread_cond_t  wakeup_cond         = PTHREAD_COND_INITIALIZER;
2336
2337 //static pthread_mutex_t prefetch_ready_lock = PTHREAD_MUTEX_INITIALIZER;
2338 //static pthread_cond_t  prefetch_ready_cond = PTHREAD_COND_INITIALIZER;
2339
2340 static pthread_mutex_t frame_done_lock     = PTHREAD_MUTEX_INITIALIZER;
2341 static pthread_cond_t  frame_done_cond     = PTHREAD_COND_INITIALIZER;
2342
2343 static volatile int seq_thread_shutdown = TRUE; 
2344 static volatile int seq_last_given_monoton_cfra = 0;
2345 static int monoton_cfra = 0;
2346
2347 typedef struct PrefetchThread {
2348         struct PrefetchThread *next, *prev;
2349         
2350         Scene *scene;
2351         struct PrefetchQueueElem *current;
2352         pthread_t pthread;
2353         int running;
2354         
2355 } PrefetchThread;
2356
2357 typedef struct PrefetchQueueElem {
2358         struct PrefetchQueueElem *next, *prev;
2359         
2360         int rectx;
2361         int recty;
2362         int cfra;
2363         int chanshown;
2364         int render_size;
2365
2366         int monoton_cfra;
2367
2368         struct ImBuf * ibuf;
2369 } PrefetchQueueElem;
2370
2371 #if 0
2372 static void *seq_prefetch_thread(void * This_)
2373 {
2374         PrefetchThread * This = This_;
2375
2376         while (!seq_thread_shutdown) {
2377                 PrefetchQueueElem *e;
2378                 int s_last;
2379
2380                 pthread_mutex_lock(&queue_lock);
2381                 e = prefetch_wait.first;
2382                 if (e) {
2383                         BLI_remlink(&prefetch_wait, e);
2384                 }
2385                 s_last = seq_last_given_monoton_cfra;
2386
2387                 This->current = e;
2388
2389                 pthread_mutex_unlock(&queue_lock);
2390
2391                 if (!e) {
2392                         pthread_mutex_lock(&prefetch_ready_lock);
2393
2394                         This->running = FALSE;
2395
2396                         pthread_cond_signal(&prefetch_ready_cond);
2397                         pthread_mutex_unlock(&prefetch_ready_lock);
2398
2399                         pthread_mutex_lock(&wakeup_lock);
2400                         if (!seq_thread_shutdown) {
2401                                 pthread_cond_wait(&wakeup_cond, &wakeup_lock);
2402                         }
2403                         pthread_mutex_unlock(&wakeup_lock);
2404                         continue;
2405                 }
2406
2407                 This->running = TRUE;
2408                 
2409                 if (e->cfra >= s_last) { 
2410                         e->ibuf = give_ibuf_seq_impl(This->scene, 
2411                                 e->rectx, e->recty, e->cfra, e->chanshown,
2412                                 e->render_size);
2413                 }
2414
2415                 pthread_mutex_lock(&queue_lock);
2416
2417                 BLI_addtail(&prefetch_done, e);
2418
2419                 for (e = prefetch_wait.first; e; e = e->next) {
2420                         if (s_last > e->monoton_cfra) {
2421                                 BLI_remlink(&prefetch_wait, e);
2422                                 MEM_freeN(e);
2423                         }
2424                 }
2425
2426                 for (e = prefetch_done.first; e; e = e->next) {
2427                         if (s_last > e->monoton_cfra) {
2428                                 if (e->ibuf) {
2429                                         IMB_cache_limiter_unref(e->ibuf);
2430                                 }
2431                                 BLI_remlink(&prefetch_done, e);
2432                                 MEM_freeN(e);
2433                         }
2434                 }
2435
2436                 pthread_mutex_unlock(&queue_lock);
2437
2438                 pthread_mutex_lock(&frame_done_lock);
2439                 pthread_cond_signal(&frame_done_cond);
2440                 pthread_mutex_unlock(&frame_done_lock);
2441         }
2442         return 0;
2443 }
2444
2445 static void seq_start_threads(Scene *scene)
2446 {
2447         int i;
2448
2449         running_threads.first = running_threads.last = NULL;
2450         prefetch_wait.first = prefetch_wait.last = NULL;
2451         prefetch_done.first = prefetch_done.last = NULL;
2452
2453         seq_thread_shutdown = FALSE;
2454         seq_last_given_monoton_cfra = monoton_cfra = 0;
2455
2456         /* since global structures are modified during the processing
2457            of one frame, only one render thread is currently possible... 
2458
2459            (but we code, in the hope, that we can remove this restriction
2460            soon...)
2461         */
2462
2463         fprintf(stderr, "SEQ-THREAD: seq_start_threads\n");
2464
2465         for (i = 0; i < 1; i++) {
2466                 PrefetchThread *t = MEM_callocN(sizeof(PrefetchThread), "prefetch_thread");
2467                 t->scene= scene;
2468                 t->running = TRUE;
2469                 BLI_addtail(&running_threads, t);
2470
2471                 pthread_create(&t->pthread, NULL, seq_prefetch_thread, t);
2472         }
2473
2474         /* init malloc mutex */
2475         BLI_init_threads(0, 0, 0);
2476 }
2477
2478 static void seq_stop_threads()
2479 {
2480         PrefetchThread *tslot;
2481         PrefetchQueueElem *e;
2482
2483         fprintf(stderr, "SEQ-THREAD: seq_stop_threads()\n");
2484
2485         if (seq_thread_shutdown) {
2486                 fprintf(stderr, "SEQ-THREAD: ... already stopped\n");
2487                 return;
2488         }
2489         
2490         pthread_mutex_lock(&wakeup_lock);
2491
2492         seq_thread_shutdown = TRUE;
2493
2494                 pthread_cond_broadcast(&wakeup_cond);
2495                 pthread_mutex_unlock(&wakeup_lock);
2496
2497         for(tslot = running_threads.first; tslot; tslot= tslot->next) {
2498                 pthread_join(tslot->pthread, NULL);
2499         }
2500
2501
2502         for (e = prefetch_wait.first; e; e = e->next) {
2503                 BLI_remlink(&prefetch_wait, e);
2504                 MEM_freeN(e);
2505         }
2506
2507         for (e = prefetch_done.first; e; e = e->next) {
2508                 if (e->ibuf) {
2509                         IMB_cache_limiter_unref(e->ibuf);
2510                 }
2511                 BLI_remlink(&prefetch_done, e);
2512                 MEM_freeN(e);
2513         }
2514
2515         BLI_freelistN(&running_threads);
2516
2517         /* deinit malloc mutex */
2518         BLI_end_threads(0);
2519 }
2520 #endif
2521
2522 void give_ibuf_prefetch_request(int rectx, int recty, int cfra, int chanshown,
2523                                 int render_size)
2524 {
2525         PrefetchQueueElem *e;
2526         if (seq_thread_shutdown) {
2527                 return;
2528         }
2529
2530         e = MEM_callocN(sizeof(PrefetchQueueElem), "prefetch_queue_elem");
2531         e->rectx = rectx;
2532         e->recty = recty;
2533         e->cfra = cfra;
2534         e->chanshown = chanshown;
2535         e->render_size = render_size;
2536         e->monoton_cfra = monoton_cfra++;
2537
2538         pthread_mutex_lock(&queue_lock);
2539         BLI_addtail(&prefetch_wait, e);
2540         pthread_mutex_unlock(&queue_lock);
2541         
2542         pthread_mutex_lock(&wakeup_lock);
2543         pthread_cond_signal(&wakeup_cond);
2544         pthread_mutex_unlock(&wakeup_lock);
2545 }
2546
2547 #if 0
2548 static void seq_wait_for_prefetch_ready()
2549 {
2550         PrefetchThread *tslot;
2551
2552         if (seq_thread_shutdown) {
2553                 return;
2554         }
2555
2556         fprintf(stderr, "SEQ-THREAD: rendering prefetch frames...\n");
2557
2558         pthread_mutex_lock(&prefetch_ready_lock);
2559
2560         for(;;) {
2561                 for(tslot = running_threads.first; tslot; tslot= tslot->next) {
2562                         if (tslot->running) {
2563                                 break;
2564                         }
2565                 }
2566                 if (!tslot) {
2567                         break;
2568                 }
2569                 pthread_cond_wait(&prefetch_ready_cond, &prefetch_ready_lock);
2570         }
2571
2572         pthread_mutex_unlock(&prefetch_ready_lock);
2573
2574         fprintf(stderr, "SEQ-THREAD: prefetch done\n");
2575 }
2576 #endif
2577
2578 ImBuf *give_ibuf_seq_threaded(Main *bmain, Scene *scene, int rectx, int recty, int cfra, int chanshown, int render_size)
2579 {
2580         PrefetchQueueElem *e = NULL;
2581         int found_something = FALSE;
2582
2583         if (seq_thread_shutdown) {
2584                 return give_ibuf_seq(bmain, scene, rectx, recty, cfra, chanshown, render_size);
2585         }
2586
2587         while (!e) {
2588                 int success = FALSE;
2589                 pthread_mutex_lock(&queue_lock);
2590
2591                 for (e = prefetch_done.first; e; e = e->next) {
2592                         if (cfra == e->cfra &&
2593                                 chanshown == e->chanshown &&
2594                                 rectx == e->rectx && 
2595                                 recty == e->recty &&
2596                                 render_size == e->render_size) {
2597                                 success = TRUE;
2598                                 found_something = TRUE;
2599                                 break;
2600                         }
2601                 }
2602
2603                 if (!e) {
2604                         for (e = prefetch_wait.first; e; e = e->next) {
2605                                 if (cfra == e->cfra &&
2606                                         chanshown == e->chanshown &&
2607                                         rectx == e->rectx && 
2608                                         recty == e->recty &&
2609                                         render_size == e->render_size) {
2610                                         found_something = TRUE;
2611                                         break;
2612                                 }
2613                         }
2614                 }
2615
2616                 if (!e) {
2617                         PrefetchThread *tslot;
2618
2619                         for(tslot = running_threads.first; 
2620                                 tslot; tslot= tslot->next) {
2621                                 if (tslot->current &&
2622                                         cfra == tslot->current->cfra &&
2623                                         chanshown == tslot->current->chanshown &&
2624                                         rectx == tslot->current->rectx && 
2625                                         recty == tslot->current->recty &&
2626                                         render_size== tslot->current->render_size){
2627                                         found_something = TRUE;
2628                                         break;
2629                                 }
2630                         }
2631                 }
2632
2633                 /* e->ibuf is unrefed by render thread on next round. */
2634
2635                 if (e) {
2636                         seq_last_given_monoton_cfra = e->monoton_cfra;
2637                 }
2638
2639                 pthread_mutex_unlock(&queue_lock);
2640
2641                 if (!success) {
2642                         e = NULL;
2643
2644                         if (!found_something) {
2645                                 fprintf(stderr, 
2646                                         "SEQ-THREAD: Requested frame "
2647                                         "not in queue ???\n");
2648                                 break;
2649                         }
2650                         pthread_mutex_lock(&frame_done_lock);
2651                         pthread_cond_wait(&frame_done_cond, &frame_done_lock);
2652                         pthread_mutex_unlock(&frame_done_lock);
2653                 }
2654         }
2655         
2656         return e ? e->ibuf : 0;
2657 }
2658
2659 /* Functions to free imbuf and anim data on changes */
2660
2661 static void free_anim_seq(Sequence *seq)
2662 {
2663         if(seq->anim) {
2664                 IMB_free_anim(seq->anim);
2665                 seq->anim = 0;
2666         }
2667 }
2668
2669 void free_imbuf_seq(Scene *scene, ListBase * seqbase, int check_mem_usage,
2670                     int keep_file_handles)
2671 {
2672         Sequence *seq;
2673
2674         if (check_mem_usage) {
2675                 /* Let the cache limitor take care of this (schlaile) */
2676                 /* While render let's keep all memory available for render 
2677                    (ton)
2678                    At least if free memory is tight...
2679                    This can make a big difference in encoding speed
2680                    (it is around 4 times(!) faster, if we do not waste time
2681                    on freeing _all_ buffers every time on long timelines...)
2682                    (schlaile)
2683                 */
2684         
2685                 uintptr_t mem_in_use;
2686                 uintptr_t mmap_in_use;
2687                 uintptr_t max;
2688         
2689                 mem_in_use= MEM_get_memory_in_use();
2690                 mmap_in_use= MEM_get_mapped_memory_in_use();
2691                 max = MEM_CacheLimiter_get_maximum();
2692         
2693                 if (max == 0 || mem_in_use + mmap_in_use <= max) {
2694                         return;
2695                 }
2696         }
2697
2698         seq_stripelem_cache_cleanup();
2699         
2700         for(seq= seqbase->first; seq; seq= seq->next) {
2701                 if(seq->strip) {
2702                         if(seq->type==SEQ_MOVIE && !keep_file_handles)
2703                                 free_anim_seq(seq);
2704                         if(seq->type==SEQ_SPEED) {
2705                                 sequence_effect_speed_rebuild_map(scene, seq, 1);
2706                         }
2707                 }
2708                 if(seq->type==SEQ_META) {
2709                         free_imbuf_seq(scene, &seq->seqbase, FALSE,
2710                                        keep_file_handles);
2711                 }
2712                 if(seq->type==SEQ_SCENE) {
2713                         /* FIXME: recurs downwards, 
2714                            but do recurs protection somehow! */
2715                 }
2716         }
2717         
2718 }
2719
2720 static int update_changed_seq_recurs(Scene *scene, Sequence *seq, Sequence *changed_seq, int len_change, int ibuf_change)
2721 {
2722         Sequence *subseq;
2723         int free_imbuf = 0;
2724         
2725         /* recurs downwards to see if this seq depends on the changed seq */
2726         
2727         if(seq == NULL)
2728                 return 0;
2729         
2730         if(seq == changed_seq)
2731                 free_imbuf = 1;
2732         
2733         for(subseq=seq->seqbase.first; subseq; subseq=subseq->next)
2734                 if(update_changed_seq_recurs(scene, subseq, changed_seq, len_change, ibuf_change))
2735                         free_imbuf = TRUE;
2736         
2737         if(seq->seq1)
2738                 if(update_changed_seq_recurs(scene, seq->seq1, changed_seq, len_change, ibuf_change))
2739                         free_imbuf = TRUE;
2740         if(seq->seq2 && (seq->seq2 != seq->seq1))
2741                 if(update_changed_seq_recurs(scene, seq->seq2, changed_seq, len_change, ibuf_change))
2742                         free_imbuf = TRUE;
2743         if(seq->seq3 && (seq->seq3 != seq->seq1) && (seq->seq3 != seq->seq2))
2744                 if(update_changed_seq_recurs(scene, seq->seq3, changed_seq, len_change, ibuf_change))
2745                         free_imbuf = TRUE;
2746         
2747         if(free_imbuf) {
2748                 if(ibuf_change) {
2749                         if(seq->type == SEQ_MOVIE)
2750                                 free_anim_seq(seq);
2751                         if(seq->type == SEQ_SPEED) {
2752                                 sequence_effect_speed_rebuild_map(scene, seq, 1);
2753                         }
2754                 }
2755                 
2756                 if(len_change)
2757                         calc_sequence(scene, seq);
2758         }
2759         
2760         return free_imbuf;
2761 }
2762
2763 void update_changed_seq_and_deps(Scene *scene, Sequence *changed_seq, int len_change, int ibuf_change)
2764 {
2765         Editing *ed= seq_give_editing(scene, FALSE);
2766         Sequence *seq;
2767         
2768         if (ed==NULL) return;
2769         
2770         for (seq=ed->seqbase.first; seq; seq=seq->next)
2771                 update_changed_seq_recurs(scene, seq, changed_seq, len_change, ibuf_change);
2772 }
2773
2774 /* seq funcs's for transforming internally
2775  notice the difference between start/end and left/right.
2776
2777  left and right are the bounds at which the sequence is rendered,
2778 start and end are from the start and fixed length of the sequence.
2779 */
2780 int seq_tx_get_start(Sequence *seq) {
2781         return seq->start;
2782 }
2783 int seq_tx_get_end(Sequence *seq)
2784 {
2785         return seq->start+seq->len;
2786 }
2787
2788 int seq_tx_get_final_left(Sequence *seq, int metaclip)
2789 {
2790         if (metaclip && seq->tmp) {
2791                 /* return the range clipped by the parents range */
2792                 return MAX2( seq_tx_get_final_left(seq, 0), seq_tx_get_final_left((Sequence *)seq->tmp, 1) );
2793         } else {
2794                 return (seq->start - seq->startstill) + seq->startofs;
2795         }
2796
2797 }
2798 int seq_tx_get_final_right(Sequence *seq, int metaclip)
2799 {
2800         if (metaclip && seq->tmp) {
2801                 /* return the range clipped by the parents range */
2802                 return MIN2( seq_tx_get_final_right(seq, 0), seq_tx_get_final_right((Sequence *)seq->tmp, 1) );
2803         } else {
2804                 return ((seq->start+seq->len) + seq->endstill) - seq->endofs;
2805         }
2806 }
2807
2808 void seq_tx_set_final_left(Sequence *seq, int val)
2809 {
2810         if (val < (seq)->start) {
2811                 seq->startstill = abs(val - (seq)->start);
2812                 seq->startofs = 0;
2813         } else {
2814                 seq->startofs = abs(val - (seq)->start);
2815                 seq->startstill = 0;
2816         }
2817 }
2818
2819 void seq_tx_set_final_right(Sequence *seq, int val)
2820 {
2821         if (val > (seq)->start + (seq)->len) {
2822                 seq->endstill = abs(val - (seq->start + (seq)->len));
2823                 seq->endofs = 0;
2824         } else {
2825                 seq->endofs = abs(val - ((seq)->start + (seq)->len));
2826                 seq->endstill = 0;
2827         }
2828 }
2829
2830 /* used so we can do a quick check for single image seq
2831    since they work a bit differently to normal image seq's (during transform) */
2832 int seq_single_check(Sequence *seq)
2833 {
2834         if ( seq->len==1 && (seq->type == SEQ_IMAGE || seq->type == SEQ_COLOR
2835                              || seq->type == SEQ_MULTICAM))
2836                 return 1;
2837         else
2838                 return 0;
2839 }
2840
2841 /* check if the selected seq's reference unselected seq's */
2842 int seqbase_isolated_sel_check(ListBase *seqbase)
2843 {
2844         Sequence *seq;
2845         /* is there more than 1 select */
2846         int ok= FALSE;
2847
2848         for(seq= seqbase->first; seq; seq= seq->next) {
2849                 if(seq->flag & SELECT) {
2850                         ok= TRUE;
2851                         break;
2852                 }
2853         }
2854
2855         if(ok == FALSE)
2856                 return FALSE;
2857
2858         /* test relationships */
2859         for(seq= seqbase->first; seq; seq= seq->next) {
2860                 if(seq->flag & SELECT) {
2861                         if(seq->type & SEQ_EFFECT) {
2862                                 if(seq->seq1 && (seq->seq1->flag & SELECT)==0) return FALSE;
2863                                 if(seq->seq2 && (seq->seq2->flag & SELECT)==0) return FALSE;
2864                                 if(seq->seq3 && (seq->seq3->flag & SELECT)==0) return FALSE;
2865                         }
2866                 }
2867                 else if(seq->type & SEQ_EFFECT) {
2868                         if(seq->seq1 && (seq->seq1->flag & SELECT)) return FALSE;
2869                         if(seq->seq2 && (seq->seq2->flag & SELECT)) return FALSE;
2870                         if(seq->seq3 && (seq->seq3->flag & SELECT)) return FALSE;
2871                 }
2872         }
2873
2874         return TRUE;
2875 }
2876
2877 /* use to impose limits when dragging/extending - so impossible situations dont happen
2878  * Cant use the SEQ_LEFTSEL and SEQ_LEFTSEL directly because the strip may be in a metastrip */
2879 void seq_tx_handle_xlimits(Sequence *seq, int leftflag, int rightflag)
2880 {
2881         if(leftflag) {
2882                 if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_final_right(seq, 0)) {
2883                         seq_tx_set_final_left(seq, seq_tx_get_final_right(seq, 0)-1);
2884                 }
2885
2886                 if (seq_single_check(seq)==0) {
2887                         if (seq_tx_get_final_left(seq, 0) >= seq_tx_get_end(seq)) {
2888                                 seq_tx_set_final_left(seq, seq_tx_get_end(seq)-1);
2889                         }
2890
2891                         /* dosnt work now - TODO */
2892                         /*
2893                         if (seq_tx_get_start(seq) >= seq_tx_get_final_right(seq, 0)) {
2894                                 int ofs;
2895                                 ofs = seq_tx_get_start(seq) - seq_tx_get_final_right(seq, 0);
2896                                 seq->start -= ofs;
2897                                 seq_tx_set_final_left(seq, seq_tx_get_final_left(seq, 0) + ofs );
2898                         }*/
2899
2900                 }
2901         }
2902
2903         if(rightflag) {
2904                 if (seq_tx_get_final_right(seq, 0) <=  seq_tx_get_final_left(seq, 0)) {
2905                         seq_tx_set_final_right(seq, seq_tx_get_final_left(seq, 0)+1);
2906                 }
2907
2908                 if (seq_single_check(seq)==0) {
2909                         if (seq_tx_get_final_right(seq, 0) <= seq_tx_get_start(seq)) {
2910                                 seq_tx_set_final_right(seq, seq_tx_get_start(seq)+1);
2911                         }
2912                 }
2913         }
2914
2915         /* sounds cannot be extended past their endpoints */
2916         if (seq->type == SEQ_SOUND) {
2917                 seq->startstill= 0;
2918                 seq->endstill= 0;
2919         }
2920 }
2921
2922 void seq_single_fix(Sequence *seq)
2923 {
2924         int left, start, offset;
2925         if (!seq_single_check(seq))
2926                 return;
2927
2928         /* make sure the image is always at the start since there is only one,
2929            adjusting its start should be ok */
2930         left = seq_tx_get_final_left(seq, 0);
2931         start = seq->start;
2932         if (start != left) {
2933                 offset = left - start;
2934                 seq_tx_set_final_left( seq, seq_tx_get_final_left(seq, 0) - offset );
2935                 seq_tx_set_final_right( seq, seq_tx_get_final_right(seq, 0) - offset );
2936                 seq->start += offset;
2937         }
2938 }
2939
2940 int seq_tx_test(Sequence * seq)
2941 {
2942         return (seq->type < SEQ_EFFECT) || (get_sequence_effect_num_inputs(seq->type) == 0);
2943 }
2944
2945 static int seq_overlap(Sequence *seq1, Sequence *seq2)
2946 {
2947         if(seq1 != seq2)
2948                 if(seq1->machine==seq2->machine)
2949                         if(((seq1->enddisp <= seq2->startdisp) || (seq1->startdisp >= seq2->enddisp))==0)
2950                                 return 1;
2951
2952         return 0;
2953 }
2954
2955 int seq_test_overlap(ListBase * seqbasep, Sequence *test)
2956 {
2957         Sequence *seq;
2958
2959         seq= seqbasep->first;
2960         while(seq) {
2961                 if(seq_overlap(test, seq))
2962                         return 1;
2963
2964                 seq= seq->next;
2965         }
2966         return 0;
2967 }
2968
2969
2970 static void seq_translate(Scene *evil_scene, Sequence *seq, int delta)
2971 {
2972         seq_offset_animdata(evil_scene, seq, delta);
2973         seq->start += delta;
2974
2975         if(seq->type==SEQ_META) {
2976                 Sequence *seq_child;
2977                 for(seq_child= seq->seqbase.first; seq_child; seq_child= seq_child->next) {
2978                         seq_translate(evil_scene, seq_child, delta);
2979                 }
2980         }
2981
2982         calc_sequence_disp(evil_scene, seq);
2983 }
2984
2985 /* return 0 if there werent enough space */
2986 int shuffle_seq(ListBase * seqbasep, Sequence *test, Scene *evil_scene)
2987 {
2988         int orig_machine= test->machine;
2989         test->machine++;
2990         calc_sequence(evil_scene, test);
2991         while( seq_test_overlap(seqbasep, test) ) {
2992                 if(test->machine >= MAXSEQ) {
2993                         break;
2994                 }
2995                 test->machine++;
2996                 calc_sequence(evil_scene, test); // XXX - I dont think this is needed since were only moving vertically, Campbell.
2997         }
2998
2999         
3000         if(test->machine >= MAXSEQ) {
3001                 /* Blender 2.4x would remove the strip.
3002                  * nicer to move it to the end */
3003
3004                 Sequence *seq;
3005                 int new_frame= test->enddisp;
3006
3007                 for(seq= seqbasep->first; seq; seq= seq->next) {
3008                         if (seq->machine == orig_machine)
3009                                 new_frame = MAX2(new_frame, seq->enddisp);
3010                 }
3011
3012                 test->machine= orig_machine;
3013                 new_frame = new_frame + (test->start-test->startdisp); /* adjust by the startdisp */
3014                 seq_translate(evil_scene, test, new_frame - test->start);
3015
3016                 calc_sequence(evil_scene, test);
3017                 return 0;
3018         } else {
3019                 return 1;
3020         }
3021 }
3022
3023 static int shuffle_seq_time_offset_test(ListBase * seqbasep, char dir)
3024 {
3025         int offset= 0;
3026         Sequence *seq, *seq_other;
3027
3028         for(seq= seqbasep->first; seq; seq= seq->next) {
3029                 if(seq->tmp) {
3030                         for(seq_other= seqbasep->first; seq_other; seq_other= seq_other->next) {
3031                                 if(!seq_other->tmp && seq_overlap(seq, seq_other)) {
3032                                         if(dir=='L') {
3033                                                 offset= MIN2(offset, seq_other->startdisp - seq->enddisp);
3034                                         }
3035                                         else {
3036                                                 offset= MAX2(offset, seq_other->enddisp - seq->startdisp);
3037                                         }
3038                                 }
3039                         }
3040                 }
3041         }
3042         return offset;
3043 }
3044
3045 static int shuffle_seq_time_offset(Scene* scene, ListBase * seqbasep, char dir)
3046 {
3047         int ofs= 0;
3048         int tot_ofs= 0;
3049         Sequence *seq;
3050         while( (ofs= shuffle_seq_time_offset_test(seqbasep, dir)) ) {
3051                 for(seq= seqbasep->first; seq; seq= seq->next) {
3052                         if(seq->tmp) {
3053                                 /* seq_test_overlap only tests display values */
3054                                 seq->startdisp +=       ofs;
3055                                 seq->enddisp +=         ofs;
3056                         }
3057                 }
3058
3059                 tot_ofs+= ofs;
3060         }
3061
3062         for(seq= seqbasep->first; seq; seq= seq->next) {
3063                 if(seq->tmp)
3064                         calc_sequence_disp(scene, seq); /* corrects dummy startdisp/enddisp values */
3065         }
3066
3067         return tot_ofs;
3068 }
3069
3070 int shuffle_seq_time(ListBase * seqbasep, Scene *evil_scene)
3071 {
3072         /* note: seq->tmp is used to tag strips to move */
3073
3074         Sequence *seq;
3075
3076         int offset_l = shuffle_seq_time_offset(evil_scene, seqbasep, 'L');
3077         int offset_r = shuffle_seq_time_offset(evil_scene, seqbasep, 'R');
3078         int offset = (-offset_l < offset_r) ?  offset_l:offset_r;
3079
3080         if(offset) {
3081                 for(seq= seqbasep->first; seq; seq= seq->next) {
3082                         if(seq->tmp) {
3083                                 seq_translate(evil_scene, seq, offset);
3084                                 seq->flag &= ~SEQ_OVERLAP;
3085                         }
3086                 }
3087         }
3088
3089         return offset? 0:1;
3090 }
3091
3092 void seq_update_sound(Scene* scene, Sequence *seq)
3093 {
3094         if(seq->scene_sound)
3095         {
3096                 sound_move_scene_sound(scene, seq->scene_sound, seq->startdisp, seq->enddisp, seq->startofs + seq->anim_startofs);
3097                 /* mute is set in seq_update_muting_recursive */
3098         }
3099 }
3100
3101 static void seq_update_muting_recursive(Scene *scene, ListBase *seqbasep, Sequence *metaseq, int mute)
3102 {
3103         Sequence *seq;
3104         int seqmute;
3105
3106         /* for sound we go over full meta tree to update muted state,
3107            since sound is played outside of evaluating the imbufs, */
3108         for(seq=seqbasep->first; seq; seq=seq->next) {
3109                 seqmute= (mute || (seq->flag & SEQ_MUTE));
3110
3111                 if(seq->type == SEQ_META) {
3112                         /* if this is the current meta sequence, unmute because
3113                            all sequences above this were set to mute */
3114                         if(seq == metaseq)
3115                                 seqmute= 0;
3116
3117                         seq_update_muting_recursive(scene, &seq->seqbase, metaseq, seqmute);
3118                 }
3119                 else if((seq->type == SEQ_SOUND) || (seq->type == SEQ_SCENE)) {
3120                         if(seq->scene_sound) {
3121                                 sound_mute_scene_sound(scene, seq->scene_sound, seqmute);
3122                         }
3123                 }
3124         }
3125 }
3126
3127 void seq_update_muting(Scene *scene, Editing *ed)
3128 {
3129         if(ed) {
3130                 /* mute all sounds up to current metastack list */
3131                 MetaStack *ms= ed->metastack.last;
3132
3133                 if(ms)
3134                         seq_update_muting_recursive(scene, &ed->seqbase, ms->parseq, 1);
3135                 else
3136                         seq_update_muting_recursive(scene, &ed->seqbase, NULL, 0);
3137         }
3138 }
3139
3140 /* in cases where we done know the sequence's listbase */
3141 ListBase *seq_seqbase(ListBase *seqbase, Sequence *seq)
3142 {
3143         Sequence *iseq;
3144         ListBase *lb= NULL;
3145
3146         for(iseq= seqbase->first; iseq; iseq= iseq->next) {
3147                 if(seq==iseq) {
3148                         return seqbase;
3149                 }
3150                 else if(iseq->seqbase.first && (lb= seq_seqbase(&iseq->seqbase, seq))) {
3151                         return lb;
3152                 }
3153         }
3154
3155         return NULL;
3156 }
3157
3158 int seq_swap(Sequence *seq_a, Sequence *seq_b)
3159 {
3160         char name[sizeof(seq_a->name)];
3161
3162         if(seq_a->len != seq_b->len)
3163                 return 0;
3164
3165         /* type checking, could be more advanced but disalow sound vs non-sound copy */
3166         if(seq_a->type != seq_b->type) {
3167                 if(seq_a->type == SEQ_SOUND || seq_b->type == SEQ_SOUND) {
3168                         return 0;
3169                 }
3170
3171                 /* disallow effects to swap with non-effects strips */
3172                 if((seq_a->type & SEQ_EFFECT) != (seq_b->type & SEQ_EFFECT)) {
3173                         return 0;
3174                 }
3175
3176                 if((seq_a->type & SEQ_EFFECT) && (seq_b->type & SEQ_EFFECT)) {
3177                         if(get_sequence_effect_num_inputs(seq_a->type) != get_sequence_effect_num_inputs(seq_b->type)) {
3178                                 return 0;
3179                         }
3180                 }
3181         }
3182
3183         SWAP(Sequence, *seq_a, *seq_b);
3184
3185         /* swap back names so animation fcurves dont get swapped */
3186         strcpy(name, seq_a->name+2);
3187         strcpy(seq_a->name+2, seq_b->name+2);
3188         strcpy(seq_b->name+2, name);
3189
3190         /* swap back opacity, and overlay mode */
3191         SWAP(int, seq_a->blend_mode, seq_b->blend_mode);
3192         SWAP(float, seq_a->blend_opacity, seq_b->blend_opacity);
3193
3194
3195         SWAP(void *, seq_a->prev, seq_b->prev);
3196         SWAP(void *, seq_a->next, seq_b->next);
3197         SWAP(int, seq_a->start, seq_b->start);
3198         SWAP(int, seq_a->startofs, seq_b->startofs);
3199         SWAP(int, seq_a->endofs, seq_b->endofs);
3200         SWAP(int, seq_a->startstill, seq_b->startstill);
3201         SWAP(int, seq_a->endstill, seq_b->endstill);
3202         SWAP(int, seq_a->machine, seq_b->machine);
3203         SWAP(int, seq_a->startdisp, seq_b->startdisp);
3204         SWAP(int, seq_a->enddisp, seq_b->enddisp);
3205
3206         return 1;
3207 }
3208
3209 /* XXX - hackish function needed for transforming strips! TODO - have some better solution */
3210 void seq_offset_animdata(Scene *scene, Sequence *seq, int ofs)
3211 {
3212         char str[32];
3213         FCurve *fcu;
3214
3215         if(scene->adt==NULL || ofs==0 || scene->adt->action==NULL)
3216                 return;
3217
3218         sprintf(str, "[\"%s\"]", seq->name+2);
3219
3220         for (fcu= scene->adt->action->curves.first; fcu; fcu= fcu->next) {
3221                 if(strstr(fcu->rna_path, "sequence_editor.sequences_all[") && strstr(fcu->rna_path, str)) {
3222                         int i;
3223                         for (i = 0; i < fcu->totvert; i++) {
3224                                 BezTriple *bezt= &fcu->bezt[i];
3225                                 bezt->vec[0][0] += ofs;
3226                                 bezt->vec[1][0] += ofs;
3227                                 bezt->vec[2][0] += ofs;
3228                         }
3229                 }
3230         }
3231 }
3232
3233 void seq_dupe_animdata(Scene *scene, char *name_from, char *name_to)
3234 {
3235         char str_from[32];
3236         FCurve *fcu;
3237         FCurve *fcu_last;
3238         FCurve *fcu_cpy;
3239         ListBase lb= {NULL, NULL};
3240
3241         if(scene->adt==NULL || scene->adt->action==NULL)
3242                 return;
3243
3244         sprintf(str_from, "[\"%s\"]", name_from);
3245
3246         fcu_last= scene->adt->action->curves.last;
3247
3248         for (fcu= scene->adt->action->curves.first; fcu && fcu->prev != fcu_last; fcu= fcu->next) {
3249                 if(strstr(fcu->rna_path, "sequence_editor.sequences_all[") && strstr(fcu->rna_path, str_from)) {
3250                         fcu_cpy= copy_fcurve(fcu);
3251                         BLI_addtail(&lb, fcu_cpy);
3252                 }
3253         }
3254
3255         /* notice validate is 0, keep this because the seq may not be added to the scene yet */
3256         BKE_animdata_fix_paths_rename(&scene->id, scene->adt, "sequence_editor.sequences_all", name_from, name_to, 0, 0, 0);
3257
3258         /* add the original fcurves back */
3259         addlisttolist(&scene->adt->action->curves, &lb);
3260 }
3261
3262 /* XXX - hackish function needed to remove all fcurves belonging to a sequencer strip */
3263 static void seq_free_animdata(Scene *scene, Sequence *seq)