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

Cleanup: remove old VSE prefetching code.

Browse Source 
Reviewed By: brecht

Differential Revision: https://developer.blender.org/D6774
This commit is contained in:
Richard Antalik
2020-02-07 23:49:37 +01:00
parent 4e2e28b8c3
commit a010d97204
5 changed files with 2 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/blender/blenkernel/BKE_sequencer.h
View File

@@ -211,9 +211,6 @@ struct SeqEffectHandle {
double BKE_sequencer_rendersize_to_scale_factor(int size);
struct ImBuf *BKE_sequencer_give_ibuf(const SeqRenderData *context, float cfra, int chanshown);
struct ImBuf *BKE_sequencer_give_ibuf_threaded(const SeqRenderData *context,
float cfra,
int chanshown);
struct ImBuf *BKE_sequencer_give_ibuf_direct(const SeqRenderData *context,
float cfra,
struct Sequence *seq);
@@ -221,9 +218,6 @@ struct ImBuf *BKE_sequencer_give_ibuf_seqbase(const SeqRenderData *context,
float cfra,
int chan_shown,
struct ListBase *seqbasep);
void BKE_sequencer_give_ibuf_prefetch_request(const SeqRenderData *context,
float cfra,
int chan_shown);
/* **********************************************************************
* sequencer.c

140
source/blender/blenkernel/intern/sequencer.c
View File

@@ -4147,146 +4147,6 @@ ImBuf *BKE_sequencer_give_ibuf_direct(const SeqRenderData *context, float cfra,
return ibuf;
}
/* *********************** threading api ******************* */
static ListBase running_threads;
static ListBase prefetch_wait;
static ListBase prefetch_done;
static pthread_mutex_t queue_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t wakeup_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t wakeup_cond = PTHREAD_COND_INITIALIZER;
// static pthread_mutex_t prefetch_ready_lock = PTHREAD_MUTEX_INITIALIZER;
// static pthread_cond_t prefetch_ready_cond = PTHREAD_COND_INITIALIZER;
static pthread_mutex_t frame_done_lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t frame_done_cond = PTHREAD_COND_INITIALIZER;
static volatile bool seq_thread_shutdown = true;
static volatile int seq_last_given_monoton_cfra = 0;
static int monoton_cfra = 0;
typedef struct PrefetchThread {
struct PrefetchThread *next, *prev;
Scene *scene;
struct PrefetchQueueElem *current;
pthread_t pthread;
int running;
} PrefetchThread;
typedef struct PrefetchQueueElem {
struct PrefetchQueueElem *next, *prev;
int rectx;
int recty;
float cfra;
int chanshown;
int preview_render_size;
int monoton_cfra;
ImBuf *ibuf;
} PrefetchQueueElem;
void BKE_sequencer_give_ibuf_prefetch_request(const SeqRenderData *context,
float cfra,
int chanshown)
{
PrefetchQueueElem *e;
if (seq_thread_shutdown) {
return;
}
e = MEM_callocN(sizeof(PrefetchQueueElem), "prefetch_queue_elem");
e->rectx = context->rectx;
e->recty = context->recty;
e->cfra = cfra;
e->chanshown = chanshown;
e->preview_render_size = context->preview_render_size;
e->monoton_cfra = monoton_cfra++;
pthread_mutex_lock(&queue_lock);
BLI_addtail(&prefetch_wait, e);
pthread_mutex_unlock(&queue_lock);
pthread_mutex_lock(&wakeup_lock);
pthread_cond_signal(&wakeup_cond);
pthread_mutex_unlock(&wakeup_lock);
}
ImBuf *BKE_sequencer_give_ibuf_threaded(const SeqRenderData *context, float cfra, int chanshown)
{
PrefetchQueueElem *e = NULL;
bool found_something = false;
if (seq_thread_shutdown) {
return BKE_sequencer_give_ibuf(context, cfra, chanshown);
}
while (!e) {
bool success = false;
pthread_mutex_lock(&queue_lock);
for (e = prefetch_done.first; e; e = e->next) {
if (cfra == e->cfra && chanshown == e->chanshown && context->rectx == e->rectx &&
context->recty == e->recty && context->preview_render_size == e->preview_render_size) {
success = true;
found_something = true;
break;
}
}
if (!e) {
for (e = prefetch_wait.first; e; e = e->next) {
if (cfra == e->cfra && chanshown == e->chanshown && context->rectx == e->rectx &&
context->recty == e->recty && context->preview_render_size == e->preview_render_size) {
found_something = true;
break;
}
}
}
if (!e) {
PrefetchThread *tslot;
for (tslot = running_threads.first; tslot; tslot = tslot->next) {
if (tslot->current && cfra == tslot->current->cfra &&
chanshown == tslot->current->chanshown && context->rectx == tslot->current->rectx &&
context->recty == tslot->current->recty &&
context->preview_render_size == tslot->current->preview_render_size) {
found_something = true;
break;
}
}
}
/* e->ibuf is unrefed by render thread on next round. */
if (e) {
seq_last_given_monoton_cfra = e->monoton_cfra;
}
pthread_mutex_unlock(&queue_lock);
if (!success) {
e = NULL;
if (!found_something) {
fprintf(stderr, "SEQ-THREAD: Requested frame not in queue ???\n");
break;
}
pthread_mutex_lock(&frame_done_lock);
pthread_cond_wait(&frame_done_cond, &frame_done_lock);
pthread_mutex_unlock(&frame_done_lock);
}
}
return e ? e->ibuf : NULL;
}
/* check whether sequence cur depends on seq */
bool BKE_sequence_check_depend(Sequence *seq, Sequence *cur)
{

26
source/blender/editors/space_sequencer/sequencer_draw.c
View File

@@ -1055,11 +1055,8 @@ ImBuf *sequencer_ibuf_get(struct Main *bmain,
if (special_seq_update) {
ibuf = BKE_sequencer_give_ibuf_direct(&context, cfra + frame_ofs, special_seq_update);
}
else if (!U.prefetchframes) { // XXX || (G.f & G_PLAYANIM) == 0) {
ibuf = BKE_sequencer_give_ibuf(&context, cfra + frame_ofs, sseq->chanshown);
}
else {
ibuf = BKE_sequencer_give_ibuf_threaded(&context, cfra + frame_ofs, sseq->chanshown);
ibuf = BKE_sequencer_give_ibuf(&context, cfra + frame_ofs, sseq->chanshown);
}
if (fb) {
@@ -1622,27 +1619,6 @@ void sequencer_draw_preview(const bContext *C,
seq_prefetch_wm_notify(C, scene);
}
#if 0
void drawprefetchseqspace(Scene *scene, ARegion *UNUSED(ar), SpaceSeq *sseq)
{
int rectx, recty;
int render_size = BKE_sequencer_rendersize_to_scale_factor(sseq->render_size);
if (sseq->render_size == SEQ_PROXY_RENDER_SIZE_NONE) {
return;
}
if (sseq->render_size == SEQ_PROXY_RENDER_SIZE_SCENE) {
render_size = scene->r.size / 100.0;
}
rectx = render_size * scene->r.xsch + 0.5;
recty = render_size * scene->r.ysch + 0.5;
if (sseq->mainb != SEQ_DRAW_SEQUENCE) {
give_ibuf_prefetch_request(rectx, recty, (scene->r.cfra), sseq->chanshown, sseq->render_size);
}
}
#endif
/* draw backdrop of the sequencer strips view */
static void draw_seq_backdrop(View2D *v2d)
{

1
source/blender/makesdna/DNA_userdef_types.h
View File

@@ -724,6 +724,7 @@ typedef struct UserDef {
short vbotimeout, vbocollectrate;
short textimeout, texcollectrate;
int memcachelimit;
/** Unused. */
int prefetchframes;
/** Control the rotation step of the view when PAD2, PAD4, PAD6&PAD8 is use. */
float pad_rot_angle;

8
source/blender/makesrna/intern/rna_userdef.c
View File

@@ -5074,14 +5074,6 @@ static void rna_def_userdef_system(BlenderRNA *brna)
/* Memory */
prop = RNA_def_property(srna, "prefetch_frames", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "prefetchframes");
RNA_def_property_range(prop, 0, INT_MAX);
RNA_def_property_ui_range(prop, 0, 500, 1, -1);
RNA_def_property_ui_text(prop,
"Prefetch Frames",
"Number of frames to render ahead during playback (sequencer only)");
prop = RNA_def_property(srna, "memory_cache_limit", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "memcachelimit");
RNA_def_property_range(prop, 0, max_memory_in_megabytes_int());