archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

== Sequencer ==

Browse Source 
Bugfixes:
- Effect dependencies sometimes went wrong. seq3 was always calculated,
  even if the effect already told the upper layer, that there is an early
  out available...
- On render, only free _all_ buffers, if memory usage is above the memcache
  limit. This made my render times drop from 17 hours to only 4 hours on
  a 2 hour movie.

  Ton: I don't want to start an edit war at this point, but if you really
  need the old behaviour, just use a very low, non-zero memcache limit in the
  preferences. (In most cases, the default of 32 Mb _is_ very low ;-)
This commit is contained in:
Peter Schlaile
2007-02-04 09:18:15 +00:00
parent a1a7a65b46
commit daa248ff0c
1 changed files with 77 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
source/blender/src/sequence.c
View File

@@ -33,6 +33,7 @@
#include <stdlib.h>
#include "MEM_guardedalloc.h"
#include "MEM_CacheLimiterC-Api.h"
#include "BLI_blenlib.h"
#include "BLI_arithb.h"
@@ -463,34 +464,45 @@ static void do_effect(int cfra, Sequence *seq, StripElem *se)
return;
}
if(se->se1==0 || se->se2==0 || se->se3==0) {
make_black_ibuf(se->ibuf);
return;
}
/* if metastrip: other 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) {
make_black_ibuf(se->ibuf);
return;
}
switch (early_out) {
case 0:
break;
case 1:
if (se1->ibuf==0) {
if (se->se1==0 || se->se2==0 || se->se3==0) {
make_black_ibuf(se->ibuf);
return;
}
/* if metastrip: other 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;
}
break;
case 1:
if (se->se1 == 0) {
make_black_ibuf(se->ibuf);
return;
}
/* if metastrip: other se's */
if(se->se1->ok==2) se1= se->se1->se1;
else se1= se->se1;
if (se1 == 0 || se1->ibuf == 0) {
make_black_ibuf(se->ibuf);
return;
}
if (se->ibuf != se1->ibuf) {
IMB_freeImBuf(se->ibuf);
se->ibuf = se1->ibuf;
@@ -498,7 +510,16 @@ static void do_effect(int cfra, Sequence *seq, StripElem *se)
}
return;
case 2:
if (se2->ibuf==0) {
if (se->se2 == 0) {
make_black_ibuf(se->ibuf);
return;
}
/* if metastrip: other se's */
if(se->se2->ok==2) se2= se->se2->se1;
else se2= se->se2;
if (se2 == 0 || se2->ibuf == 0) {
make_black_ibuf(se->ibuf);
return;
}
@@ -508,9 +529,7 @@ static void do_effect(int cfra, Sequence *seq, StripElem *se)
IMB_refImBuf(se->ibuf);
}
return;
}
if (se1->ibuf==0 || se2->ibuf==0 || se3->ibuf==0) {
default:
make_black_ibuf(se->ibuf);
return;
}
@@ -909,6 +928,9 @@ static void do_effect_seq_recursively(int cfra, Sequence * seq, StripElem *se)
case 0:
do_build_seq_recursively(seq->seq1, cfra);
do_build_seq_recursively(seq->seq2, cfra);
if (seq->seq3) {
do_build_seq_recursively(seq->seq3, cfra);
}
break;
case 1:
do_build_seq_recursively(seq->seq1, cfra);
@@ -918,9 +940,6 @@ static void do_effect_seq_recursively(int cfra, Sequence * seq, StripElem *se)
break;
}
if (seq->seq3) {
do_build_seq_recursively(seq->seq3, cfra);
}
do_build_seq_ibuf(seq, cfra);
@@ -932,6 +951,11 @@ static void do_effect_seq_recursively(int cfra, Sequence * seq, StripElem *se)
IMB_cache_limiter_unref(seq->seq1->curelem->ibuf);
if (seq->seq2->curelem && seq->seq2->curelem->ibuf)
IMB_cache_limiter_unref(seq->seq2->curelem->ibuf);
if (seq->seq3) {
if (seq->seq3->curelem && seq->seq3->curelem->ibuf)
IMB_cache_limiter_unref(
seq->seq3->curelem->ibuf);
}
break;
case 1:
if (seq->seq1->curelem && seq->seq1->curelem->ibuf)
@@ -942,10 +966,6 @@ static void do_effect_seq_recursively(int cfra, Sequence * seq, StripElem *se)
IMB_cache_limiter_unref(seq->seq2->curelem->ibuf);
break;
}
if (seq->seq3) {
if (seq->seq3->curelem && seq->seq3->curelem->ibuf)
IMB_cache_limiter_unref(seq->seq3->curelem->ibuf);
}
}
static void do_build_seq_recursively_impl(Sequence * seq, int cfra)
@@ -1338,8 +1358,29 @@ void do_render_seq(RenderResult *rr, int cfra)
}
/* Let the cache limitor take care of this (schlaile) */
/* While render let's keep all memory available for render (ton) */
free_imbuf_seq_except(cfra);
/* While render let's keep all memory available for render
(ton)
At least if free memory is tight...
This can make a big difference in encoding speed
(it is around 4 times(!) faster, if we do not waste time
on freeing _all_ buffers every time on long timelines...)
(schlaile)
*/
{
extern int mem_in_use;
int max = MEM_CacheLimiter_get_maximum();
if (max != 0 && mem_in_use > max) {
fprintf(stderr, "mem_in_use = %d, max = %d\n",
mem_in_use, max);
fprintf(stderr, "Cleaning up, please wait...\n"
"If this happens very often,\n"
"consider "
"raising the memcache limit in the "
"user preferences.\n");
free_imbuf_seq();
}
}
}
else {
/* render result is delivered empty in most cases, nevertheless we handle all cases */