From bbb1936411a5f98f5a49ed0d63bcf1a547cbdb59 Mon Sep 17 00:00:00 2001 From: Richard Antalik Date: Tue, 2 Mar 2021 12:08:16 +0100 Subject: VSE: Refactor VSE strip loading code Isolate RNA and operator logic from functions that create strips. - Operator specific code was removed from `SeqLoadInfo` structure and `SEQ_add_*` functions. - Strip loading code was removed from RNA and operator functions. - `SEQ_add_*` API was unified to work on `SeqLoadData` struct. Only exception is image strip, which require files to be loaded separately to strip creation itself. This is not ideal, but I think it's acceptable. - Some functions and variables were refactored so the code reads better. There are minor functional changes (coincidental bugfixes): - Operator errors are reported per-strip. Previously they were not reported at all? - `new_sound()` RNA API function now create sound with length of 1 if source file does not exist. Previously it created strip with length of 0. - Replace selection operator property wasn't working correctly. Fixed in this patch. Reviewed By: sergey Differential Revision: https://developer.blender.org/D9760 --- source/blender/sequencer/SEQ_add.h | 95 ++++-- source/blender/sequencer/intern/render.c | 28 -- source/blender/sequencer/intern/strip_add.c | 501 +++++++++++++++++++--------- 3 files changed, 402 insertions(+), 222 deletions(-) (limited to 'source/blender/sequencer') diff --git a/source/blender/sequencer/SEQ_add.h b/source/blender/sequencer/SEQ_add.h index b136cb35e09..e262d7ed1ef 100644 --- a/source/blender/sequencer/SEQ_add.h +++ b/source/blender/sequencer/SEQ_add.h @@ -32,48 +32,73 @@ struct Scene; struct Sequence; struct bContext; -/* api for adding new sequence strips */ -typedef struct SeqLoadInfo { +/* SeqLoadData.flags */ +typedef enum eSeqLoadFlags { + SEQ_LOAD_SOUND_CACHE = (1 << 1), + SEQ_LOAD_SOUND_MONO = (1 << 2), + SEQ_LOAD_MOVIE_SYNC_FPS = (1 << 3), +} eSeqLoadFlags; + +/* Api for adding new sequence strips. */ +typedef struct SeqLoadData { int start_frame; - int end_frame; int channel; - int flag; /* use sound, replace sel */ - int type; - int len; /* only for image strips */ + char name[64]; /* Strip name. */ char path[1024]; /* 1024 = FILE_MAX */ + struct { + int len; + int end_frame; + } image; /* Only for image strips. */ + struct Scene *scene; /* Only for scene strips. */ + struct MovieClip *clip; /* Only for clip strips. */ + struct Mask *mask; /* Only for mask strips. */ + struct { + int type; + int end_frame; + struct Sequence *seq1; + struct Sequence *seq2; + struct Sequence *seq3; + } effect; /* Only for effect strips. */ + eSeqLoadFlags flags; eSeqImageFitMethod fit_method; - - /* multiview */ + bool use_multiview; char views_format; struct Stereo3dFormat *stereo3d_format; + bool allow_invalid_file; /* Used by RNA API to create placeholder strips. */ +} SeqLoadData; - /* return values */ - char name[64]; - struct Sequence *seq_sound; /* for movie's */ - int tot_success; - int tot_error; -} SeqLoadInfo; - -/* SeqLoadInfo.flag */ -#define SEQ_LOAD_REPLACE_SEL (1 << 0) -#define SEQ_LOAD_FRAME_ADVANCE (1 << 1) -#define SEQ_LOAD_MOVIE_SOUND (1 << 2) -#define SEQ_LOAD_SOUND_CACHE (1 << 3) -#define SEQ_LOAD_SYNC_FPS (1 << 4) -#define SEQ_LOAD_SOUND_MONO (1 << 5) - -/* use as an api function */ -typedef struct Sequence *(*SeqLoadFn)(struct bContext *, ListBase *, struct SeqLoadInfo *); - -struct Sequence *SEQ_add_image_strip(struct bContext *C, - ListBase *seqbasep, - struct SeqLoadInfo *seq_load); -struct Sequence *SEQ_add_sound_strip(struct bContext *C, - ListBase *seqbasep, - struct SeqLoadInfo *seq_load); -struct Sequence *SEQ_add_movie_strip(struct bContext *C, - ListBase *seqbasep, - struct SeqLoadInfo *seq_load); +void SEQ_add_load_data_init(struct SeqLoadData *load_data, + const char *name, + const char *path, + const int start_frame, + const int channel); +struct Sequence *SEQ_add_image_strip(struct Main *bmain, + struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +struct Sequence *SEQ_add_sound_strip(struct Main *bmain, + struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +struct Sequence *SEQ_add_movie_strip(struct Main *bmain, + struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +struct Sequence *SEQ_add_scene_strip(struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +struct Sequence *SEQ_add_movieclip_strip(struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +struct Sequence *SEQ_add_mask_strip(struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +struct Sequence *SEQ_add_effect_strip(struct Scene *scene, + struct ListBase *seqbase, + struct SeqLoadData *load_data); +void SEQ_add_image_set_directory(struct Sequence *seq, char *path); +void SEQ_add_image_load_file(struct Sequence *seq, size_t strip_frame, char *filename); +void SEQ_add_image_init_alpha_mode(struct Sequence *seq); void SEQ_add_reload_new_file(struct Main *bmain, struct Scene *scene, struct Sequence *seq, diff --git a/source/blender/sequencer/intern/render.c b/source/blender/sequencer/intern/render.c index e9de73bc093..f1a0a7db13b 100644 --- a/source/blender/sequencer/intern/render.c +++ b/source/blender/sequencer/intern/render.c @@ -203,34 +203,6 @@ void SEQ_render_pixel_from_sequencer_space_v4(struct Scene *scene, float pixel[4 } } -void SEQ_render_init_colorspace(Sequence *seq) -{ - if (seq->strip && seq->strip->stripdata) { - char name[FILE_MAX]; - ImBuf *ibuf; - - BLI_join_dirfile(name, sizeof(name), seq->strip->dir, seq->strip->stripdata->name); - BLI_path_abs(name, BKE_main_blendfile_path_from_global()); - - /* initialize input color space */ - if (seq->type == SEQ_TYPE_IMAGE) { - ibuf = IMB_loadiffname( - name, IB_test | IB_alphamode_detect, seq->strip->colorspace_settings.name); - - /* byte images are default to straight alpha, however sequencer - * works in premul space, so mark strip to be premultiplied first - */ - seq->alpha_mode = SEQ_ALPHA_STRAIGHT; - if (ibuf) { - if (ibuf->flags & IB_alphamode_premul) { - seq->alpha_mode = IMA_ALPHA_PREMUL; - } - - IMB_freeImBuf(ibuf); - } - } - } -} /** \} */ /* -------------------------------------------------------------------- */ diff --git a/source/blender/sequencer/intern/strip_add.c b/source/blender/sequencer/intern/strip_add.c index ba080a07879..1aa0e32a363 100644 --- a/source/blender/sequencer/intern/strip_add.c +++ b/source/blender/sequencer/intern/strip_add.c @@ -29,6 +29,7 @@ #include "MEM_guardedalloc.h" +#include "DNA_mask_types.h" #include "DNA_scene_types.h" #include "DNA_sequence_types.h" #include "DNA_sound_types.h" @@ -54,7 +55,9 @@ #include "IMB_metadata.h" #include "SEQ_add.h" +#include "SEQ_effects.h" #include "SEQ_relations.h" +#include "SEQ_render.h" #include "SEQ_select.h" #include "SEQ_sequencer.h" #include "SEQ_time.h" @@ -65,168 +68,369 @@ #include "proxy.h" #include "utils.h" -static void seq_load_apply(Main *bmain, Scene *scene, Sequence *seq, SeqLoadInfo *seq_load) +/** + * Initialize common SeqLoadData members + * + * \param load_data: SeqLoadData to be initialized + * \param name: strip name (can be NULL) + * \param path: path to file that is used as strip input (can be NULL) + * \param start_frame: timeline frame where strip will be created + * \param channel: timeline channel where strip will be created + * + */ +void SEQ_add_load_data_init(SeqLoadData *load_data, + const char *name, + const char *path, + const int start_frame, + const int channel) { - if (seq) { - BLI_strncpy_utf8(seq->name + 2, seq_load->name, sizeof(seq->name) - 2); - BLI_utf8_invalid_strip(seq->name + 2, strlen(seq->name + 2)); - SEQ_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq); + memset(load_data, 0, sizeof(SeqLoadData)); + if (name != NULL) { + BLI_strncpy(load_data->name, name, sizeof(load_data->name)); + } + if (path != NULL) { + BLI_strncpy(load_data->path, path, sizeof(load_data->path)); + } + load_data->start_frame = start_frame; + load_data->channel = channel; +} - if (seq_load->flag & SEQ_LOAD_FRAME_ADVANCE) { - seq_load->start_frame += (seq->enddisp - seq->startdisp); - } +static void seq_add_generic_update(Scene *scene, ListBase *seqbase, Sequence *seq) +{ + SEQ_sequence_base_unique_name_recursive(seqbase, seq); + SEQ_time_update_sequence_bounds(scene, seq); + SEQ_sort(scene); + SEQ_relations_invalidate_cache_composite(scene, seq); +} - if (seq_load->flag & SEQ_LOAD_REPLACE_SEL) { - seq_load->flag |= SELECT; - SEQ_select_active_set(scene, seq); +static void seq_add_set_name(Sequence *seq, SeqLoadData *load_data) +{ + if (load_data->name != NULL) { + BLI_strncpy(seq->name + 2, load_data->name, sizeof(seq->name) - 2); + } + else { + if (seq->type == SEQ_TYPE_SCENE) { + BLI_strncpy(seq->name + 2, load_data->scene->id.name + 2, sizeof(seq->name) - 2); } - - if (seq_load->flag & SEQ_LOAD_SOUND_MONO) { - seq->sound->flags |= SOUND_FLAGS_MONO; - BKE_sound_load(bmain, seq->sound); + else if (seq->type == SEQ_TYPE_MOVIECLIP) { + BLI_strncpy(seq->name + 2, load_data->clip->id.name + 2, sizeof(seq->name) - 2); } - - if (seq_load->flag & SEQ_LOAD_SOUND_CACHE) { - if (seq->sound) { - seq->sound->flags |= SOUND_FLAGS_CACHING; - } + else if (seq->type == SEQ_TYPE_MASK) { + BLI_strncpy(seq->name + 2, load_data->mask->id.name + 2, sizeof(seq->name) - 2); + } + else if ((seq->type & SEQ_TYPE_EFFECT) != 0) { + BLI_strncpy(seq->name + 2, SEQ_sequence_give_name(seq), sizeof(seq->name) - 2); + } + else { /* Image, sound and movie. */ + BLI_strncpy_utf8(seq->name + 2, load_data->name, sizeof(seq->name) - 2); + BLI_utf8_invalid_strip(seq->name + 2, strlen(seq->name + 2)); } - - seq_load->tot_success++; - } - else { - seq_load->tot_error++; } } -/* NOTE: this function doesn't fill in image names */ -Sequence *SEQ_add_image_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) +/** + * Add scene strip. + * + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_scene_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data) { - Scene *scene = CTX_data_scene(C); /* only for active seq */ - Sequence *seq; - Strip *strip; + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, SEQ_TYPE_SCENE); + seq->blend_mode = SEQ_TYPE_CROSS; + seq->scene = load_data->scene; + seq->len = load_data->scene->r.efra - load_data->scene->r.sfra + 1; + id_us_ensure_real((ID *)load_data->scene); + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); + return seq; +} - seq = SEQ_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel, SEQ_TYPE_IMAGE); - seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */ +/** + * Add movieclip strip. + * + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_movieclip_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data) +{ + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, SEQ_TYPE_MOVIECLIP); + seq->blend_mode = SEQ_TYPE_CROSS; + seq->clip = load_data->clip; + seq->len = BKE_movieclip_get_duration(load_data->clip); + id_us_ensure_real((ID *)load_data->clip); + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); + return seq; +} - /* basic defaults */ - seq->len = seq_load->len ? seq_load->len : 1; +/** + * Add mask strip. + * + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_mask_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data) +{ + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, SEQ_TYPE_MASK); + seq->blend_mode = SEQ_TYPE_CROSS; + seq->mask = load_data->mask; + seq->len = BKE_mask_get_duration(load_data->mask); + id_us_ensure_real((ID *)load_data->mask); + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); + return seq; +} - strip = seq->strip; - strip->stripdata = MEM_callocN(seq->len * sizeof(StripElem), "stripelem"); - BLI_strncpy(strip->dir, seq_load->path, sizeof(strip->dir)); +/** + * Add effect strip. + * + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_effect_strip(Scene *scene, ListBase *seqbase, struct SeqLoadData *load_data) +{ + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, load_data->effect.type); + + seq->flag |= SEQ_USE_EFFECT_DEFAULT_FADE; + struct SeqEffectHandle sh = SEQ_effect_handle_get(seq); + sh.init(seq); + seq->seq1 = load_data->effect.seq1; + seq->seq2 = load_data->effect.seq2; + seq->seq3 = load_data->effect.seq3; + + if (seq->type == SEQ_TYPE_COLOR) { + seq->blend_mode = SEQ_TYPE_CROSS; + } + else if (seq->type == SEQ_TYPE_ADJUSTMENT) { + seq->blend_mode = SEQ_TYPE_CROSS; + } + else if (seq->type == SEQ_TYPE_TEXT) { + seq->blend_mode = SEQ_TYPE_ALPHAOVER; + } + else if (SEQ_effect_get_num_inputs(seq->type) == 1) { + seq->blend_mode = seq->seq1->blend_mode; + } - if (seq_load->stereo3d_format) { - *seq->stereo3d_format = *seq_load->stereo3d_format; + if (!load_data->effect.seq1) { + seq->len = 1; /* Effect is generator, set non zero length. */ + SEQ_transform_set_right_handle_frame(seq, load_data->image.end_frame); } + SEQ_relations_update_changed_seq_and_deps(scene, seq, 1, 1); /* Runs SEQ_time_update_sequence. */ + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); + + return seq; +} + +/** + * Set directory used by image strip. + * + * \param seq: image strip to be changed + * \param path: directory path + */ +void SEQ_add_image_set_directory(Sequence *seq, char *path) +{ + BLI_strncpy(seq->strip->dir, path, sizeof(seq->strip->dir)); +} - seq->views_format = seq_load->views_format; - seq->flag |= seq_load->flag & SEQ_USE_VIEWS; +/** + * Set directory used by image strip. + * + * \param seq: image strip to be changed + * \param strip_frame: frame index of strip to be changed + * \param filename: image filename (only filename, not complete path) + */ +void SEQ_add_image_load_file(Sequence *seq, size_t strip_frame, char *filename) +{ + StripElem *se = SEQ_render_give_stripelem(seq, seq->start + strip_frame); + BLI_strncpy(se->name, filename, sizeof(se->name)); +} - seq_load_apply(CTX_data_main(C), scene, seq, seq_load); +/** + * Set image strip alpha mode + * + * \param seq: image strip to be changed + */ +void SEQ_add_image_init_alpha_mode(Sequence *seq) +{ + if (seq->strip && seq->strip->stripdata) { + char name[FILE_MAX]; + ImBuf *ibuf; + + BLI_join_dirfile(name, sizeof(name), seq->strip->dir, seq->strip->stripdata->name); + BLI_path_abs(name, BKE_main_blendfile_path_from_global()); + + /* Initialize input color space. */ + if (seq->type == SEQ_TYPE_IMAGE) { + ibuf = IMB_loadiffname( + name, IB_test | IB_alphamode_detect, seq->strip->colorspace_settings.name); + + /* Byte images are default to straight alpha, however sequencer + * works in premul space, so mark strip to be premultiplied first. + */ + seq->alpha_mode = SEQ_ALPHA_STRAIGHT; + if (ibuf) { + if (ibuf->flags & IB_alphamode_premul) { + seq->alpha_mode = IMA_ALPHA_PREMUL; + } + IMB_freeImBuf(ibuf); + } + } + } +} + +/** + * Add image strip. + * NOTE: Use SEQ_add_image_set_directory() and SEQ_add_image_load_file() to load image sequences + * + * \param main: Main reference + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_image_strip(Main *bmain, Scene *scene, ListBase *seqbase, SeqLoadData *load_data) +{ + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, SEQ_TYPE_IMAGE); + seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */ + seq->len = load_data->image.len; + Strip *strip = seq->strip; + strip->stripdata = MEM_callocN(load_data->image.len * sizeof(StripElem), "stripelem"); + + /* Multiview settings. */ + if (load_data->use_multiview) { + seq->flag |= SEQ_USE_VIEWS; + seq->views_format = load_data->views_format; + } + if (load_data->stereo3d_format) { + seq->stereo3d_format = load_data->stereo3d_format; + } + + /* Set initial scale based on load_data->fit_method. */ char file_path[FILE_MAX]; - BLI_join_dirfile(file_path, sizeof(file_path), seq_load->path, seq_load->name); - BLI_path_abs(file_path, BKE_main_blendfile_path(CTX_data_main(C))); + BLI_join_dirfile(file_path, sizeof(file_path), load_data->path, load_data->name); + BLI_path_abs(file_path, BKE_main_blendfile_path(bmain)); ImBuf *ibuf = IMB_loadiffname(file_path, IB_rect, seq->strip->colorspace_settings.name); if (ibuf != NULL) { SEQ_set_scale_to_fit( - seq, ibuf->x, ibuf->y, scene->r.xsch, scene->r.ysch, seq_load->fit_method); + seq, ibuf->x, ibuf->y, scene->r.xsch, scene->r.ysch, load_data->fit_method); IMB_freeImBuf(ibuf); } - SEQ_relations_invalidate_cache_composite(scene, seq); + /* Set Last active directory. */ + BLI_strncpy(scene->ed->act_imagedir, seq->strip->dir, sizeof(scene->ed->act_imagedir)); + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); return seq; } #ifdef WITH_AUDASPACE -Sequence *SEQ_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) -{ - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); /* only for sound */ - Editing *ed = SEQ_editing_get(scene, false); - bSound *sound; - - Sequence *seq; /* generic strip vars */ - Strip *strip; - StripElem *se; - - sound = BKE_sound_new_file(bmain, seq_load->path); /* handles relative paths */ +/** + * Add sound strip. + * NOTE: Use SEQ_add_image_set_directory() and SEQ_add_image_load_file() to load image sequences + * + * \param main: Main reference + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_sound_strip(Main *bmain, Scene *scene, ListBase *seqbase, SeqLoadData *load_data) +{ + bSound *sound = BKE_sound_new_file(bmain, load_data->path); /* Handles relative paths. */ SoundInfo info; - if (!BKE_sound_info_get(bmain, sound, &info)) { + bool sound_loaded = BKE_sound_info_get(bmain, sound, &info); + + if (!sound_loaded && !load_data->allow_invalid_file) { BKE_id_free(bmain, sound); return NULL; } - if (info.specs.channels == SOUND_CHANNELS_INVALID) { + if (info.specs.channels == SOUND_CHANNELS_INVALID && !load_data->allow_invalid_file) { BKE_id_free(bmain, sound); return NULL; } - seq = SEQ_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel, SEQ_TYPE_SOUND_RAM); + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, SEQ_TYPE_SOUND_RAM); seq->sound = sound; - BLI_strncpy(seq->name + 2, "Sound", SEQ_NAME_MAXSTR - 2); - SEQ_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq); + seq->scene_sound = NULL; - /* basic defaults */ /* We add a very small negative offset here, because * ceil(132.0) == 133.0, not nice with videos, see T47135. */ - seq->len = (int)ceil((double)info.length * FPS - 1e-4); - strip = seq->strip; - - /* we only need 1 element to store the filename */ - strip->stripdata = se = MEM_callocN(sizeof(StripElem), "stripelem"); - - BLI_split_dirfile(seq_load->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name)); - - seq->scene_sound = NULL; + seq->len = MAX2(1, (int)ceil((double)info.length * FPS - 1e-4)); - SEQ_time_update_sequence_bounds(scene, seq); + Strip *strip = seq->strip; + /* We only need 1 element to store the filename. */ + StripElem *se = strip->stripdata = se = MEM_callocN(sizeof(StripElem), "stripelem"); + BLI_split_dirfile(load_data->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name)); - /* last active name */ - BLI_strncpy(ed->act_sounddir, strip->dir, FILE_MAXDIR); + if (seq != NULL && seq->sound != NULL) { + if (load_data->flags & SEQ_LOAD_SOUND_MONO) { + seq->sound->flags |= SOUND_FLAGS_MONO; + } - seq_load_apply(bmain, scene, seq, seq_load); + if (load_data->flags & SEQ_LOAD_SOUND_CACHE) { + if (seq->sound) { + seq->sound->flags |= SOUND_FLAGS_CACHING; + } + } + } - /* TODO(sergey): Shall we tag here or in the operator? */ - DEG_relations_tag_update(bmain); + /* Set Last active directory. */ + BLI_strncpy(scene->ed->act_sounddir, strip->dir, FILE_MAXDIR); + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); return seq; } + #else // WITH_AUDASPACE -Sequence *SEQ_add_sound_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) -{ - (void)C; - (void)seqbasep; - (void)seq_load; - return NULL; -} +Sequence *SEQ_add_sound_strip(Main *UNUSED(bmain), + Scene *UNUSED(scene), + ListBase *UNUSED(seqbase), + const SeqLoadData *UNUSED(load_data)) #endif // WITH_AUDASPACE -Sequence *SEQ_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_load) +/** + * Add movie strip. + * + * \param main: Main reference + * \param scene: Scene where strips will be added + * \param seqbase: ListBase where strips will be added + * \param load_data: SeqLoadData with information necessary to create strip + * \return created strip + */ +Sequence *SEQ_add_movie_strip(Main *bmain, Scene *scene, ListBase *seqbase, SeqLoadData *load_data) { - Main *bmain = CTX_data_main(C); - Scene *scene = CTX_data_scene(C); /* only for sound */ - char path[sizeof(seq_load->path)]; + char path[sizeof(load_data->path)]; + BLI_strncpy(path, load_data->path, sizeof(path)); + BLI_path_abs(path, BKE_main_blendfile_path(bmain)); - Sequence *seq; /* generic strip vars */ - Strip *strip; - StripElem *se; char colorspace[64] = "\0"; /* MAX_COLORSPACE_NAME */ bool is_multiview_loaded = false; - const bool is_multiview = (seq_load->flag & SEQ_USE_VIEWS) != 0; - const int totfiles = seq_num_files(scene, seq_load->views_format, is_multiview); - struct anim **anim_arr; + const int totfiles = seq_num_files(scene, load_data->views_format, load_data->use_multiview); + struct anim **anim_arr = MEM_callocN(sizeof(struct anim *) * totfiles, "Video files"); int i; - BLI_strncpy(path, seq_load->path, sizeof(path)); - BLI_path_abs(path, BKE_main_blendfile_path(bmain)); - - anim_arr = MEM_callocN(sizeof(struct anim *) * totfiles, "Video files"); - - if (is_multiview && (seq_load->views_format == R_IMF_VIEWS_INDIVIDUAL)) { + if (load_data->use_multiview && (load_data->views_format == R_IMF_VIEWS_INDIVIDUAL)) { char prefix[FILE_MAX]; const char *ext = NULL; size_t j = 0; @@ -245,38 +449,30 @@ Sequence *SEQ_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_ j++; } } - - if (j == 0) { - MEM_freeN(anim_arr); - return NULL; - } is_multiview_loaded = true; } } if (is_multiview_loaded == false) { anim_arr[0] = openanim(path, IB_rect, 0, colorspace); - - if (anim_arr[0] == NULL) { - MEM_freeN(anim_arr); - return NULL; - } } - if (seq_load->flag & SEQ_LOAD_MOVIE_SOUND) { - seq_load->channel++; + if (anim_arr[0] == NULL && !load_data->allow_invalid_file) { + MEM_freeN(anim_arr); + return NULL; } - seq = SEQ_sequence_alloc(seqbasep, seq_load->start_frame, seq_load->channel, SEQ_TYPE_MOVIE); - /* multiview settings */ - if (seq_load->stereo3d_format) { - *seq->stereo3d_format = *seq_load->stereo3d_format; - seq->views_format = seq_load->views_format; - } - seq->flag |= seq_load->flag & SEQ_USE_VIEWS; + Sequence *seq = SEQ_sequence_alloc( + seqbase, load_data->start_frame, load_data->channel, SEQ_TYPE_MOVIE); - seq->type = SEQ_TYPE_MOVIE; - seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */ + /* Multiview settings. */ + if (load_data->use_multiview) { + seq->flag |= SEQ_USE_VIEWS; + seq->views_format = load_data->views_format; + } + if (load_data->stereo3d_format) { + seq->stereo3d_format = load_data->stereo3d_format; + } for (i = 0; i < totfiles; i++) { if (anim_arr[i]) { @@ -289,51 +485,38 @@ Sequence *SEQ_add_movie_strip(bContext *C, ListBase *seqbasep, SeqLoadInfo *seq_ } } - IMB_anim_load_metadata(anim_arr[0]); + seq->blend_mode = SEQ_TYPE_CROSS; /* so alpha adjustment fade to the strip below */ - seq->anim_preseek = IMB_anim_get_preseek(anim_arr[0]); + if (anim_arr[0] != NULL) { + seq->anim_preseek = IMB_anim_get_preseek(anim_arr[0]); + seq->len = IMB_anim_get_duration(anim_arr[0], IMB_TC_RECORD_RUN); - const float width = IMB_anim_get_image_width(anim_arr[0]); - const float height = IMB_anim_get_image_height(anim_arr[0]); - SEQ_set_scale_to_fit(seq, width, height, scene->r.xsch, scene->r.ysch, seq_load->fit_method); + IMB_anim_load_metadata(anim_arr[0]); - BLI_strncpy(seq->name + 2, "Movie", SEQ_NAME_MAXSTR - 2); - SEQ_sequence_base_unique_name_recursive(&scene->ed->seqbase, seq); + /* Adjust scene's frame rate settings to match. */ + if (load_data->flags & SEQ_LOAD_MOVIE_SYNC_FPS) { + IMB_anim_get_fps(anim_arr[0], &scene->r.frs_sec, &scene->r.frs_sec_base, true); + } - /* adjust scene's frame rate settings to match */ - if (seq_load->flag & SEQ_LOAD_SYNC_FPS) { - IMB_anim_get_fps(anim_arr[0], &scene->r.frs_sec, &scene->r.frs_sec_base, true); + /* Set initial scale based on load_data->fit_method. */ + const float width = IMB_anim_get_image_width(anim_arr[0]); + const float height = IMB_anim_get_image_height(anim_arr[0]); + SEQ_set_scale_to_fit(seq, width, height, scene->r.xsch, scene->r.ysch, load_data->fit_method); } - /* basic defaults */ - seq->len = IMB_anim_get_duration(anim_arr[0], IMB_TC_RECORD_RUN); - strip = seq->strip; - + seq->len = MAX2(1, seq->len); BLI_strncpy(seq->strip->colorspace_settings.name, colorspace, sizeof(seq->strip->colorspace_settings.name)); - /* we only need 1 element for MOVIE strips */ + Strip *strip = seq->strip; + /* We only need 1 element for MOVIE strips. */ + StripElem *se; strip->stripdata = se = MEM_callocN(sizeof(StripElem), "stripelem"); + BLI_split_dirfile(load_data->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name)); - BLI_split_dirfile(seq_load->path, strip->dir, se->name, sizeof(strip->dir), sizeof(se->name)); - - SEQ_time_update_sequence_bounds(scene, seq); - - if (seq_load->name[0] == '\0') { - BLI_strncpy(seq_load->name, se->name, sizeof(seq_load->name)); - } - - if (seq_load->flag & SEQ_LOAD_MOVIE_SOUND) { - int start_frame_back = seq_load->start_frame; - seq_load->channel--; - seq_load->seq_sound = SEQ_add_sound_strip(C, seqbasep, seq_load); - seq_load->start_frame = start_frame_back; - } - - /* can be NULL */ - seq_load_apply(CTX_data_main(C), scene, seq, seq_load); - SEQ_relations_invalidate_cache_composite(scene, seq); + seq_add_set_name(seq, load_data); + seq_add_generic_update(scene, seqbase, seq); MEM_freeN(anim_arr); return seq; @@ -525,9 +708,9 @@ void SEQ_add_movie_reload_if_needed(struct Main *bmain, bool must_reload = false; - /* The Sequence struct allows for multiple anim structs to be associated with one strip. This - * function will return true only if there is at least one 'anim' AND all anims can produce - * frames. */ + /* The Sequence struct allows for multiple anim structs to be associated with one strip. + * This function will return true only if there is at least one 'anim' AND all anims can + * produce frames. */ if (BLI_listbase_is_empty(&seq->anims)) { /* No anim present, so reloading is always necessary. */ -- cgit v1.2.3