5#include "testing/testing.h"
35#include "RNA_prototypes.hh"
49#include "opentimelineio/anyVector.h"
50#include "opentimelineio/clip.h"
51#include "opentimelineio/effect.h"
52#include "opentimelineio/externalReference.h"
53#include "opentimelineio/gap.h"
54#include "opentimelineio/generatorReference.h"
55#include "opentimelineio/imageSequenceReference.h"
56#include "opentimelineio/linearTimeWarp.h"
57#include "opentimelineio/marker.h"
58#include "opentimelineio/missingReference.h"
59#include "opentimelineio/serialization.h"
60#include "opentimelineio/stack.h"
61#include "opentimelineio/timeline.h"
62#include "opentimelineio/track.h"
63#include "opentimelineio/transition.h"
90 BlendfileLoadingBaseTest::SetUp();
161 ASSERT_TRUE(timeline->to_json_file(
otio_path));
167 if (strstr(report.
message, text)) {
177 BLI_path_join(path,
sizeof(path), tests::flags_test_asset_dir().c_str(), relative_path);
185 BLI_copy(
asset_path(
"io_tests/blend_scene/textures/alpha.png").c_str(), path.c_str()), 0);
195 ListBaseT<Strip> &seqbase,
201 Strip *input1 =
nullptr,
202 Strip *input2 =
nullptr)
243 ListBaseT<Strip> &strips_a,
245 ListBaseT<Strip> &strips_b)
248 for (
Strip &a : strips_a) {
250 ASSERT_NE(
b,
nullptr) << a.name + 2;
252 EXPECT_EQ(a.channel,
b->channel) << a.name + 2;
253 EXPECT_EQ(a.left_handle(),
b->left_handle()) << a.name + 2;
254 EXPECT_EQ(a.right_handle(scene_a),
b->right_handle(scene_b)) << a.name + 2;
266 ASSERT_NE(imported,
nullptr);
273 Scene *scene = new_scene();
276 TimeMarker *marker = MEM_new<TimeMarker>(__func__);
281 Scene *imported = round_trip(scene);
282 ASSERT_NE(imported,
nullptr);
288 EXPECT_STREQ(imported->
markers.first()->name,
"Marker");
289 EXPECT_TRUE(read_otio()->tracks()->children().empty());
294 Scene *scene = new_scene();
295 Strip *
color = add_color(scene,
"Color", 1, 1, 10);
315 expect_round_trip(scene);
320#if !defined(WITH_FFMPEG) || !defined(WITH_AUDASPACE)
321 GTEST_SKIP() <<
"Movie or sound support is unavailable";
323 Scene *scene = new_scene();
327 asset_path(
"sequence_editing/ffmpeg/media/grad_h264.mp4").c_str(),
331 movie->handles_set(scene, movie->left_handle() + 2, movie->right_handle(scene) - 3);
335 sound->volume = 0.5f;
343 add_images(scene,
"Still", 3, 20, {
"still.png"});
344 expect_round_trip(scene);
349 Scene *scene = new_scene();
350 add_images(scene,
"Sequence", 1, 1, {
"shot.0101.png",
"shot.0103.png",
"shot.0105.png"});
351 add_images(scene,
"Unnamed", 2, 1, {
"a.png",
"b.png"});
352 Scene *imported = round_trip(scene);
353 ASSERT_NE(imported,
nullptr);
355 SerializableObject::Retainer<Timeline> timeline = read_otio();
356 auto *reference =
dynamic_cast<ImageSequenceReference *
>(
357 timeline->find_clips()[0]->media_reference());
358 ASSERT_NE(reference,
nullptr);
359 EXPECT_EQ(reference->name_prefix(),
"shot.");
360 EXPECT_EQ(reference->start_frame(), 101);
362 EXPECT_EQ(reference->frame_zero_padding(), 4);
363 EXPECT_TRUE(has_report(
"1 image sequence(s) with non-sequential filenames"));
366 ASSERT_NE(sequence,
nullptr);
368 EXPECT_STREQ(sequence->
data->stripdata[2].filename,
"shot.0105.png");
374 Scene *scene = new_scene();
375 add_color(scene,
"Before Start", 1, -5, 10);
376 add_color(scene,
"A", 1, 10, 10);
377 add_color(scene,
"B", 1, 40, 10);
384 meta->handles_set(scene, 27, 33);
386 add_color(scene,
"High Channel", 7, 30, 5);
391 Scene *imported = round_trip(scene);
392 ASSERT_NE(imported,
nullptr);
396 EXPECT_STREQ(imported_channel->
name,
"Titles");
402#ifndef WITH_AUDASPACE
403 GTEST_SKIP() <<
"Sound support is unavailable";
405 Scene *scene = new_scene();
411 &
load_data,
"Sound", asset_path(
"sound/pink_panther.ogg").c_str(), 10, 2);
413 sound->handles_set(scene, 10, 20);
415 meta->handles_set(scene, 10, 20);
417 Scene *imported = round_trip(scene);
418 ASSERT_NE(imported,
nullptr);
420 SerializableObject::Retainer<Timeline> timeline = read_otio();
421 ASSERT_EQ(timeline->video_tracks().size(), 1);
422 ASSERT_EQ(timeline->audio_tracks().size(), 1);
423 EXPECT_NE(
dynamic_cast<Stack *
>(timeline->video_tracks()[0]->children().back().value),
nullptr);
424 EXPECT_NE(
dynamic_cast<Stack *
>(timeline->audio_tracks()[0]->children().back().value),
nullptr);
429 EXPECT_EQ(imported_meta.left_handle(), 10);
430 EXPECT_EQ(imported_meta.right_handle(imported), 20);
432 EXPECT_EQ(imported_meta.seqbase.first()->left_handle(), 10);
438#ifndef WITH_AUDASPACE
439 GTEST_SKIP() <<
"Sound support is unavailable";
441 Scene *scene = new_scene();
442 const double fps = scene->frames_per_second();
443 const std::pair<const char *, float> cases[] = {{
"Small", 0.3f}, {
"Large", 0.7f}};
447 &
load_data, cases[i].first, asset_path(
"sound/pink_panther.ogg").c_str(), 1, i + 1);
449 sound->handles_set(scene, 6, 26);
450 sound->sound_offset = cases[i].second / fps;
453 Scene *imported = round_trip(scene);
454 ASSERT_NE(imported,
nullptr);
456 SerializableObject::Retainer<Timeline> timeline = read_otio();
457 for (
const auto &[name, offset] : cases) {
460 ASSERT_NE(strip,
nullptr) << name;
461 EXPECT_EQ(strip->left_handle(), original->left_handle()) << name;
462 EXPECT_EQ(strip->right_handle(imported), original->right_handle(scene)) << name;
463 EXPECT_NEAR(strip->content_start() + strip->sound_offset * fps,
464 original->content_start() + original->sound_offset * fps,
468 for (
const SerializableObject::Retainer<Clip> &clip : timeline->find_clips()) {
469 if (clip->name() == name) {
470 EXPECT_NEAR(clip->source_range()->start_time().value_rescaled_to(fps), 5.0 - offset, 1
e-4)
479 Scene *scene = new_scene();
480 ListBaseT<Strip> &seqbase = scene->
ed->
seqbase;
481 Strip *a = add_color(scene,
"A", 1, 1, 10);
482 Strip *
b = add_color(scene,
"B", 1, 16, 10);
485 Strip *c = add_color(scene,
"C", 2, 30, 10);
486 Strip *d = add_color(scene,
"D", 2, 44, 10);
492 wipe->effect_fader = 0.25f;
494 expect_round_trip(scene);
499 Scene *scene = new_scene();
500 Strip *a = add_color(scene,
"A", 1, 1, 20);
501 Strip *
b = add_color(scene,
"B", 2, 10, 20);
504 Scene *imported = round_trip(scene);
505 ASSERT_NE(imported,
nullptr);
506 EXPECT_TRUE(has_report(
"Transition strip 'Cross' was not exported"));
513 Scene *scene = new_scene();
514 ListBaseT<Strip> &seqbase = scene->
ed->
seqbase;
515 Strip *a = add_color(scene,
"A", 1, 1, 20);
516 Strip *
b = add_color(scene,
"B", 3, 1, 20);
528 over->effect_fader = 0.5f;
531 expect_round_trip(scene);
536 Scene *scene = new_scene();
539 load_data.scene = new_scene(
"Shot Scene");
542 Scene *imported = round_trip(scene);
543 ASSERT_NE(imported,
nullptr);
545 EXPECT_NE(
dynamic_cast<MissingReference *
>(read_otio()->find_clips()[0]->media_reference()),
552 auto timeline = SerializableObject::Retainer<Timeline>(
553 new Timeline(
"Foreign", RationalTime(0, 24)));
554 auto track = SerializableObject::Retainer<Track>(
new Track());
555 AnyDictionary resolve;
556 resolve[
"Clip Color"] = std::string(
"Orange");
557 auto clip = SerializableObject::Retainer<Clip>(
new Clip(
559 new GeneratorReference(
"",
"COLOR", TimeRange(RationalTime(0, 24), RationalTime(10, 24))),
560 TimeRange(RationalTime(0, 24), RationalTime(10, 24))));
561 clip->metadata()[
"Resolve_OTIO"] = resolve;
562 track->append_child(clip);
563 timeline->tracks()->append_child(track);
564 write_otio(timeline);
566 Scene *imported = import_otio();
567 ASSERT_NE(imported,
nullptr);
569 ASSERT_NE(strip,
nullptr);
572 ASSERT_NE(group,
nullptr);
575 export_otio(imported);
576 AnyDictionary exported = read_otio()->find_clips()[0]->metadata();
578 std::any_cast<AnyDictionary>(exported[
"Resolve_OTIO"])[
"Clip Color"]),
584 auto timeline = SerializableObject::Retainer<Timeline>(
585 new Timeline(
"Foreign", RationalTime(90000, 25)));
586 auto track = SerializableObject::Retainer<Track>(
new Track());
587 track->append_child(
new Gap(RationalTime(10, 25)));
590 new ExternalReference(
"file:///a%20b/still.png",
591 TimeRange(RationalTime(1000, 25), RationalTime(100, 25))),
592 TimeRange(RationalTime(1010, 25), RationalTime(40, 50))));
593 timeline->tracks()->append_child(track);
594 write_otio(timeline);
596 Scene *imported = import_otio();
597 ASSERT_NE(imported,
nullptr);
601 ASSERT_NE(strip,
nullptr);
604 EXPECT_EQ(strip->right_handle(imported), 90030);
609 const std::vector<std::pair<std::string, std::any>> &values)
611 AnyVector parameters;
612 for (
const auto &[
id, value] : values) {
618 AnyDictionary effect;
619 effect[
"Effect Name"] = name;
620 effect[
"Enabled"] =
true;
621 effect[
"Parameters"] = parameters;
627 auto timeline = SerializableObject::Retainer<Timeline>(
628 new Timeline(
"Markers", RationalTime(0, 24)));
629 timeline->tracks()->markers().push_back(
630 new Marker(
"Old", TimeRange(RationalTime(5, 24), RationalTime(1, 24)), std::nullopt));
631 std::string json = timeline->to_json_string();
632 const std::string schema =
"\"Marker.3\"";
633 const size_t schema_start = json.find(schema);
634 ASSERT_NE(schema_start, std::string::npos);
635 json.replace(schema_start, schema.size(),
"\"Marker.2\"");
636 fstream stream(otio_path, std::ios::out);
640 Scene *imported = import_otio();
641 ASSERT_NE(imported,
nullptr);
644 EXPECT_STREQ(imported->
markers.first()->name,
"Old");
649 const TimeRange range(RationalTime(0, 24), RationalTime(10, 24));
650 auto *generator =
new GeneratorReference(
"Solid Color",
"Solid Color", range);
651 generator->parameters()[
"Resolve_OTIO"] = AnyVector{
652 resolve_effect(
"Solid Color", {{
"color", std::string(
"#ff8000")}})};
653 auto clip = SerializableObject::Retainer<Clip>(
new Clip(
"Solid Color", generator, range));
654 AnyDictionary clip_resolve;
655 clip_resolve[
"Link Group ID"] =
int64_t(1);
656 clip->metadata()[
"Resolve_OTIO"] = clip_resolve;
658 auto add_effect = [&](
const AnyDictionary &resolve) {
659 auto *effect =
new otio::Effect(
"",
"Resolve Effect");
660 effect->metadata()[
"Resolve_OTIO"] = resolve;
661 clip->effects().push_back(effect);
664 {{
"transformationZoomX", 2.0},
665 {
"transformationPan", 0.25},
666 {
"transformationRotationAngle", 90.0}}));
669 auto track = SerializableObject::Retainer<Track>(
new Track(
"V1"));
670 AnyDictionary track_resolve;
671 track_resolve[
"Locked"] =
true;
672 track->metadata()[
"Resolve_OTIO"] = track_resolve;
673 track->append_child(clip);
674 auto timeline = SerializableObject::Retainer<Timeline>(
new Timeline(
"Resolve"));
675 timeline->tracks()->append_child(track);
676 write_otio(timeline);
678 Scene *imported = import_otio();
679 ASSERT_NE(imported,
nullptr);
681 ASSERT_NE(strip,
nullptr);
684 EXPECT_FLOAT_EQ(
color->col[0], 1.0f);
686 EXPECT_FLOAT_EQ(
color->col[2], 0.0f);
687 EXPECT_FLOAT_EQ(strip->
data->transform->scale_x, 2.0f);
688 EXPECT_FLOAT_EQ(strip->
data->transform->scale_y, 1.0f);
689 EXPECT_FLOAT_EQ(strip->
data->transform->xofs, 0.25f * imported->
r.
xsch);
692 EXPECT_FLOAT_EQ(strip->blend_opacity, 50.0f);
700 const TimeRange range(RationalTime(0, 24), RationalTime(10, 24));
701 auto track = SerializableObject::Retainer<Track>(
new Track());
702 for (
const double time_scalar : {-1.0, -2.0}) {
703 auto *clip =
new Clip(
704 std::to_string(time_scalar),
new GeneratorReference(
"",
"COLOR", range), range);
705 clip->effects().push_back(
new LinearTimeWarp(
"",
"", time_scalar));
706 track->append_child(clip);
708 auto timeline = SerializableObject::Retainer<Timeline>(
new Timeline(
"Reverse"));
709 timeline->tracks()->append_child(track);
710 write_otio(timeline);
712 Scene *imported = import_otio();
713 ASSERT_NE(imported,
nullptr);
715 int speed_strips = 0;
730 const TimeRange range(RationalTime(0, 24), RationalTime(20, 24));
731 auto image = SerializableObject::Retainer<Clip>(
733 new ExternalReference(asset_path(
"sequence_editing/filter/31x17.png"), range),
735 auto add_effect = [&](Clip &clip,
const AnyDictionary &resolve) {
736 auto *effect =
new otio::Effect(
"",
"Resolve Effect");
737 effect->metadata()[
"Resolve_OTIO"] = resolve;
738 clip.effects().push_back(effect);
743 {{
"transformationFlipX",
true},
744 {
"transformationAnchorPoint", AnyVector{0.1, 0.05}}}));
745 AnyDictionary composite =
resolve_effect(
"Composite", {{
"opacity", 100.0}});
746 AnyDictionary key_start;
747 key_start[
"Value"] = 100.0;
748 AnyDictionary key_end;
749 key_end[
"Value"] = 0.0;
751 keys[
"0"] = key_start;
752 keys[
"10"] = key_end;
753 std::any_cast<AnyDictionary &>(
754 std::any_cast<AnyVector &>(composite[
"Parameters"])[0])[
"Key Frames"] = keys;
755 add_effect(*
image, composite);
757 auto *wipe =
new Transition(
758 "Edge Wipe",
"Custom_Transition", RationalTime(5, 24), RationalTime(5, 24));
759 AnyDictionary wipe_resolve;
761 wipe->metadata()[
"Resolve_OTIO"] = wipe_resolve;
763 AnyDictionary link_resolve;
764 link_resolve[
"Link Group ID"] =
int64_t(7);
765 auto *linked_video =
new Clip(
"Linked Video",
new GeneratorReference(
"",
"COLOR", range), range);
766 linked_video->metadata()[
"Resolve_OTIO"] = link_resolve;
767 auto *linked_other =
new Clip(
"Linked Other",
new GeneratorReference(
"",
"COLOR", range), range);
768 linked_other->metadata()[
"Resolve_OTIO"] = link_resolve;
770 auto track_1 = SerializableObject::Retainer<Track>(
new Track(
"V1"));
771 track_1->append_child(
image);
772 track_1->append_child(wipe);
773 track_1->append_child(linked_video);
774 auto *adjustment =
new Clip(
"Adjustment",
new MissingReference(), range);
776 std::any_cast<AnyDictionary &>(
777 adjustment->effects()[0]->metadata()[
"Resolve_OTIO"])[
"Type"] =
int64_t(74);
778 auto track_2 = SerializableObject::Retainer<Track>(
new Track(
"V2"));
779 track_2->append_child(adjustment);
780 track_2->append_child(linked_other);
782 auto *sound =
new Clip(
783 "Sound",
new ExternalReference(asset_path(
"sound/pink_panther.ogg"), range), range);
786 {{
"volume", 0.0}, {
"faderIn", 4.0}, {
"faderOut", 6.0}}));
787 auto track_3 = SerializableObject::Retainer<Track>(
788 new Track(
"A1", std::nullopt, Track::Kind::audio));
789 track_3->append_child(sound);
791 auto timeline = SerializableObject::Retainer<Timeline>(
new Timeline(
"Resolve"));
792 timeline->tracks()->append_child(track_1);
793 timeline->tracks()->append_child(track_2);
794 timeline->tracks()->append_child(track_3);
795 write_otio(timeline);
797 Scene *imported = import_otio();
798 ASSERT_NE(imported,
nullptr);
800 ASSERT_NE(strip,
nullptr);
801 const float scale = std::max(imported->
r.
xsch / 31.0f, imported->
r.
ysch / 17.0f);
802 EXPECT_FLOAT_EQ(strip->
data->transform->scale_x,
scale);
803 EXPECT_FLOAT_EQ(strip->
data->transform->origin[0],
804 0.5f + 0.1f * imported->
r.
ysch / (31.0f *
scale));
805 EXPECT_FLOAT_EQ(strip->
data->transform->origin[1],
806 0.5f + 0.05f * imported->
r.
ysch / (17.0f *
scale));
811 "sequence_editor.strips_all[\"Image\"].blend_alpha",
815 ASSERT_NE(fcurve,
nullptr);
817 EXPECT_FLOAT_EQ(fcurve->
bezt[0].
vec[1][0], strip->left_handle());
818 EXPECT_FLOAT_EQ(fcurve->
bezt[0].
vec[1][1], 1.0f);
819 EXPECT_FLOAT_EQ(fcurve->
bezt[1].
vec[1][0], strip->left_handle() + 10);
820 EXPECT_FLOAT_EQ(fcurve->
bezt[1].
vec[1][1], 0.0f);
823 ASSERT_NE(wipe_strip,
nullptr);
829 ASSERT_NE(video,
nullptr);
830 ASSERT_NE(other,
nullptr);
834 ASSERT_NE(adjustment_strip,
nullptr);
838 ASSERT_NE(sound_strip,
nullptr);
841 "sequence_editor.strips_all[\"Sound\"].volume",
845 ASSERT_NE(volume,
nullptr);
847 const int start = sound_strip->left_handle();
848 const int end = sound_strip->right_handle(imported);
849 EXPECT_FLOAT_EQ(volume->
bezt[0].
vec[1][0], start);
850 EXPECT_FLOAT_EQ(volume->
bezt[0].
vec[1][1], 0.0f);
851 EXPECT_FLOAT_EQ(volume->
bezt[1].
vec[1][0], start + 4);
852 EXPECT_FLOAT_EQ(volume->
bezt[1].
vec[1][1], 1.0f);
853 EXPECT_FLOAT_EQ(volume->
bezt[2].
vec[1][0], end - 6);
854 EXPECT_FLOAT_EQ(volume->
bezt[2].
vec[1][1], 1.0f);
855 EXPECT_FLOAT_EQ(volume->
bezt[3].
vec[1][0], end);
856 EXPECT_FLOAT_EQ(volume->
bezt[3].
vec[1][1], 0.0f);
861 const TimeRange range(RationalTime(0, 24), RationalTime(10, 24));
862 AnyDictionary kdenlive;
863 kdenlive[
"color"] = std::string(
"0xff8000ff");
864 AnyDictionary parameters;
865 parameters[
"kdenlive"] = kdenlive;
866 auto clip = SerializableObject::Retainer<Clip>(
868 new GeneratorReference(
"Orange",
"kdenlive:SolidColor", range, parameters),
870 auto track = SerializableObject::Retainer<Track>(
new Track());
871 track->append_child(clip);
872 auto timeline = SerializableObject::Retainer<Timeline>(
new Timeline(
"Kdenlive"));
873 timeline->tracks()->append_child(track);
874 write_otio(timeline);
876 Scene *imported = import_otio();
877 ASSERT_NE(imported,
nullptr);
879 ASSERT_NE(strip,
nullptr);
882 EXPECT_FLOAT_EQ(
color->col[0], 1.0f);
884 EXPECT_FLOAT_EQ(
color->col[2], 0.0f);
889 auto timeline = SerializableObject::Retainer<Timeline>(
890 new Timeline(
"Kdenlive", RationalTime(0, 24)));
891 auto track = SerializableObject::Retainer<Track>(
new Track());
892 track->append_child(
new Gap(RationalTime(10, 24)));
895 new ExternalReference(
"file:///missing.mov",
896 TimeRange(RationalTime(0, 0), RationalTime(120, 0))),
897 TimeRange(RationalTime(5, 24), RationalTime(10, 24))));
898 timeline->tracks()->append_child(track);
899 write_otio(timeline);
901 Scene *imported = import_otio();
902 ASSERT_NE(imported,
nullptr);
904 ASSERT_NE(strip,
nullptr);
905 EXPECT_FLOAT_EQ(strip->content_start(), 5.0f);
907 EXPECT_EQ(strip->right_handle(imported), 20);
File and directory operations.
#define BLI_path_join(...)
external readfile function prototypes.
Read Blender memory allocation and freeing.
static void TearDownTestCase()
static void SetUpTestCase()
constexpr IndexRange()=default
constexpr int64_t size() const
constexpr IndexRange index_range() const
const T & data(const Action &owning_action) const
SerializableObject::Retainer< Timeline > read_otio()
Vector< std::unique_ptr< bContextStore > > context_store
void set_sequencer_scene(Scene *scene)
static void TearDownTestCase()
static std::string dump(Scene *scene, Strip *strip)
std::string copy_image(const char *filename)
Strip * add_color(Scene *scene, const char *name, const int channel, const int start, int length)
Scene * new_scene(const char *name="Timeline")
static void expect_same_strips(Scene *scene_a, ListBaseT< Strip > &strips_a, Scene *scene_b, ListBaseT< Strip > &strips_b)
std::string asset_path(const char *relative_path)
Strip * add_images(Scene *scene, const char *name, const int channel, const int start, const Span< const char * > filenames)
Scene * round_trip(Scene *scene)
bool has_report(const char *text)
static void SetUpTestCase()
void write_otio(Timeline *timeline)
void expect_round_trip(Scene *scene)
Strip * add_effect(Scene *scene, ListBaseT< Strip > &seqbase, const StripType type, const char *name, const int channel, const int start, const int length, Strip *input1=nullptr, Strip *input2=nullptr)
void export_otio(Scene *scene)
static PointerRNA rna(Scene *scene, Strip *strip)
float4 load_data(StoredFloat4 data)
float length(VecOp< float, D >) RET
float3x3 scale(float3x3 mat, float2 scale)
#define EXPECT_NE(result, expect)
#define EXPECT_TRUE(result)
#define EXPECT_NEAR(result, expect, threshold)
std::string filename(const std::string_view &str, size_t pos)
static const std::any * parameter(const AnyDictionary &effect, const std::string &id)
static AnyDictionary resolve_effect(const std::string &name, const std::vector< std::pair< std::string, std::any > > &values)
SerializableObject * read_otio_file_with_workarounds(const char *filepath, opentimelineio::OPENTIMELINEIO_VERSION_NS::ErrorStatus *error_status)
AnyDictionary rna_to_dictionary(PointerRNA &ptr)
TEST_F(OTIOTest, TimelineSettings)
Strip * add_effect_strip(Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Strip * lookup_strip_by_name(Editing *ed, const char *key)
Strip * add_image_strip(Main *bmain, Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
Strip * add_meta_strip(Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
void add_image_load_file(Scene *scene, Strip *strip, size_t strip_frame, const char *filename)
void add_image_set_directory(Strip *strip, const char *dirpath)
Editing * editing_ensure(Scene *scene)
void time_update_meta_strip_range(const Scene *scene, Strip *strip_meta)
Strip * add_sound_strip(Main *, Scene *, ListBaseT< Strip > *, LoadData *)
EQCurveMappingData * sound_equalizermodifier_add_graph(SoundEqualizerModifierData *semd, float min_freq, float max_freq)
Strip * add_scene_strip(Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
SeqTimelineChannel * channel_get_by_index(const ListBaseT< SeqTimelineChannel > *channels, const int channel_index)
VectorSet< Strip * > connected_strips_get(const Strip *strip)
StripModifierData * modifier_new(Strip *strip, const char *name, eStripModifierType type)
Strip * add_movie_strip(Main *bmain, Scene *scene, ListBaseT< Strip > *seqbase, LoadData *load_data)
void add_load_data_init(LoadData *load_data, const char *name, const char *path, const int start_frame, const int channel)
char * STRNCPY(char(&dst)[N], const char *src)
void BKE_reports_free(ReportList *reports)
PointerRNA RNA_id_pointer_create(ID *id)
bool BLI_dir_create_recursive(const char *dirname) ATTR_NONNULL()
void RNA_string_set(PointerRNA *ptr, const char *name, const char *value)
void BKE_reports_init(ReportList *reports, int flag)
bool BLI_exists(const char *path) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
IDProperty * IDP_GetPropertyFromGroup(const IDProperty *prop, StringRef name) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Scene * OTIO_import(bContext *C, const OTIOImportParams ¶ms)
void BKE_sound_init_once()
bContextStore * CTX_store_add(Vector< std::unique_ptr< bContextStore > > &contexts, StringRef name, const PointerRNA *ptr)
void * BLI_findstring(const ListBase *listbase, const char *id, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
@ STRIP_MODIFIER_FLAG_MUTE
const char * BKE_tempdir_session() ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
@ STRIP_TYPE_GAUSSIAN_BLUR
AnimData * BKE_animdata_from_id(const ID *id)
int BLI_delete(const char *path, bool dir, bool recursive) ATTR_NONNULL()
FCurve * BKE_animadata_fcurve_find_by_rna_path(AnimData *animdata, const char *rna_path, const int rna_index, bAction **r_action, bool *r_driven)
void BKE_curvemapping_changed(CurveMapping *cumap, bool rem_doubles)
Scene * BKE_scene_add(Main *bmain, const char *name)
void CTX_free(bContext *C)
@ SEQ_USE_EFFECT_DEFAULT_FADE
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
int BLI_listbase_count(const ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
void BKE_sound_exit_once()
void BKE_main_free(Main *bmain)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
int BLI_copy(const char *path_src, const char *path_dst) ATTR_NONNULL()
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
CurveMapPoint * BKE_curvemap_insert(CurveMap *cuma, float x, float y)
void CTX_data_main_set(bContext *C, Main *bmain)
void OTIO_export(bContext *C, const OTIOExportParams ¶ms)
void CTX_store_set(bContext *C, const bContextStore *store)
@ eSeqModifierType_SoundEqualizer
@ eSeqModifierType_BrightContrast
@ eSeqModifierType_Curves
void BKE_tempdir_init(const char *userdir)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
struct CurveMapping curve_mapping
ListBaseT< SeqTimelineChannel > channels
ListBaseT< Strip > seqbase
ListBaseT< TimeMarker > markers