Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/source/blender/src/sequence.c
diff options
context:
space:
mode:
Diffstat (limited to 'source/blender/src/sequence.c')
-rw-r--r--source/blender/src/sequence.c1647
1 files changed, 1647 insertions, 0 deletions
diff --git a/source/blender/src/sequence.c b/source/blender/src/sequence.c
new file mode 100644
index 00000000000..ec98ed3889b
--- /dev/null
+++ b/source/blender/src/sequence.c
@@ -0,0 +1,1647 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License. See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#include <string.h>
+
+#ifdef WIN32
+#include "BLI_winstuff.h"
+#endif
+
+#include "MEM_guardedalloc.h"
+#include "PIL_dynlib.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+#include "BLI_editVert.h"
+
+#include "IMB_imbuf_types.h"
+#include "IMB_imbuf.h"
+
+#include "DNA_ipo_types.h"
+#include "DNA_sequence_types.h"
+#include "DNA_view3d_types.h"
+
+#include "BKE_utildefines.h"
+#include "BKE_plugin_types.h"
+#include "BKE_global.h"
+#include "BKE_texture.h"
+#include "BKE_image.h"
+#include "BKE_main.h"
+#include "BKE_scene.h"
+#include "BKE_ipo.h"
+
+#include "BIF_screen.h"
+#include "BIF_interface.h"
+#include "BIF_toolbox.h"
+#include "BSE_filesel.h"
+#include "BSE_headerbuttons.h"
+#include "BSE_sequence.h"
+
+#include "interface.h" /* MAART: for INT and FLO types */
+#include "blendef.h"
+#include "render.h"
+
+Sequence *seq_arr[MAXSEQ+1];
+int seqrectx, seqrecty;
+
+/* Alle support voor plugin sequences: */
+
+void open_plugin_seq(PluginSeq *pis, char *seqname)
+{
+ int (*version)();
+ char *cp;
+
+ /* voor zekerheid: (hier wordt op getest) */
+ pis->doit= 0;
+ pis->pname= 0;
+ pis->varstr= 0;
+ pis->cfra= 0;
+ pis->version= 0;
+
+ /* clear the error list */
+ PIL_dynlib_get_error_as_string(NULL);
+
+ /* if(pis->handle) PIL_dynlib_close(pis->handle); */
+ /* pis->handle= 0; */
+
+ /* open the needed object */
+ pis->handle= PIL_dynlib_open(pis->name);
+ if(test_dlerr(pis->name, pis->name)) return;
+
+ if (pis->handle != 0) {
+ /* find the address of the version function */
+ version= (int (*)())PIL_dynlib_find_symbol(pis->handle, "plugin_seq_getversion");
+ if (test_dlerr(pis->name, "plugin_seq_getversion")) return;
+
+ if (version != 0) {
+ pis->version= version();
+ if (pis->version==2 || pis->version==3) {
+ int (*info_func)(PluginInfo *);
+ PluginInfo *info= (PluginInfo*) MEM_mallocN(sizeof(PluginInfo), "plugin_info");;
+
+ info_func= (int (*)(PluginInfo *))PIL_dynlib_find_symbol(pis->handle, "plugin_getinfo");
+
+ if(info_func == NULL) error("No info func");
+ else {
+ info_func(info);
+
+ pis->pname= info->name;
+ pis->vars= info->nvars;
+ pis->cfra= info->cfra;
+
+ pis->varstr= info->varstr;
+
+ pis->doit= (void(*)(void))info->seq_doit;
+ if (info->init)
+ info->init();
+ }
+ MEM_freeN(info);
+
+ cp= PIL_dynlib_find_symbol(pis->handle, "seqname");
+ if(cp) strcpy(cp, seqname);
+ } else {
+ printf ("Plugin returned unrecognized version number\n");
+ return;
+ }
+ }
+ }
+}
+
+PluginSeq *add_plugin_seq(char *str, char *seqname)
+{
+ PluginSeq *pis;
+ VarStruct *varstr;
+ int a;
+
+ pis= MEM_callocN(sizeof(PluginSeq), "PluginSeq");
+
+ strcpy(pis->name, str);
+ open_plugin_seq(pis, seqname);
+
+ if(pis->doit==0) {
+ if(pis->handle==0) error("no plugin: %s", str);
+ else error("in plugin: %s", str);
+ MEM_freeN(pis);
+ return 0;
+ }
+
+ /* default waardes */
+ varstr= pis->varstr;
+ for(a=0; a<pis->vars; a++, varstr++) {
+ if( (varstr->type & FLO)==FLO)
+ pis->data[a]= varstr->def;
+ else if( (varstr->type & INT)==INT)
+ *((int *)(pis->data+a))= (int) varstr->def;
+ }
+
+ return pis;
+}
+
+void free_plugin_seq(PluginSeq *pis)
+{
+
+ if(pis==0) return;
+
+ /* geen PIL_dynlib_close: dezelfde plugin kan meerdere keren geopend zijn: 1 handle */
+ MEM_freeN(pis);
+}
+
+/* ***************** END PLUGIN ************************ */
+
+void free_stripdata(int len, StripElem *se)
+{
+ StripElem *seo;
+ int a;
+
+ seo= se;
+
+ for(a=0; a<len; a++, se++) {
+ if(se->ibuf && se->ok!=2) IMB_freeImBuf(se->ibuf);
+ }
+
+ MEM_freeN(seo);
+
+}
+
+void free_strip(Strip *strip)
+{
+ strip->us--;
+ if(strip->us>0) return;
+ if(strip->us<0) {
+ printf("error: negative users in strip\n");
+ return;
+ }
+
+ if(strip->stripdata) {
+ free_stripdata(strip->len, strip->stripdata);
+ }
+ MEM_freeN(strip);
+}
+
+void new_stripdata(Sequence *seq)
+{
+
+ if(seq->strip) {
+ if(seq->strip->stripdata) free_stripdata(seq->strip->len, seq->strip->stripdata);
+ seq->strip->stripdata= 0;
+ seq->strip->len= seq->len;
+ if(seq->len>0) seq->strip->stripdata= MEM_callocN(seq->len*sizeof(StripElem), "stripelems");
+ }
+}
+
+void free_sequence(Sequence *seq)
+{
+ extern Sequence *last_seq;
+
+ if(seq->strip) free_strip(seq->strip);
+
+ if(seq->anim) IMB_free_anim(seq->anim);
+
+ free_plugin_seq(seq->plugin);
+
+ if(seq==last_seq) last_seq= 0;
+
+ MEM_freeN(seq);
+}
+
+void do_seq_count(ListBase *seqbase, int *totseq)
+{
+ Sequence *seq;
+
+ seq= seqbase->first;
+ while(seq) {
+ (*totseq)++;
+ if(seq->seqbase.first) do_seq_count(&seq->seqbase, totseq);
+ seq= seq->next;
+ }
+}
+
+void do_build_seqar(ListBase *seqbase, Sequence ***seqar, int depth)
+{
+ Sequence *seq;
+
+ seq= seqbase->first;
+ while(seq) {
+ seq->depth= depth;
+ if(seq->seqbase.first) do_build_seqar(&seq->seqbase, seqar, depth+1);
+ **seqar= seq;
+ (*seqar)++;
+ seq= seq->next;
+ }
+}
+
+void build_seqar(ListBase *seqbase, Sequence ***seqar, int *totseq)
+{
+ Sequence **tseqar;
+
+ *totseq= 0;
+ do_seq_count(seqbase, totseq);
+
+ if(*totseq==0) {
+ *seqar= 0;
+ return;
+ }
+ *seqar= MEM_mallocN(sizeof(void *)* *totseq, "seqar");
+ tseqar= *seqar;
+
+ do_build_seqar(seqbase, seqar, 0);
+ *seqar= tseqar;
+}
+
+void free_editing(Editing *ed)
+{
+ MetaStack *ms;
+ Sequence *seq;
+
+ if(ed==0) return;
+
+ WHILE_SEQ(&ed->seqbase) {
+ free_sequence(seq);
+ }
+ END_SEQ
+
+ while( (ms= ed->metastack.first) ) {
+ BLI_remlink(&ed->metastack, ms);
+ MEM_freeN(ms);
+ }
+
+ MEM_freeN(ed);
+}
+
+void calc_sequence(Sequence *seq)
+{
+ Sequence *seqm;
+ int min, max;
+
+ /* eerst recursief alle meta's aflopen */
+ seqm= seq->seqbase.first;
+ while(seqm) {
+ if(seqm->seqbase.first) calc_sequence(seqm);
+ seqm= seqm->next;
+ }
+
+ /* effecten: en meta automatische start en end */
+
+ if(seq->type & SEQ_EFFECT) {
+ /* pointers */
+ if(seq->seq2==0) seq->seq2= seq->seq1;
+ if(seq->seq3==0) seq->seq3= seq->seq1;
+
+ /* effecten gaan van seq1 -> seq2: testen */
+
+ /* we nemen de grootste start en de kleinste eind */
+
+ // seq->start= seq->startdisp= MAX2(seq->seq1->startdisp, seq->seq2->startdisp);
+ // seq->enddisp= MIN2(seq->seq1->enddisp, seq->seq2->enddisp);
+
+ seq->start= seq->startdisp= MAX3(seq->seq1->startdisp, seq->seq2->startdisp, seq->seq3->startdisp);
+ seq->enddisp= MIN3(seq->seq1->enddisp, seq->seq2->enddisp, seq->seq3->enddisp);
+ seq->len= seq->enddisp - seq->startdisp;
+
+ if(seq->strip && seq->len!=seq->strip->len) {
+ new_stripdata(seq);
+ }
+
+ }
+ else {
+ if(seq->type==SEQ_META) {
+ seqm= seq->seqbase.first;
+ if(seqm) {
+ min= 1000000;
+ max= -1000000;
+ while(seqm) {
+ if(seqm->startdisp < min) min= seqm->startdisp;
+ if(seqm->enddisp > max) max= seqm->enddisp;
+ seqm= seqm->next;
+ }
+ seq->start= min;
+ seq->len= max-min;
+
+ if(seq->strip && seq->len!=seq->strip->len) {
+ new_stripdata(seq);
+ }
+ }
+ }
+
+
+ if(seq->startofs && seq->startstill) seq->startstill= 0;
+ if(seq->endofs && seq->endstill) seq->endstill= 0;
+
+ seq->startdisp= seq->start + seq->startofs - seq->startstill;
+ seq->enddisp= seq->start+seq->len - seq->endofs + seq->endstill;
+
+ seq->handsize= 10.0; /* 10 frames */
+ if( seq->enddisp-seq->startdisp < 20 ) {
+ seq->handsize= (float)(0.5*(seq->enddisp-seq->startdisp));
+ }
+ else if(seq->enddisp-seq->startdisp > 250) {
+ seq->handsize= (float)((seq->enddisp-seq->startdisp)/25);
+ }
+ }
+}
+
+void sort_seq()
+{
+ /* alle strips in soort bij elkaar en op volgorde van machine */
+ ListBase seqbase, effbase;
+ Editing *ed;
+ Sequence *seq, *seqt;
+
+ ed= G.scene->ed;
+ if(ed==0) return;
+
+ seqbase.first= seqbase.last= 0;
+ effbase.first= effbase.last= 0;
+
+ while( (seq= ed->seqbasep->first) ) {
+ BLI_remlink(ed->seqbasep, seq);
+
+ if(seq->type & SEQ_EFFECT) {
+ seqt= effbase.first;
+ while(seqt) {
+ if(seqt->machine>=seq->machine) {
+ BLI_insertlinkbefore(&effbase, seqt, seq);
+ break;
+ }
+ seqt= seqt->next;
+ }
+ if(seqt==0) BLI_addtail(&effbase, seq);
+ }
+ else {
+ seqt= seqbase.first;
+ while(seqt) {
+ if(seqt->machine>=seq->machine) {
+ BLI_insertlinkbefore(&seqbase, seqt, seq);
+ break;
+ }
+ seqt= seqt->next;
+ }
+ if(seqt==0) BLI_addtail(&seqbase, seq);
+ }
+ }
+
+ addlisttolist(&seqbase, &effbase);
+ *(ed->seqbasep)= seqbase;
+}
+
+
+void clear_scene_in_allseqs(Scene *sce)
+{
+ Scene *sce1;
+ Editing *ed;
+ Sequence *seq;
+
+ /* als er een scene delete is: alle seqs testen */
+
+ sce1= G.main->scene.first;
+ while(sce1) {
+ if(sce1!=sce && sce1->ed) {
+ ed= sce1->ed;
+
+ WHILE_SEQ(&ed->seqbase) {
+
+ if(seq->scene==sce) seq->scene= 0;
+
+ }
+ END_SEQ
+ }
+
+ sce1= sce1->id.next;
+ }
+}
+
+/* ***************** DO THE SEQUENCE ***************** */
+
+void do_alphaover_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+ int fac2, mfac, fac, fac4;
+ int xo, tempc;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac2= (int)(256.0*facf0);
+ fac4= (int)(256.0*facf1);
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ /* rt = rt1 over rt2 (alpha van rt1) */
+
+ fac= fac2;
+ mfac= 256 - ( (fac2*rt1[3])>>8 );
+
+ if(fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+ else if(mfac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+ else {
+ tempc= ( fac*rt1[0] + mfac*rt2[0])>>8;
+ if(tempc>255) rt[0]= 255; else rt[0]= tempc;
+ tempc= ( fac*rt1[1] + mfac*rt2[1])>>8;
+ if(tempc>255) rt[1]= 255; else rt[1]= tempc;
+ tempc= ( fac*rt1[2] + mfac*rt2[2])>>8;
+ if(tempc>255) rt[2]= 255; else rt[2]= tempc;
+ tempc= ( fac*rt1[3] + mfac*rt2[3])>>8;
+ if(tempc>255) rt[3]= 255; else rt[3]= tempc;
+ }
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ fac= fac4;
+ mfac= 256 - ( (fac4*rt1[3])>>8 );
+
+ if(fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+ else if(mfac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+ else {
+ tempc= ( fac*rt1[0] + mfac*rt2[0])>>8;
+ if(tempc>255) rt[0]= 255; else rt[0]= tempc;
+ tempc= ( fac*rt1[1] + mfac*rt2[1])>>8;
+ if(tempc>255) rt[1]= 255; else rt[1]= tempc;
+ tempc= ( fac*rt1[2] + mfac*rt2[2])>>8;
+ if(tempc>255) rt[2]= 255; else rt[2]= tempc;
+ tempc= ( fac*rt1[3] + mfac*rt2[3])>>8;
+ if(tempc>255) rt[3]= 255; else rt[3]= tempc;
+ }
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+}
+
+void do_alphaunder_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+ int fac2, mfac, fac, fac4;
+ int xo;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac2= (int)(256.0*facf0);
+ fac4= (int)(256.0*facf1);
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ /* rt = rt1 under rt2 (alpha van rt2) */
+
+ /* deze ingewikkelde optimalisering is omdat
+ * de 'skybuf' ingecrosst kan worden
+ */
+ if(rt2[3]==0 && fac2==256) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+ else if(rt2[3]==255) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+ else {
+ mfac= rt2[3];
+ fac= (fac2*(256-mfac))>>8;
+
+ if(fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+ else {
+ rt[0]= ( fac*rt1[0] + mfac*rt2[0])>>8;
+ rt[1]= ( fac*rt1[1] + mfac*rt2[1])>>8;
+ rt[2]= ( fac*rt1[2] + mfac*rt2[2])>>8;
+ rt[3]= ( fac*rt1[3] + mfac*rt2[3])>>8;
+ }
+ }
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ if(rt2[3]==0 && fac4==256) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+ else if(rt2[3]==255) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+ else {
+ mfac= rt2[3];
+ fac= (fac4*(256-mfac))>>8;
+
+ if(fac==0) *( (unsigned int *)rt) = *( (unsigned int *)rt2);
+ else {
+ rt[0]= ( fac*rt1[0] + mfac*rt2[0])>>8;
+ rt[1]= ( fac*rt1[1] + mfac*rt2[1])>>8;
+ rt[2]= ( fac*rt1[2] + mfac*rt2[2])>>8;
+ rt[3]= ( fac*rt1[3] + mfac*rt2[3])>>8;
+ }
+ }
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+}
+
+
+void do_cross_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+ int fac1, fac2, fac3, fac4;
+ int xo;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac2= (int)(256.0*facf0);
+ fac1= 256-fac2;
+ fac4= (int)(256.0*facf1);
+ fac3= 256-fac4;
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ rt[0]= (fac1*rt1[0] + fac2*rt2[0])>>8;
+ rt[1]= (fac1*rt1[1] + fac2*rt2[1])>>8;
+ rt[2]= (fac1*rt1[2] + fac2*rt2[2])>>8;
+ rt[3]= (fac1*rt1[3] + fac2*rt2[3])>>8;
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ rt[0]= (fac3*rt1[0] + fac4*rt2[0])>>8;
+ rt[1]= (fac3*rt1[1] + fac4*rt2[1])>>8;
+ rt[2]= (fac3*rt1[2] + fac4*rt2[2])>>8;
+ rt[3]= (fac3*rt1[3] + fac4*rt2[3])>>8;
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ }
+}
+
+void do_gammacross_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+/* extern unsigned short *igamtab1, *gamtab; render.h */
+ int fac1, fac2, col;
+ int xo;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac2= (int)(256.0*facf0);
+ fac1= 256-fac2;
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ col= (fac1*igamtab1[rt1[0]] + fac2*igamtab1[rt2[0]])>>8;
+ if(col>65535) rt[0]= 255; else rt[0]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+ col=(fac1*igamtab1[rt1[1]] + fac2*igamtab1[rt2[1]])>>8;
+ if(col>65535) rt[1]= 255; else rt[1]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+ col= (fac1*igamtab1[rt1[2]] + fac2*igamtab1[rt2[2]])>>8;
+ if(col>65535) rt[2]= 255; else rt[2]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+ col= (fac1*igamtab1[rt1[3]] + fac2*igamtab1[rt2[3]])>>8;
+ if(col>65535) rt[3]= 255; else rt[3]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ col= (fac1*igamtab1[rt1[0]] + fac2*igamtab1[rt2[0]])>>8;
+ if(col>65535) rt[0]= 255; else rt[0]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+ col= (fac1*igamtab1[rt1[1]] + fac2*igamtab1[rt2[1]])>>8;
+ if(col>65535) rt[1]= 255; else rt[1]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+ col= (fac1*igamtab1[rt1[2]] + fac2*igamtab1[rt2[2]])>>8;
+ if(col>65535) rt[2]= 255; else rt[2]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+ col= (fac1*igamtab1[rt1[3]] + fac2*igamtab1[rt2[3]])>>8;
+ if(col>65535) rt[3]= 255; else rt[3]= ( (char *)(gamtab+col))[MOST_SIG_BYTE];
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ }
+}
+
+void do_add_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+ int col, xo, fac1, fac3;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac1= (int)(256.0*facf0);
+ fac3= (int)(256.0*facf1);
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ col= rt1[0]+ ((fac1*rt2[0])>>8);
+ if(col>255) rt[0]= 255; else rt[0]= col;
+ col= rt1[1]+ ((fac1*rt2[1])>>8);
+ if(col>255) rt[1]= 255; else rt[1]= col;
+ col= rt1[2]+ ((fac1*rt2[2])>>8);
+ if(col>255) rt[2]= 255; else rt[2]= col;
+ col= rt1[3]+ ((fac1*rt2[3])>>8);
+ if(col>255) rt[3]= 255; else rt[3]= col;
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ col= rt1[0]+ ((fac3*rt2[0])>>8);
+ if(col>255) rt[0]= 255; else rt[0]= col;
+ col= rt1[1]+ ((fac3*rt2[1])>>8);
+ if(col>255) rt[1]= 255; else rt[1]= col;
+ col= rt1[2]+ ((fac3*rt2[2])>>8);
+ if(col>255) rt[2]= 255; else rt[2]= col;
+ col= rt1[3]+ ((fac3*rt2[3])>>8);
+ if(col>255) rt[3]= 255; else rt[3]= col;
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+}
+
+void do_sub_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+ int col, xo, fac1, fac3;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac1= (int)(256.0*facf0);
+ fac3= (int)(256.0*facf1);
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ col= rt1[0]- ((fac1*rt2[0])>>8);
+ if(col<0) rt[0]= 0; else rt[0]= col;
+ col= rt1[1]- ((fac1*rt2[1])>>8);
+ if(col<0) rt[1]= 0; else rt[1]= col;
+ col= rt1[2]- ((fac1*rt2[2])>>8);
+ if(col<0) rt[2]= 0; else rt[2]= col;
+ col= rt1[3]- ((fac1*rt2[3])>>8);
+ if(col<0) rt[3]= 0; else rt[3]= col;
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ col= rt1[0]- ((fac3*rt2[0])>>8);
+ if(col<0) rt[0]= 0; else rt[0]= col;
+ col= rt1[1]- ((fac3*rt2[1])>>8);
+ if(col<0) rt[1]= 0; else rt[1]= col;
+ col= rt1[2]- ((fac3*rt2[2])>>8);
+ if(col<0) rt[2]= 0; else rt[2]= col;
+ col= rt1[3]- ((fac3*rt2[3])>>8);
+ if(col<0) rt[3]= 0; else rt[3]= col;
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+}
+
+/* Must be > 0 or add precopy, etc to the function */
+#define XOFF 8
+#define YOFF 8
+
+void do_drop_effect(float facf0, float facf1, int x, int y, unsigned int *rect2i, unsigned int *rect1i, unsigned int *outi)
+{
+ int height, width, temp, fac, fac1, fac2;
+ char *rt1, *rt2, *out;
+ int field= 1;
+
+ width= x;
+ height= y;
+
+ fac1= (int)(70.0*facf0);
+ fac2= (int)(70.0*facf1);
+
+ rt2= (char*) (rect2i + YOFF*width);
+ rt1= (char*) rect1i;
+ out= (char*) outi;
+ for (y=0; y<height-YOFF; y++) {
+ if(field) fac= fac1;
+ else fac= fac2;
+ field= !field;
+
+ memcpy(out, rt1, sizeof(int)*XOFF);
+ rt1+= XOFF*4;
+ out+= XOFF*4;
+
+ for (x=XOFF; x<width; x++) {
+ temp= ((fac*rt2[3])>>8);
+
+ *(out++)= MAX2(0, *rt1 - temp); rt1++;
+ *(out++)= MAX2(0, *rt1 - temp); rt1++;
+ *(out++)= MAX2(0, *rt1 - temp); rt1++;
+ *(out++)= MAX2(0, *rt1 - temp); rt1++;
+ rt2+=4;
+ }
+ rt2+=XOFF*4;
+ }
+ memcpy(out, rt1, sizeof(int)*YOFF*width);
+}
+
+ /* L E T O P: rect2 en rect1 omgekeerd */
+void do_drop_effect2(float facf0, float facf1, int x, int y, unsigned int *rect2, unsigned int *rect1, unsigned int *out)
+{
+ int col, xo, yo, temp, fac1, fac3;
+ int xofs= -8, yofs= 8;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ yo= y;
+
+ rt2= (char *)(rect2 + yofs*x + xofs);
+
+ rt1= (char *)rect1;
+ rt= (char *)out;
+
+ fac1= (int)(70.0*facf0);
+ fac3= (int)(70.0*facf1);
+
+ while(y-- > 0) {
+
+ temp= y-yofs;
+ if(temp > 0 && temp < yo) {
+
+ x= xo;
+ while(x--) {
+
+ temp= x+xofs;
+ if(temp > 0 && temp < xo) {
+
+ temp= ((fac1*rt2[3])>>8);
+
+ col= rt1[0]- temp;
+ if(col<0) rt[0]= 0; else rt[0]= col;
+ col= rt1[1]- temp;
+ if(col<0) rt[1]= 0; else rt[1]= col;
+ col= rt1[2]- temp;
+ if(col<0) rt[2]= 0; else rt[2]= col;
+ col= rt1[3]- temp;
+ if(col<0) rt[3]= 0; else rt[3]= col;
+ }
+ else *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+ else {
+ x= xo;
+ while(x--) {
+ *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+
+ if(y==0) break;
+ y--;
+
+ temp= y-yofs;
+ if(temp > 0 && temp < yo) {
+
+ x= xo;
+ while(x--) {
+
+ temp= x+xofs;
+ if(temp > 0 && temp < xo) {
+
+ temp= ((fac3*rt2[3])>>8);
+
+ col= rt1[0]- temp;
+ if(col<0) rt[0]= 0; else rt[0]= col;
+ col= rt1[1]- temp;
+ if(col<0) rt[1]= 0; else rt[1]= col;
+ col= rt1[2]- temp;
+ if(col<0) rt[2]= 0; else rt[2]= col;
+ col= rt1[3]- temp;
+ if(col<0) rt[3]= 0; else rt[3]= col;
+ }
+ else *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+ else {
+ x= xo;
+ while(x--) {
+ *( (unsigned int *)rt) = *( (unsigned int *)rt1);
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+ }
+}
+
+
+void do_mul_effect(float facf0, float facf1, int x, int y, unsigned int *rect1, unsigned int *rect2, unsigned int *out)
+{
+ int xo, fac1, fac3;
+ char *rt1, *rt2, *rt;
+
+ xo= x;
+ rt1= (char *)rect1;
+ rt2= (char *)rect2;
+ rt= (char *)out;
+
+ fac1= (int)(256.0*facf0);
+ fac3= (int)(256.0*facf1);
+
+ /* formule:
+ * fac*(a*b) + (1-fac)*a => fac*a*(b-1)+a
+ */
+
+ while(y--) {
+
+ x= xo;
+ while(x--) {
+
+ rt[0]= rt1[0] + ((fac1*rt1[0]*(rt2[0]-256))>>16);
+ rt[1]= rt1[1] + ((fac1*rt1[1]*(rt2[1]-256))>>16);
+ rt[2]= rt1[2] + ((fac1*rt1[2]*(rt2[2]-256))>>16);
+ rt[3]= rt1[3] + ((fac1*rt1[3]*(rt2[3]-256))>>16);
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+
+ if(y==0) break;
+ y--;
+
+ x= xo;
+ while(x--) {
+
+ rt[0]= rt1[0] + ((fac3*rt1[0]*(rt2[0]-256))>>16);
+ rt[1]= rt1[1] + ((fac3*rt1[1]*(rt2[1]-256))>>16);
+ rt[2]= rt1[2] + ((fac3*rt1[2]*(rt2[2]-256))>>16);
+ rt[3]= rt1[3] + ((fac3*rt1[3]*(rt2[3]-256))>>16);
+
+ rt1+= 4; rt2+= 4; rt+= 4;
+ }
+ }
+}
+
+void make_black_ibuf(ImBuf *ibuf)
+{
+ unsigned int *rect;
+ int tot;
+
+ if(ibuf==0 || ibuf->rect==0) return;
+
+ tot= ibuf->x*ibuf->y;
+ rect= ibuf->rect;
+ while(tot--) *(rect++)= 0;
+
+}
+
+void multibuf(ImBuf *ibuf, float fmul)
+{
+ char *rt;
+ int a, mul, icol;
+
+ mul= (int)(256.0*fmul);
+
+ a= ibuf->x*ibuf->y;
+ rt= (char *)ibuf->rect;
+ while(a--) {
+
+ icol= (mul*rt[0])>>8;
+ if(icol>254) rt[0]= 255; else rt[0]= icol;
+ icol= (mul*rt[1])>>8;
+ if(icol>254) rt[1]= 255; else rt[1]= icol;
+ icol= (mul*rt[2])>>8;
+ if(icol>254) rt[2]= 255; else rt[2]= icol;
+ icol= (mul*rt[3])>>8;
+ if(icol>254) rt[3]= 255; else rt[3]= icol;
+
+ rt+= 4;
+ }
+}
+
+void do_effect(int cfra, Sequence *seq, StripElem *se)
+{
+ StripElem *se1, *se2, *se3;
+ float fac, facf;
+ int x, y;
+ char *cp;
+
+ if(se->se1==0 || se->se2==0 || se->se3==0) {
+ make_black_ibuf(se->ibuf);
+ return;
+ }
+
+ /* als metastrip: andere se's */
+ if(se->se1->ok==2) se1= se->se1->se1;
+ else se1= se->se1;
+
+ if(se->se2->ok==2) se2= se->se2->se1;
+ else se2= se->se2;
+
+ if(se->se3->ok==2) se3= se->se3->se1;
+ else se3= se->se3;
+
+ if(se1==0 || se2==0 || se3==0 || se1->ibuf==0 || se2->ibuf==0 || se3->ibuf==0) {
+ make_black_ibuf(se->ibuf);
+ return;
+ }
+
+ x= se2->ibuf->x;
+ y= se2->ibuf->y;
+
+ if(seq->ipo && seq->ipo->curve.first) {
+ do_seq_ipo(seq);
+ fac= seq->facf0;
+ facf= seq->facf1;
+ }
+ else if ELEM3( seq->type, SEQ_CROSS, SEQ_GAMCROSS, SEQ_PLUGIN) {
+ fac= (float)(cfra - seq->startdisp);
+ facf= (float)(fac+0.5);
+ fac /= seq->len;
+ facf /= seq->len;
+ }
+ else {
+ fac= facf= 1.0;
+ }
+
+ if( G.scene->r.mode & R_FIELDS ); else facf= fac;
+
+ switch(seq->type) {
+ case SEQ_CROSS:
+ do_cross_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_GAMCROSS:
+ do_gammacross_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_ADD:
+ do_add_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_SUB:
+ do_sub_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_MUL:
+ do_mul_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_ALPHAOVER:
+ do_alphaover_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_OVERDROP:
+ do_drop_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ do_alphaover_effect(fac, facf, x, y, se1->ibuf->rect, se->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_ALPHAUNDER:
+ do_alphaunder_effect(fac, facf, x, y, se1->ibuf->rect, se2->ibuf->rect, se->ibuf->rect);
+ break;
+ case SEQ_PLUGIN:
+ if(seq->plugin && seq->plugin->doit) {
+
+ if((G.f & G_PLAYANIM)==0) waitcursor(1);
+
+ if(seq->plugin->cfra) *(seq->plugin->cfra)= frame_to_float(CFRA);
+
+ cp= PIL_dynlib_find_symbol(seq->plugin->handle, "seqname");
+ if(cp) strcpy(cp, seq->name+2);
+
+ if (seq->plugin->version<=2) {
+ if(se1->ibuf) IMB_convert_rgba_to_abgr(se1->ibuf->x*se1->ibuf->y, se1->ibuf->rect);
+ if(se2->ibuf) IMB_convert_rgba_to_abgr(se2->ibuf->x*se2->ibuf->y, se2->ibuf->rect);
+ if(se3->ibuf) IMB_convert_rgba_to_abgr(se3->ibuf->x*se3->ibuf->y, se3->ibuf->rect);
+ }
+
+ ((SeqDoit)seq->plugin->doit)(seq->plugin->data, fac, facf, x, y,
+ se1->ibuf, se2->ibuf, se->ibuf, se3->ibuf);
+
+ if (seq->plugin->version<=2) {
+ if(se1->ibuf) IMB_convert_rgba_to_abgr(se1->ibuf->x*se1->ibuf->y, se1->ibuf->rect);
+ if(se2->ibuf) IMB_convert_rgba_to_abgr(se2->ibuf->x*se2->ibuf->y, se2->ibuf->rect);
+ if(se3->ibuf) IMB_convert_rgba_to_abgr(se3->ibuf->x*se3->ibuf->y, se3->ibuf->rect);
+ IMB_convert_rgba_to_abgr(se->ibuf->x*se->ibuf->y, se->ibuf->rect);
+ }
+
+ if((G.f & G_PLAYANIM)==0) waitcursor(0);
+ }
+ break;
+ }
+
+}
+
+int evaluate_seq_frame(int cfra)
+{
+ Sequence *seq;
+ Editing *ed;
+ int totseq=0;
+
+ memset(seq_arr, 0, 4*MAXSEQ);
+
+ ed= G.scene->ed;
+ if(ed==0) return 0;
+
+ seq= ed->seqbasep->first;
+ while(seq) {
+ if(seq->startdisp <=cfra && seq->enddisp > cfra) {
+ seq_arr[seq->machine]= seq;
+ totseq++;
+ }
+ seq= seq->next;
+ }
+
+ return totseq;
+}
+
+StripElem *give_stripelem(Sequence *seq, int cfra)
+{
+ Strip *strip;
+ StripElem *se;
+ int nr;
+
+ strip= seq->strip;
+ se= strip->stripdata;
+
+ if(se==0) return 0;
+ if(seq->startdisp >cfra || seq->enddisp <= cfra) return 0;
+
+ if(cfra <= seq->start) nr= 0;
+ else if(cfra >= seq->start+seq->len-1) nr= seq->len-1;
+ else nr= cfra-seq->start;
+
+ se+= nr;
+ se->nr= nr;
+
+ return se;
+}
+
+void set_meta_stripdata(Sequence *seqm)
+{
+ Sequence *seq, *seqim, *seqeff;
+ Editing *ed;
+ ListBase *tempbase;
+ StripElem *se;
+ int a, cfra, b;
+
+ /* zet alle ->se1 pointers in stripdata, dan kan daar de ibuf uitgelezen */
+
+ ed= G.scene->ed;
+ if(ed==0) return;
+
+ tempbase= ed->seqbasep;
+ ed->seqbasep= &seqm->seqbase;
+
+ se= seqm->strip->stripdata;
+ for(a=0; a<seqm->len; a++, se++) {
+ cfra= a+seqm->start;
+ if(evaluate_seq_frame(cfra)) {
+
+ /* we nemen de hoogste effectstrip of de laagste imagestrip/metastrip */
+ seqim= seqeff= 0;
+
+ for(b=1; b<MAXSEQ; b++) {
+ if(seq_arr[b]) {
+ seq= seq_arr[b];
+ if(seq->type & SEQ_EFFECT) {
+ if(seqeff==0) seqeff= seq;
+ else if(seqeff->machine < seq->machine) seqeff= seq;
+ }
+ else {
+ if(seqim==0) seqim= seq;
+ else if(seqim->machine > seq->machine) seqim= seq;
+ }
+ }
+ }
+ if(seqeff) seq= seqeff;
+ else if(seqim) seq= seqim;
+ else seq= 0;
+
+ if(seq) {
+ se->se1= give_stripelem(seq, cfra);
+ }
+ else se->se1= 0;
+ }
+ }
+
+ ed->seqbasep= tempbase;
+}
+
+
+
+/* HULPFUNKTIES VOOR GIVE_IBUF_SEQ */
+
+void do_seq_count_cfra(ListBase *seqbase, int *totseq, int cfra)
+{
+ Sequence *seq;
+
+ seq= seqbase->first;
+ while(seq) {
+ if(seq->startdisp <=cfra && seq->enddisp > cfra) {
+
+ if(seq->seqbase.first) {
+
+ if(cfra< seq->start) do_seq_count_cfra(&seq->seqbase, totseq, seq->start);
+ else if(cfra> seq->start+seq->len-1) do_seq_count_cfra(&seq->seqbase, totseq, seq->start+seq->len-1);
+ else do_seq_count_cfra(&seq->seqbase, totseq, cfra);
+ }
+
+ (*totseq)++;
+ }
+ seq= seq->next;
+ }
+}
+
+void do_build_seqar_cfra(ListBase *seqbase, Sequence ***seqar, int cfra)
+{
+ Sequence *seq;
+ StripElem *se;
+ Scene *oldsce;
+ unsigned int *rectot;
+ int oldx, oldy, oldcfra, doseq;
+ char name[FILE_MAXDIR];
+
+ seq= seqbase->first;
+ while(seq) {
+
+ /* op nul zetten ivm free_imbuf_seq... */
+ seq->curelem= 0;
+
+ if(seq->startdisp <=cfra && seq->enddisp > cfra) {
+
+ if(seq->seqbase.first) {
+ if(cfra< seq->start) do_build_seqar_cfra(&seq->seqbase, seqar, seq->start);
+ else if(cfra> seq->start+seq->len-1) do_build_seqar_cfra(&seq->seqbase, seqar, seq->start+seq->len-1);
+ else do_build_seqar_cfra(&seq->seqbase, seqar, cfra);
+ }
+
+ **seqar= seq;
+ (*seqar)++;
+
+ se=seq->curelem= give_stripelem(seq, cfra);
+
+ if(se) {
+ if(seq->type == SEQ_META) {
+ se->ok= 2;
+ if(se->se1==0) set_meta_stripdata(seq);
+ if(se->se1) {
+ se->ibuf= se->se1->ibuf;
+ }
+ }
+ else if(seq->type & SEQ_EFFECT) {
+
+ /* testen of image te klein is: opnieuw maken */
+ if(se->ibuf) {
+ if(se->ibuf->x < seqrectx || se->ibuf->y < seqrecty) {
+ IMB_freeImBuf(se->ibuf);
+ se->ibuf= 0;
+ }
+ }
+
+ /* moet het effect (opnieuw) berekend? */
+
+ if(se->ibuf==0 || (se->se1 != seq->seq1->curelem) || (se->se2 != seq->seq2->curelem) || (se->se3 != seq->seq3->curelem)) {
+ se->se1= seq->seq1->curelem;
+ se->se2= seq->seq2->curelem;
+ se->se3= seq->seq3->curelem;
+
+ if(se->ibuf==0) se->ibuf= IMB_allocImBuf((short)seqrectx, (short)seqrecty, 32, IB_rect, 0);
+
+ do_effect(cfra, seq, se);
+ }
+
+ /* size testen */
+ if(se->ibuf) {
+ if(se->ibuf->x != seqrectx || se->ibuf->y != seqrecty ) {
+ if(G.scene->r.mode & R_OSA)
+ IMB_scaleImBuf(se->ibuf, (short)seqrectx, (short)seqrecty);
+ else
+ IMB_scalefastImBuf(se->ibuf, (short)seqrectx, (short)seqrecty);
+ }
+ }
+ }
+ else if(seq->type < SEQ_EFFECT) {
+
+ if(se->ibuf) {
+ /* testen of image te klein is: opnieuw laden */
+ if(se->ibuf->x < seqrectx || se->ibuf->y < seqrecty) {
+ IMB_freeImBuf(se->ibuf);
+ se->ibuf= 0;
+ se->ok= 1;
+ }
+ }
+
+ if(seq->type==SEQ_IMAGE) {
+ if(se->ok && se->ibuf==0) {
+
+ /* als playanim of render: geen waitcursor doen */
+ if((G.f & G_PLAYANIM)==0) waitcursor(1);
+
+ strcpy(name, seq->strip->dir);
+ strcat(name, se->name);
+ BLI_convertstringcode(name, G.sce, G.scene->r.cfra);
+ se->ibuf= IMB_loadiffname(name, IB_rect);
+
+ if((G.f & G_PLAYANIM)==0) waitcursor(0);
+
+ if(se->ibuf==0) se->ok= 0;
+ else {
+ if(se->ibuf->depth==32 && se->ibuf->zbuf==0) converttopremul(se->ibuf);
+ seq->strip->orx= se->ibuf->x;
+ seq->strip->ory= se->ibuf->y;
+ }
+ }
+ }
+ else if(seq->type==SEQ_MOVIE) {
+ if(se->ok && se->ibuf==0) {
+
+ /* als playanim of render: geen waitcursor doen */
+ if((G.f & G_PLAYANIM)==0) waitcursor(1);
+
+ if(seq->anim==0) {
+ strcpy(name, seq->strip->dir);
+ strcat(name, seq->strip->stripdata->name);
+ BLI_convertstringcode(name, G.sce, G.scene->r.cfra);
+
+ seq->anim = openanim(name, IB_rect);
+ }
+ if(seq->anim) {
+ se->ibuf = IMB_anim_absolute(seq->anim, se->nr);
+ }
+
+ if(se->ibuf==0) se->ok= 0;
+ else {
+ if(se->ibuf->depth==32) converttopremul(se->ibuf);
+ seq->strip->orx= se->ibuf->x;
+ seq->strip->ory= se->ibuf->y;
+ if(seq->flag & SEQ_FILTERY) IMB_filtery(se->ibuf);
+ if(seq->mul==0.0) seq->mul= 1.0;
+ if(seq->mul != 1.0) multibuf(se->ibuf, seq->mul);
+ }
+ if((G.f & G_PLAYANIM)==0) waitcursor(0);
+ }
+ }
+ else if(seq->type==SEQ_SCENE && se->ibuf==0) {
+ View3D *vd;
+
+ oldsce= G.scene;
+ set_scene_bg(seq->scene);
+
+ /* oneindige lus voorkomen */
+ doseq= G.scene->r.scemode & R_DOSEQ;
+ G.scene->r.scemode &= ~R_DOSEQ;
+
+ /* vanalles bewaren */
+ oldcfra= CFRA; CFRA= seq->sfra + se->nr;
+ waitcursor(1);
+
+ rectot= R.rectot; R.rectot= 0;
+ oldx= R.rectx; oldy= R.recty;
+ /* dit is nodig omdat de huidige 3D window niet de layers mag leveren, alsof het background render is */
+ vd= G.vd;
+ G.vd= 0;
+
+ RE_initrender(NULL);
+ if (!G.background) {
+ if(R.r.mode & R_FIELDS) update_for_newframe();
+ R.flag= 0;
+
+ free_filesel_spec(G.scene->r.pic);
+ }
+
+ se->ibuf= IMB_allocImBuf(R.rectx, R.recty, 32, IB_rect, 0);
+ if(R.rectot) memcpy(se->ibuf->rect, R.rectot, 4*R.rectx*R.recty);
+ if(R.rectz) {
+ se->ibuf->zbuf= (int *)R.rectz;
+ /* make sure ibuf frees it */
+ se->ibuf->mall |= IB_zbuf;
+ R.rectz= 0;
+ }
+
+ /* and restore */
+ G.vd= vd;
+
+ if((G.f & G_PLAYANIM)==0) waitcursor(0);
+ CFRA= oldcfra;
+ if(R.rectot) MEM_freeN(R.rectot);
+ R.rectot= rectot;
+ R.rectx=oldx; R.recty=oldy;
+ G.scene->r.scemode |= doseq;
+ set_scene_bg(oldsce);
+
+ /* restore!! */
+ R.rectx= seqrectx;
+ R.recty= seqrecty;
+
+ /* added because this flag is checked for
+ * movie writing when rendering an anim.
+ * very convoluted. fix. -zr
+ */
+ R.r.imtype= G.scene->r.imtype;
+ }
+
+ /* size testen */
+ if(se->ibuf) {
+ if(se->ibuf->x != seqrectx || se->ibuf->y != seqrecty ) {
+
+ if (G.scene->r.mode & R_FIELDS) {
+
+ if (seqrecty > 288) IMB_scalefieldImBuf(se->ibuf, (short)seqrectx, (short)seqrecty);
+ else {
+ IMB_de_interlace(se->ibuf);
+
+ if(G.scene->r.mode & R_OSA)
+ IMB_scaleImBuf(se->ibuf, (short)seqrectx, (short)seqrecty);
+ else
+ IMB_scalefastImBuf(se->ibuf, (short)seqrectx, (short)seqrecty);
+ }
+ }
+ else {
+ if(G.scene->r.mode & R_OSA)
+ IMB_scaleImBuf(se->ibuf,(short)seqrectx, (short)seqrecty);
+ else
+ IMB_scalefastImBuf(se->ibuf, (short)seqrectx, (short)seqrecty);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ seq= seq->next;
+ }
+}
+
+ImBuf *give_ibuf_seq(int cfra)
+{
+ Sequence **tseqar, **seqar;
+ Sequence *seq, *seqfirst=0;/* , *effirst=0; */
+ Editing *ed;
+ StripElem *se;
+ int seqnr, totseq;
+
+ /* we maken recursief een 'stack' van sequences, deze is ook
+ * gesorteerd en kan gewoon doorlopen worden.
+ * Deze methode is vooral ontwikkeld voor stills voor en achter meta's
+ */
+
+ totseq= 0;
+ ed= G.scene->ed;
+ if(ed==0) return 0;
+ do_seq_count_cfra(ed->seqbasep, &totseq, cfra);
+
+ if(totseq==0) return 0;
+
+ seqrectx= (G.scene->r.size*G.scene->r.xsch)/100;
+ if(G.scene->r.mode & R_PANORAMA) seqrectx*= G.scene->r.xparts;
+ seqrecty= (G.scene->r.size*G.scene->r.ysch)/100;
+
+
+ /* tseqar is nodig omdat in do_build_... de pointer verandert */
+ seqar= tseqar= MEM_callocN(sizeof(void *)*totseq, "seqar");
+
+ /* deze fie laadt en maakt ook de ibufs */
+ do_build_seqar_cfra(ed->seqbasep, &seqar, cfra);
+ seqar= tseqar;
+
+ for(seqnr=0; seqnr<totseq; seqnr++) {
+ seq= seqar[seqnr];
+
+ se= seq->curelem;
+ if(se) {
+ if(seq->type==SEQ_META) {
+
+ /* onderste strip! */
+ if(seqfirst==0) seqfirst= seq;
+ else if(seqfirst->depth > seq->depth) seqfirst= seq;
+ else if(seqfirst->machine > seq->machine) seqfirst= seq;
+
+ }
+ else if(seq->type & SEQ_EFFECT) {
+
+ /* bovenste strip! */
+ if(seqfirst==0) seqfirst= seq;
+ else if(seqfirst->depth > seq->depth) seqfirst= seq;
+ else if(seqfirst->machine < seq->machine) seqfirst= seq;
+
+
+ }
+ else if(seq->type < SEQ_EFFECT) { /* images */
+
+ /* onderste strip! zodat je bovenin altijd hulptroep kan bewaren */
+
+ if(seqfirst==0) seqfirst= seq;
+ else if(seqfirst->depth > seq->depth) seqfirst= seq;
+ else if(seqfirst->machine > seq->machine) seqfirst= seq;
+
+ }
+ }
+ }
+
+ MEM_freeN(seqar);
+
+ if(seqfirst->curelem==0) return 0;
+ return seqfirst->curelem->ibuf;
+
+}
+
+void free_imbuf_effect_spec(int cfra)
+{
+ Sequence *seq;
+ StripElem *se;
+ Editing *ed;
+ int a;
+
+ ed= G.scene->ed;
+ if(ed==0) return;
+
+ WHILE_SEQ(&ed->seqbase) {
+
+ if(seq->strip) {
+
+ if(seq->type & SEQ_EFFECT) {
+ se= seq->strip->stripdata;
+ for(a=0; a<seq->len; a++, se++) {
+ if(se==seq->curelem && se->ibuf) {
+ IMB_freeImBuf(se->ibuf);
+ se->ibuf= 0;
+ se->ok= 1;
+ se->se1= se->se2= se->se3= 0;
+ }
+ }
+ }
+ }
+ }
+ END_SEQ
+}
+
+void free_imbuf_seq_except(int cfra)
+{
+ Sequence *seq;
+ StripElem *se;
+ Editing *ed;
+ int a;
+
+ ed= G.scene->ed;
+ if(ed==0) return;
+
+ WHILE_SEQ(&ed->seqbase) {
+
+ if(seq->strip) {
+
+ if( seq->type==SEQ_META ) {
+ ;
+ }
+ else {
+ se= seq->strip->stripdata;
+ for(a=0; a<seq->len; a++, se++) {
+ if(se!=seq->curelem && se->ibuf) {
+ IMB_freeImBuf(se->ibuf);
+ se->ibuf= 0;
+ se->ok= 1;
+ se->se1= se->se2= se->se3= 0;
+ }
+ }
+ }
+
+ if(seq->type==SEQ_MOVIE) {
+ if(seq->startdisp > cfra || seq->enddisp < cfra) {
+ if(seq->anim) {
+ IMB_free_anim(seq->anim);
+ seq->anim = 0;
+ }
+ }
+ }
+ }
+ }
+ END_SEQ
+}
+
+void free_imbuf_seq()
+{
+ Sequence *seq;
+ StripElem *se;
+ Editing *ed;
+ int a;
+
+ ed= G.scene->ed;
+ if(ed==0) return;
+
+ WHILE_SEQ(&ed->seqbase) {
+
+ if(seq->strip) {
+
+ if( seq->type==SEQ_META ) {
+ ;
+ }
+ else {
+ se= seq->strip->stripdata;
+ for(a=0; a<seq->len; a++, se++) {
+ if(se->ibuf) {
+ IMB_freeImBuf(se->ibuf);
+ se->ibuf= 0;
+ se->ok= 1;
+ se->se1= se->se2= se->se3= 0;
+ }
+ }
+ }
+
+ if(seq->type==SEQ_MOVIE) {
+ if(seq->anim) {
+ IMB_free_anim(seq->anim);
+ seq->anim = 0;
+ }
+ }
+ }
+ }
+ END_SEQ
+}
+
+void do_render_seq()
+{
+/* static ImBuf *lastibuf=0; */
+ ImBuf *ibuf;
+
+ /* plaatje in R.rectot kopieeren */
+
+ G.f |= G_PLAYANIM; /* waitcursor patch */
+
+ ibuf= give_ibuf_seq(CFRA);
+ if(ibuf) {
+
+ memcpy(R.rectot, ibuf->rect, 4*R.rectx*R.recty);
+
+ /* if (ibuf->zbuf) { */
+ /* if (R.rectz) freeN(R.rectz); */
+ /* R.rectz = BLI_dupallocN(ibuf->zbuf); */
+ /* } */
+
+ free_imbuf_seq_except(CFRA);
+ }
+ G.f &= ~G_PLAYANIM;
+
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-18 08:34:19 +0300