Blender V5.3
otio_import.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2026 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cmath>
10#include <sstream>
11
12#include "BKE_context.hh"
13#include "BKE_lib_id.hh"
14#include "BKE_report.hh"
15#include "BKE_scene.hh"
16
17#include "BLI_index_range.hh"
18#include "BLI_listbase.hh"
19#include "BLI_path_utils.hh"
20#include "BLI_serialize.hh"
21#include "BLI_string.hh"
22#include "BLI_string_utf8.hh"
23#include "BLI_vector.hh"
24
25#include "BLT_translation.hh"
26
27#include "CLG_log.h"
28
29#include "DEG_depsgraph.hh"
31
32#include "DNA_scene_types.h"
33#include "DNA_sequence_types.h"
34
35#include "IMB_imbuf_types.hh"
36
37#include "RNA_access.hh"
38#include "RNA_prototypes.hh"
39
40#include "SEQ_add.hh"
41#include "SEQ_channels.hh"
42#include "SEQ_effects.hh"
43#include "SEQ_sequencer.hh"
44#include "SEQ_time.hh"
45#include "SEQ_transform.hh"
46
47#include "opentimelineio/clip.h"
48#include "opentimelineio/effect.h"
49#include "opentimelineio/externalReference.h"
50#include "opentimelineio/freezeFrame.h"
51#include "opentimelineio/gap.h"
52#include "opentimelineio/generatorReference.h"
53#include "opentimelineio/imageSequenceReference.h"
54#include "opentimelineio/linearTimeWarp.h"
55#include "opentimelineio/marker.h"
56#include "opentimelineio/stack.h"
57#include "opentimelineio/timeline.h"
58#include "opentimelineio/track.h"
59#include "opentimelineio/transition.h"
60
61#include "otio_import.hh"
64#include "otio_metadata.hh"
65
66namespace blender::io::otio {
67
68static CLG_LogRef LOG = {"io.otio"};
69
71 Clip *clip;
72 ListBaseT<Strip> *seqbase;
74 int start;
77};
78
87
88static int to_frames(const StripImportContext &ctx, const RationalTime &time)
89{
90 return int(std::round(time.value_rescaled_to(ctx.fps)));
91}
92
93static const std::any *blender_metadata(SerializableObjectWithMetadata &object, const char *key)
94{
95 AnyDictionary &metadata = object.metadata();
96 auto blender = metadata.find("blender");
97 if (blender == metadata.end()) {
98 return nullptr;
99 }
100 AnyDictionary *dictionary = std::any_cast<AnyDictionary>(&blender->second);
101 if (!dictionary) {
102 return nullptr;
103 }
104 auto value = dictionary->find(key);
105 return value != dictionary->end() ? &value->second : nullptr;
106}
107
108static const AnyDictionary *strip_metadata(SerializableObjectWithMetadata &object)
109{
110 const std::any *value = blender_metadata(object, "strip");
111 return value ? std::any_cast<AnyDictionary>(value) : nullptr;
112}
113
114static const std::string *strip_metadata_string(SerializableObjectWithMetadata &object,
115 const char *key)
116{
117 const AnyDictionary *metadata = strip_metadata(object);
118 if (!metadata || !metadata->has_key(key)) {
119 return nullptr;
120 }
121 return std::any_cast<std::string>(&metadata->at(key));
122}
123
124static std::optional<StripType> strip_type_from_identifier(const std::string *identifier)
125{
126 PointerRNA ptr = RNA_pointer_create_discrete(nullptr, RNA_Strip, nullptr);
127 int type;
128 if (!identifier ||
130 nullptr, &ptr, RNA_struct_find_property(&ptr, "type"), identifier->c_str(), &type))
131 {
132 return std::nullopt;
133 }
134 return StripType(type);
135}
136
137static std::string url_to_filepath(const std::string &url)
138{
139 if (!url.starts_with("file://")) {
140 return url;
141 }
142 std::string filepath;
143 for (size_t i = strlen("file://"); i < url.size(); i++) {
144 if (url[i] == '%' && i + 2 < url.size()) {
145 filepath += char(std::strtol(url.substr(i + 1, 2).c_str(), nullptr, 16));
146 i += 2;
147 }
148 else {
149 filepath += url[i];
150 }
151 }
152#ifdef WIN32
153 if (filepath.size() > 2 && filepath[0] == '/' && filepath[2] == ':') {
154 filepath.erase(0, 1);
155 }
156#endif
157 return filepath;
158}
159
161 Strip *strip,
162 ListBaseT<Strip> &seqbase,
163 const int start,
164 const int duration,
165 SerializableObjectWithMetadata &object)
166{
167 strip->handles_set(ctx.scene, start, start + duration);
168 if (auto *item = dynamic_cast<Item *>(&object); item && !item->enabled()) {
169 strip->flag |= SEQ_MUTE;
170 }
171 seq::transform_shuffle_vertical(&seqbase, {strip}, ctx.scene);
172 ctx.strip_metadata.append({strip, &object});
173}
174
176 ListBaseT<Strip> &seqbase,
178 const std::string &dirpath,
179 const Span<std::string> filenames)
180{
181 load_data.image.count = filenames.size();
182 Strip *strip = seq::add_image_strip(ctx.bmain, ctx.scene, &seqbase, &load_data);
183 seq::add_image_set_directory(strip, dirpath.c_str());
184 for (const int i : filenames.index_range()) {
185 seq::add_image_load_file(ctx.scene, strip, i, filenames[i].c_str());
186 }
188 return strip;
189}
190
192 Clip &clip,
193 ListBaseT<Strip> &seqbase,
194 const int channel,
195 const int start,
196 const int duration,
197 const bool is_audio)
198{
199 MediaReference *reference = clip.media_reference();
200 const TimeRange range = clip.trimmed_range();
201 const std::optional<TimeRange> available_range = reference ? reference->available_range() :
202 std::nullopt;
203 const bool has_available_start = available_range &&
204 available_range->start_time().is_valid_time();
205 const RationalTime media_time = range.start_time() - (has_available_start ?
206 available_range->start_time() :
207 RationalTime());
208 const int media_start = to_frames(ctx, media_time);
209
211 seq::add_load_data_init(&load_data, clip.name().c_str(), nullptr, start - media_start, channel);
212 load_data.allow_invalid_file = true;
213 if (const std::optional<eSeqImageFitMethod> fit_method = resolve_fit_method(clip)) {
214 load_data.fit_method = *fit_method;
215 }
216
217 if (auto *external = dynamic_cast<ExternalReference *>(reference)) {
218 const std::string filepath = url_to_filepath(external->target_url());
219 STRNCPY(load_data.path, filepath.c_str());
220 if (is_audio) {
221 Strip *strip = seq::add_sound_strip(ctx.bmain, ctx.scene, &seqbase, &load_data);
222 if (strip) {
223 strip->sound_offset = media_start / ctx.fps - media_time.to_seconds();
224 }
225 return strip;
226 }
227 if (!BLI_path_extension_check_array(filepath.c_str(), imb_ext_image)) {
228 return seq::add_movie_strip(ctx.bmain, ctx.scene, &seqbase, &load_data);
229 }
230 char dirpath[FILE_MAX], filename[FILE_MAXFILE];
232 filepath.c_str(), dirpath, sizeof(dirpath), filename, sizeof(filename));
233 load_data.start_frame = start;
234 return add_image_strip(ctx, seqbase, load_data, dirpath, {filename});
235 }
236
237 if (auto *sequence = dynamic_cast<ImageSequenceReference *>(reference)) {
238 Vector<std::string> filenames;
239 for (const int i : IndexRange(sequence->number_of_images_in_sequence())) {
240 char filename[FILE_MAX];
242 sizeof(filename),
243 sequence->name_prefix().c_str(),
244 sequence->name_suffix().c_str(),
245 sequence->frame_zero_padding(),
246 sequence->start_frame() + i * sequence->frame_step());
247 filenames.append(filename);
248 }
249 return add_image_strip(
250 ctx, seqbase, load_data, url_to_filepath(sequence->target_url_base()), filenames);
251 }
252
253 std::optional<StripType> type;
254 if (auto *generator = dynamic_cast<GeneratorReference *>(reference)) {
255 const std::string kind = generator->generator_kind();
256 type = strip_type_from_identifier(&kind);
257 if (!type) {
258 type = resolve_generator_type(*generator);
259 }
260 if (!type) {
261 type = kdenlive_generator_type(*generator);
262 }
263 }
264 else if (resolve_is_adjustment_clip(clip)) {
266 }
267 if (type && seq::effect_type_get_min_num_inputs(*type) == 2) {
268 ctx.pending_effects.append({&clip, &seqbase, channel, start, duration, *type});
269 return nullptr;
270 }
271 if (type) {
272 load_data.start_frame = start;
273 load_data.effect.type = *type;
274 load_data.effect.length = duration;
275 return seq::add_effect_strip(ctx.scene, &seqbase, &load_data);
276 }
277
279 const std::string *scene_name = strip_metadata_string(clip, "scene");
280 load_data.scene = scene_name ? reinterpret_cast<Scene *>(BKE_libblock_find_name(
281 ctx.bmain, ID_SCE, scene_name->c_str())) :
282 nullptr;
283 if (load_data.scene) {
284 return seq::add_scene_strip(ctx.scene, &seqbase, &load_data);
285 }
286 }
287
290 "Clip '%s' was not imported, its media is not supported",
291 clip.name().c_str());
292 return nullptr;
293}
294
296 Item &item,
297 ListBaseT<Strip> &seqbase,
298 Strip &input)
299{
300 for (SerializableObject::Retainer<otio::Effect> &effect : item.effects()) {
301 std::optional<StripType> type = strip_type_from_identifier(
302 strip_metadata_string(*effect, "type"));
303 if (!type) {
304 const std::string name = effect->effect_name();
305 type = dynamic_cast<LinearTimeWarp *>(effect.value) ||
306 dynamic_cast<FreezeFrame *>(effect.value) ?
309 }
310 if (!type || seq::effect_type_get_min_num_inputs(*type) != 1) {
311 continue;
312 }
313 auto *time_warp = dynamic_cast<LinearTimeWarp *>(effect.value);
314 if (time_warp && time_warp->time_scalar() < 0.0) {
315 input.flag |= SEQ_REVERSE_FRAMES;
316 if (time_warp->time_scalar() == -1.0) {
317 continue;
318 }
319 }
320
323 &load_data, effect->name().c_str(), nullptr, input.left_handle(), input.channel + 1);
324 load_data.effect.type = *type;
325 load_data.effect.input1 = &input;
326 Strip *strip = seq::add_effect_strip(ctx.scene, &seqbase, &load_data);
327
328 if (time_warp) {
329 SpeedControlVars *speed = static_cast<SpeedControlVars *>(strip->effectdata);
331 speed->speed_fader = std::abs(time_warp->time_scalar());
332 }
333 place_strip(ctx,
334 strip,
335 seqbase,
336 input.left_handle(),
337 input.right_handle(ctx.scene) - input.left_handle(),
338 *effect);
339 }
340}
341
342static void import_stack(StripImportContext &ctx,
343 Stack &stack,
344 ListBaseT<Strip> &seqbase,
345 ListBaseT<SeqTimelineChannel> &channels,
346 int origin);
347
349 Item &item,
350 ListBaseT<Strip> &seqbase,
351 const int channel,
352 const int start,
353 const int duration,
354 const bool is_audio)
355{
356 Strip *strip = nullptr;
357 if (auto *clip = dynamic_cast<Clip *>(&item)) {
358 strip = clip_to_strip(ctx, *clip, seqbase, channel, start, duration, is_audio);
359 }
360 else if (auto *stack = dynamic_cast<Stack *>(&item)) {
362 seq::add_load_data_init(&load_data, stack->name().c_str(), nullptr, start, channel);
363 strip = seq::add_meta_strip(ctx.scene, &seqbase, &load_data);
364 import_stack(ctx,
365 *stack,
366 strip->seqbase,
367 strip->channels,
368 start - to_frames(ctx, item.trimmed_range().start_time()));
370 }
371
372 if (!strip) {
373 return nullptr;
374 }
375 place_strip(ctx, strip, seqbase, start, duration, item);
376 add_strip_effects(ctx, item, seqbase, *strip);
377 return strip;
378}
379
381 Transition &transition,
382 ListBaseT<Strip> &seqbase,
383 Strip &from,
384 Strip &to)
385{
386 from.right_handle_set(ctx.scene,
387 from.right_handle(ctx.scene) - to_frames(ctx, transition.in_offset()));
388 to.left_handle_set(ctx.scene, to.left_handle() + to_frames(ctx, transition.out_offset()));
389
392 &load_data, transition.name().c_str(), nullptr, from.right_handle(ctx.scene), from.channel);
393 std::optional<StripType> type = strip_type_from_identifier(
394 strip_metadata_string(transition, "type"));
395 if (!type) {
396 type = resolve_transition_type(transition);
397 }
398 load_data.effect.type = type.value_or(STRIP_TYPE_CROSS);
399 load_data.effect.input1 = &from;
400 load_data.effect.input2 = &to;
401 Strip *strip = seq::add_effect_strip(ctx.scene, &seqbase, &load_data);
402 ctx.strip_metadata.append({strip, &transition});
403}
404
406 Track &track,
407 ListBaseT<Strip> &seqbase,
408 const int channel,
409 const int origin)
410{
411 const bool is_audio = track.kind() == Track::Kind::audio;
412 const std::vector<SerializableObject::Retainer<Composable>> &children = track.children();
413 Vector<Strip *> strips;
414
415 int frame = origin;
416 for (const SerializableObject::Retainer<Composable> &child : children) {
417 Strip *strip = nullptr;
418 if (auto *item = dynamic_cast<Item *>(child.value)) {
419 const int duration = to_frames(ctx, item->trimmed_range().duration());
420 if (!dynamic_cast<Gap *>(item)) {
421 strip = import_item(ctx, *item, seqbase, channel, frame, duration, is_audio);
422 }
423 frame += duration;
424 }
425 strips.append(strip);
426 }
427
428 for (const int i : strips.index_range().drop_front(1).drop_back(1)) {
429 auto *transition = dynamic_cast<Transition *>(children[i].value);
430 if (transition && strips[i - 1] && strips[i + 1]) {
431 add_transition(ctx, *transition, seqbase, *strips[i - 1], *strips[i + 1]);
432 }
433 }
434}
435
437 Stack &stack,
438 ListBaseT<Strip> &seqbase,
439 ListBaseT<SeqTimelineChannel> &channels,
440 const int origin)
441{
442 int channel = 0;
443 for (const SerializableObject::Retainer<Composable> &child : stack.children()) {
444 auto *track = dynamic_cast<Track *>(child.value);
445 if (!track) {
446 continue;
447 }
448 const std::any *track_channel = blender_metadata(*track, "channel");
449 const int64_t *channel_index = track_channel ? std::any_cast<int64_t>(track_channel) : nullptr;
450 channel = channel_index ? int(*channel_index) : channel + 1;
451 if (SeqTimelineChannel *timeline_channel = seq::channel_get_by_index(&channels, channel)) {
452 if (!track->name().empty()) {
453 STRNCPY_UTF8(timeline_channel->name, track->name().c_str());
454 }
455 SET_FLAG_FROM_TEST(timeline_channel->flag, !track->enabled(), SEQ_CHANNEL_MUTE);
456 SET_FLAG_FROM_TEST(timeline_channel->flag, resolve_track_locked(*track), SEQ_CHANNEL_LOCK);
457 }
458 import_track(ctx, *track, seqbase, channel, origin);
459 }
460}
461
463{
464 Editing *editing = seq::editing_get(ctx.scene);
465 for (const PendingEffect &pending : ctx.pending_effects) {
466 const std::string *input1 = strip_metadata_string(*pending.clip, "input_1");
467 const std::string *input2 = strip_metadata_string(*pending.clip, "input_2");
468
471 &load_data, pending.clip->name().c_str(), nullptr, pending.start, pending.channel);
472 load_data.effect.type = pending.type;
473 load_data.effect.input1 = input1 ? seq::lookup_strip_by_name(editing, input1->c_str()) :
474 nullptr;
475 load_data.effect.input2 = input2 ? seq::lookup_strip_by_name(editing, input2->c_str()) :
476 nullptr;
477 if (!load_data.effect.input1 || !load_data.effect.input2) {
480 "Effect '%s' was not imported, its inputs are missing",
481 pending.clip->name().c_str());
482 continue;
483 }
484 Strip *strip = seq::add_effect_strip(ctx.scene, pending.seqbase, &load_data);
485 place_strip(ctx, strip, *pending.seqbase, pending.start, pending.duration, *pending.clip);
486 }
487}
488
489static void import_markers(StripImportContext &ctx, Stack &stack, const int origin)
490{
491 for (const SerializableObject::Retainer<Marker> &otio_marker : stack.markers()) {
492 TimeMarker *marker = MEM_new<TimeMarker>(__func__);
493 marker->frame = origin + to_frames(ctx, otio_marker->marked_range().start_time());
494 STRNCPY(marker->name, otio_marker->name().c_str());
495 BLI_addtail(&ctx.scene->markers, marker);
496 }
497}
498
508{
510 auto &dictionary = static_cast<serialize::DictionaryValue &>(value);
511 const std::shared_ptr<serialize::Value> *marked_range = dictionary.lookup("marked_range");
512 if (marked_range && dictionary.lookup_str("OTIO_SCHEMA") == "Marker.2") {
513 dictionary.append("range", *marked_range);
514 }
515 for (const serialize::DictionaryValue::Item &item : dictionary.elements()) {
516 workaround_marker_v2_upgrade(*item.second);
517 }
518 }
519 else if (const serialize::ArrayValue *array = value.as_array_value()) {
520 for (const std::shared_ptr<serialize::Value> &item : array->elements()) {
522 }
523 }
524}
525
534 const char *filepath, opentimelineio::OPENTIMELINEIO_VERSION_NS::ErrorStatus *error_status)
535{
536 const std::shared_ptr<serialize::Value> value = serialize::read_json_file(filepath);
537 if (!value) {
538 return SerializableObject::from_json_file(filepath, error_status);
539 }
541 serialize::JsonFormatter formatter;
542 std::stringstream json;
543 formatter.serialize(json, *value);
544 return SerializableObject::from_json_string(json.str(), error_status);
545}
546
547static Scene *import_scene(bContext *C, const std::string &name)
548{
550 if (!scene || (scene->ed && !BLI_listbase_is_empty(&scene->ed->seqbase))) {
551 scene = BKE_scene_add(CTX_data_main(C), name.empty() ? DATA_("OTIO Import") : name.c_str());
552 }
553 seq::editing_ensure(scene);
554 return scene;
555}
556
558{
559 opentimelineio::OPENTIMELINEIO_VERSION_NS::ErrorStatus error_status;
560 SerializableObject::Retainer<SerializableObject> object(
561 read_otio_file_with_workarounds(params.filepath, &error_status));
562 auto *timeline = dynamic_cast<Timeline *>(object.value);
563 if (!timeline) {
565 "Failed to read OTIO file '%s': %s",
566 params.filepath,
567 error_status.full_description.c_str());
568 BKE_reportf(params.reports, RPT_ERROR, "Failed to read OTIO timeline '%s'", params.filepath);
569 return nullptr;
570 }
571
572 Main *bmain = CTX_data_main(C);
573 Scene *scene = import_scene(C, timeline->name());
574
575 const std::optional<RationalTime> global_start = timeline->global_start_time();
576 if (global_start) {
577 scene->r.frs_sec = short(std::round(global_start->rate()));
578 scene->r.frs_sec_base = float(scene->r.frs_sec / global_start->rate());
579 }
580
581 StripImportContext ctx{bmain, scene, params, scene->frames_per_second()};
582 const int origin = global_start ? to_frames(ctx, *global_start) : scene->r.sfra;
583 const int duration = to_frames(ctx, timeline->duration());
584 scene->r.sfra = origin;
585 scene->r.efra = origin + std::max(duration - 1, 0);
586
587 import_stack(ctx, *timeline->tracks(), scene->ed->seqbase, scene->ed->channels, origin);
589 for (auto &[strip, otio_object] : ctx.strip_metadata) {
590 PointerRNA ptr = RNA_pointer_create_discrete(&scene->id, RNA_Strip, strip);
592 bmain, scene->ed, resolve_strip_properties(*scene, *strip, *otio_object), ptr);
593 rna_from_dictionary(bmain, scene->ed, kdenlive_strip_properties(*otio_object), ptr);
594 if (const AnyDictionary *metadata = strip_metadata(*otio_object)) {
595 rna_from_dictionary(bmain, scene->ed, *metadata, ptr);
596 }
597 store_foreign_metadata(*otio_object, strip->prop);
598 }
600 import_markers(ctx, *timeline->tracks(), origin);
601 store_foreign_metadata(*timeline, scene->id.properties);
602
604 DEG_id_tag_update(&scene->id,
606 return scene;
607}
608
609} // namespace blender::io::otio
#define FILE_MAXFILE
#define FILE_MAX
#define STRNCPY_UTF8(dst, src)
#define DATA_(msgid)
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define C
Definition RandGen.cpp:29
#define SET_FLAG_FROM_TEST(value, test, flag)
constexpr IndexRange drop_back(int64_t n) const
constexpr IndexRange()=default
constexpr IndexRange drop_front(int64_t n) const
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
void append(const T &value)
IndexRange index_range() const
const std::shared_ptr< Value > * lookup(StringRef key) const
Definition serialize.cc:265
std::pair< std::string, std::shared_ptr< Value > > Item
void serialize(std::ostream &os, const Value &value) override
Definition serialize.cc:370
const ArrayValue * as_array_value() const
Definition serialize.cc:56
float4 load_data(StoredFloat4 data)
std::string filename(const std::string_view &str, size_t pos)
bool resolve_track_locked(Track &track)
static int to_frames(const StripImportContext &ctx, const RationalTime &time)
static void add_transition(StripImportContext &ctx, Transition &transition, ListBaseT< Strip > &seqbase, Strip &from, Strip &to)
void resolve_connect_strips(const Span< std::pair< Strip *, SerializableObjectWithMetadata * > > strips)
static Strip * clip_to_strip(StripImportContext &ctx, Clip &clip, ListBaseT< Strip > &seqbase, const int channel, const int start, const int duration, const bool is_audio)
static Scene * import_scene(bContext *C, const std::string &name)
static const AnyDictionary * strip_metadata(SerializableObjectWithMetadata &object)
SerializableObject * read_otio_file_with_workarounds(const char *filepath, opentimelineio::OPENTIMELINEIO_VERSION_NS::ErrorStatus *error_status)
Scene * importer_main(bContext *C, const OTIOImportParams &params)
std::optional< StripType > kdenlive_generator_type(const GeneratorReference &generator)
static Strip * add_image_strip(StripImportContext &ctx, ListBaseT< Strip > &seqbase, seq::LoadData &load_data, const std::string &dirpath, const Span< std::string > filenames)
static void import_stack(StripImportContext &ctx, Stack &stack, ListBaseT< Strip > &seqbase, ListBaseT< SeqTimelineChannel > &channels, int origin)
static void import_markers(StripImportContext &ctx, Stack &stack, const int origin)
static void add_pending_effects(StripImportContext &ctx)
static const std::any * blender_metadata(SerializableObjectWithMetadata &object, const char *key)
static const std::string * strip_metadata_string(SerializableObjectWithMetadata &object, const char *key)
static std::optional< StripType > strip_type_from_identifier(const std::string *identifier)
static std::string url_to_filepath(const std::string &url)
AnyDictionary kdenlive_strip_properties(SerializableObjectWithMetadata &object)
std::optional< eSeqImageFitMethod > resolve_fit_method(Item &item)
static void workaround_marker_v2_upgrade(serialize::Value &value)
void store_foreign_metadata(const SerializableObjectWithMetadata &object, IDProperty *&properties)
void rna_from_dictionary(Main *bmain, Editing *editing, const AnyDictionary &dictionary, PointerRNA &ptr)
static CLG_LogRef LOG
AnyDictionary resolve_strip_properties(const Scene &scene, const Strip &strip, SerializableObjectWithMetadata &object)
static void add_strip_effects(StripImportContext &ctx, Item &item, ListBaseT< Strip > &seqbase, Strip &input)
static void import_track(StripImportContext &ctx, Track &track, ListBaseT< Strip > &seqbase, const int channel, const int origin)
static void place_strip(StripImportContext &ctx, Strip *strip, ListBaseT< Strip > &seqbase, const int start, const int duration, SerializableObjectWithMetadata &object)
std::optional< StripType > resolve_generator_type(const GeneratorReference &generator)
bool resolve_is_adjustment_clip(Clip &clip)
static Strip * import_item(StripImportContext &ctx, Item &item, ListBaseT< Strip > &seqbase, const int channel, const int start, const int duration, const bool is_audio)
std::optional< StripType > resolve_transition_type(Transition &transition)
std::shared_ptr< Value > read_json_file(StringRef path)
Definition serialize.cc:401
Strip * add_effect_strip(Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Definition strip_add.cc:174
Strip * lookup_strip_by_name(Editing *ed, const char *key)
Strip * add_image_strip(Main *bmain, Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Definition strip_add.cc:245
Strip * add_meta_strip(Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Definition strip_add.cc:376
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
void add_image_load_file(Scene *scene, Strip *strip, size_t strip_frame, const char *filename)
Definition strip_add.cc:210
void add_image_set_directory(Strip *strip, const char *dirpath)
Definition strip_add.cc:205
Editing * editing_ensure(Scene *scene)
Definition sequencer.cc:309
void time_update_meta_strip_range(const Scene *scene, Strip *strip_meta)
Strip * add_sound_strip(Main *, Scene *, ListBaseT< Strip > *, LoadData *)
Definition strip_add.cc:367
void add_image_init_alpha_mode(Main *bmain, Scene *scene, Strip *strip)
Definition strip_add.cc:216
Strip * add_scene_strip(Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Definition strip_add.cc:138
SeqTimelineChannel * channel_get_by_index(const ListBaseT< SeqTimelineChannel > *channels, const int channel_index)
Definition channels.cc:59
void transform_shuffle_vertical(ListBaseT< Strip > *seqbasep, Span< Strip * > strips, Scene *scene, const int channel_delta)
int effect_type_get_min_num_inputs(StripType type)
Definition effects.cc:347
Strip * add_movie_strip(Main *bmain, Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Definition strip_add.cc:394
void add_load_data_init(LoadData *load_data, const char *name, const char *path, const int start_frame, const int channel)
Definition strip_add.cc:69
BMesh Iterators.
__int64 int64_t
Definition BKE_text.h:90
char * STRNCPY(char(&dst)[N], const char *src)
ID * BKE_libblock_find_name(Main *bmain, short type, const char *name, const std::optional< Library * > lib=std::nullopt) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition lib_id.cc:1808
@ RPT_WARNING
Definition BKE_report.hh:40
Scene * CTX_data_sequencer_scene(const bContext *C)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
bool RNA_property_enum_value(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const char *identifier, int *r_value)
BLI_INLINE bool BLI_listbase_is_empty(const ListBase *lb)
void DEG_id_tag_update(ID *id, unsigned int flags)
Scene * BKE_scene_add(Main *bmain, const char *name)
Definition scene.cc:2200
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
Definition report.cc:191
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
Main * CTX_data_main(const bContext *C)
bool BLI_path_extension_check_array(const char *path, const char **ext_array) ATTR_NONNULL(1
@ ID_RECALC_ANIMATION
Definition DNA_ID.h:1077
@ ID_RECALC_AUDIO_FPS
Definition DNA_ID.h:1127
@ ID_RECALC_SEQUENCER_STRIPS
Definition DNA_ID.h:1122
void BLI_path_split_dir_file(const char *filepath, char *dir, size_t dir_maxncpy, char *file, size_t file_maxncpy) ATTR_NONNULL(1
void BLI_path_sequence_encode(char *path, size_t path_maxncpy, const char *head, const char *tail, unsigned short numlen, int pic)
void DEG_relations_tag_update(Main *bmain)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
ListBaseT< SeqTimelineChannel > channels
ListBaseT< Strip > seqbase
IDProperty * properties
Definition DNA_ID.h:481
char filepath[FILE_MAX]
Definition IO_otio.hh:27
struct Editing * ed
ListBaseT< TimeMarker > markers
struct RenderData r
eEffectSpeedControlType speed_control_type
ListBaseT< Strip > * seqbase
Vector< PendingEffect > pending_effects
const OTIOImportParams & params
Vector< std::pair< Strip *, SerializableObjectWithMetadata * > > strip_metadata
float length() const
Definition sky_math.h:294