Blender V5.3
otio_export.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 <algorithm>
10#include <map>
11#include <tuple>
12
13#include "BKE_blender_version.h"
14#include "BKE_context.hh"
15#include "BKE_main.hh"
16#include "BKE_report.hh"
17
18#include "BLI_index_range.hh"
20#include "BLI_path_utils.hh"
21#include "BLI_string.hh"
22#include "BLI_vector.hh"
23
24#include "CLG_log.h"
25
26#include "DNA_scene_types.h"
27#include "DNA_sequence_types.h"
28
29#include "RNA_access.hh"
30#include "RNA_prototypes.hh"
31
32#include "SEQ_channels.hh"
33#include "SEQ_effects.hh"
34#include "SEQ_sequencer.hh"
35#include "SEQ_transform.hh"
36#include "SEQ_utils.hh"
37
38#include "opentimelineio/clip.h"
39#include "opentimelineio/color.h"
40#include "opentimelineio/effect.h"
41#include "opentimelineio/externalReference.h"
42#include "opentimelineio/freezeFrame.h"
43#include "opentimelineio/gap.h"
44#include "opentimelineio/generatorReference.h"
45#include "opentimelineio/imageSequenceReference.h"
46#include "opentimelineio/linearTimeWarp.h"
47#include "opentimelineio/marker.h"
48#include "opentimelineio/missingReference.h"
49#include "opentimelineio/stack.h"
50#include "opentimelineio/timeline.h"
51#include "opentimelineio/track.h"
52#include "opentimelineio/transition.h"
53
54#include "otio_export.hh"
56#include "otio_metadata.hh"
57
59
60static CLG_LogRef LOG = {"io.otio"};
61
71
72struct PlacedItem {
73 const Strip *strip;
74 int start;
75 int end;
76 SerializableObject::Retainer<Composable> composable;
77};
78
83
88
89static RationalTime frames(const StripExportContext &ctx, const double count)
90{
91 return RationalTime(count, ctx.fps);
92}
93
94static TimeRange frame_range(const StripExportContext &ctx, const double start, const int duration)
95{
96 return TimeRange(frames(ctx, start), frames(ctx, duration));
97}
98
99static bool is_single_input_effect(const Strip &strip)
100{
102}
103
104static bool is_transition(const Strip &strip)
105{
106 /* Compositor strips are not yet supported, if we support them then remove this function. */
108}
109
110static bool is_nested(const Strip &strip)
111{
112 return strip.type == STRIP_TYPE_META ||
113 (strip.type == STRIP_TYPE_SCENE && (strip.flag & SEQ_SCENE_STRIPS));
114}
115
116static int media_length(const StripExportContext &ctx, const Strip &strip)
117{
119 return strip.right_handle(ctx.scene) - strip.left_handle();
120 }
121 return strip.anim_startofs + strip.content_length() + strip.anim_endofs;
122}
123
124static std::string media_filepath(const StripExportContext &ctx, const Strip &strip)
125{
126 char filepath[FILE_MAX];
127 BLI_path_join(filepath, sizeof(filepath), strip.data->dirpath, strip.data->stripdata->filename);
129 return filepath;
130}
131
132static std::string strip_type_identifier(const StripExportContext &ctx, const Strip &strip)
133{
135 &ctx.scene->id, RNA_Strip, const_cast<Strip *>(&strip));
136 const char *identifier = "";
138 nullptr, &ptr, RNA_struct_find_property(&ptr, "type"), strip.type, &identifier);
139 return identifier;
140}
141
143 const Strip &strip,
144 SerializableObjectWithMetadata &object)
145{
147 &ctx.scene->id, RNA_Strip, const_cast<Strip *>(&strip));
148 AnyDictionary data;
149 data["strip"] = rna_to_dictionary(ptr);
150 object.metadata()["blender"] = data;
151 add_foreign_metadata(strip.prop, object);
152}
153
154/* Return `false` if the image sequence in Blender cannot be represented natively in the
155 * OTIO specification (e.g. arbitrarily named filepaths with no digits). */
156static bool image_sequence_pattern_get(const StripElem *elems,
157 const int elems_num,
158 char *r_name_prefix,
159 char *r_name_suffix,
160 int &r_start_frame,
161 int &r_frame_step,
162 int &r_padding)
163{
164 unsigned short digits_len;
165 r_start_frame = BLI_path_sequence_decode(
166 elems[0].filename, r_name_prefix, FILE_MAX, r_name_suffix, FILE_MAX, &digits_len);
167 r_padding = digits_len;
168 if (digits_len == 0) {
169 return false;
170 }
171
172 r_frame_step = 1;
173 if (elems_num > 1) {
174 r_frame_step = BLI_path_sequence_decode(elems[1].filename, nullptr, 0, nullptr, 0, nullptr) -
175 r_start_frame;
176 if (r_frame_step < 1) {
177 return false;
178 }
179 }
180
181 for (const int i : IndexRange(elems_num)) {
182 char filename[FILE_MAX];
184 sizeof(filename),
185 r_name_prefix,
186 r_name_suffix,
187 digits_len,
188 r_start_frame + i * r_frame_step);
189 if (!STREQ(filename, elems[i].filename)) {
190 return false;
191 }
192 }
193 return true;
194}
195
196static SerializableObject::Retainer<MediaReference> image_sequence_reference(
197 StripExportContext &ctx, const Strip &strip)
198{
199 char name_prefix[FILE_MAX], name_suffix[FILE_MAX];
200 int start_frame, frame_step, padding;
201 if (!image_sequence_pattern_get(strip.data->stripdata,
202 strip.data->stripdata_num,
203 name_prefix,
204 name_suffix,
205 start_frame,
206 frame_step,
207 padding))
208 {
210 return new MissingReference(strip.name + 2);
211 }
212
213 char dirpath[FILE_MAX];
214 BLI_strncpy(dirpath, strip.data->dirpath, sizeof(dirpath));
216
217 /* OTIO expects the rate of the full sequence, counting file numbers that don't exist. */
218 const double rate = ctx.fps * frame_step;
219 return new ImageSequenceReference(dirpath,
220 name_prefix,
221 name_suffix,
222 start_frame,
223 frame_step,
224 rate,
225 padding,
226 ImageSequenceReference::MissingFramePolicy::error,
227 frame_range(ctx, 0, media_length(ctx, strip)));
228}
229
230static SerializableObject::Retainer<MediaReference> media_reference(StripExportContext &ctx,
231 const Strip &strip)
232{
233 const bool has_media = strip.data && strip.data->stripdata;
234
235 switch (strip.type) {
236 case STRIP_TYPE_MOVIE:
237 case STRIP_TYPE_SOUND:
238 if (!has_media) {
239 return new MissingReference(strip.name + 2);
240 }
241 return new ExternalReference(media_filepath(ctx, strip),
242 frame_range(ctx, 0, media_length(ctx, strip)));
243
244 case STRIP_TYPE_IMAGE:
245 if (!has_media) {
246 return new MissingReference(strip.name + 2);
247 }
249 return new ExternalReference(media_filepath(ctx, strip),
250 frame_range(ctx, 0, media_length(ctx, strip)));
251 }
252 return image_sequence_reference(ctx, strip);
253
256 return new MissingReference(strip.name + 2);
257 }
258 [[fallthrough]];
259 case STRIP_TYPE_COLOR:
260 case STRIP_TYPE_TEXT:
261 case STRIP_TYPE_ADD:
262 case STRIP_TYPE_SUB:
263 case STRIP_TYPE_MUL:
266 case STRIP_TYPE_COLORMIX: {
267 const TimeRange available_range = frame_range(ctx, 0, media_length(ctx, strip));
269 return resolve_generator_reference(strip, available_range);
270 }
271 return new GeneratorReference(
272 strip.name + 2, strip_type_identifier(ctx, strip), available_range);
273 }
274
275 case STRIP_TYPE_SCENE:
277 return new MissingReference(strip.name + 2);
278
279 default:
280 return nullptr;
281 }
282}
283
284static float speed_factor(const StripExportContext &ctx,
285 const Strip &input,
286 const Strip &speed_strip)
287{
288 const SpeedControlVars *speed = static_cast<const SpeedControlVars *>(speed_strip.effectdata);
289 switch (speed->speed_control_type) {
290 case SEQ_SPEED_STRETCH: {
291 const float speed_length = speed_strip.right_handle(ctx.scene) - speed_strip.left_handle();
292 return speed_length != 0.0f ? (input.length(ctx.scene) - input.startofs) / speed_length :
293 0.0f;
294 }
296 return speed->speed_fader;
297 default:
298 return 0.0f;
299 }
300}
301
302static SerializableObject::Retainer<otio::Effect> strip_to_effect(const StripExportContext &ctx,
303 const Strip &input,
304 const Strip &effect_strip)
305{
306 const std::string name = effect_strip.name + 2;
307 SerializableObject::Retainer<otio::Effect> effect;
308 if (effect_strip.type != STRIP_TYPE_SPEED) {
309 effect = new otio::Effect(name, strip_type_identifier(ctx, effect_strip));
310 }
311 else if (const float factor = speed_factor(ctx, input, effect_strip); factor != 0.0f) {
312 effect = new LinearTimeWarp(name, "", factor);
313 }
314 else {
315 effect = new FreezeFrame(name);
316 }
317 add_strip_metadata(ctx, effect_strip, *effect);
318 return effect;
319}
320
321static void add_strip_data(const StripExportContext &ctx,
322 Editing &editing,
323 const Strip &strip,
324 Item &item)
325{
326 item.set_enabled(!(strip.flag & SEQ_MUTE));
327 add_strip_metadata(ctx, strip, item);
328 for (const Strip *effect_strip : seq::lookup_effects_by_strip(&editing, &strip)) {
329 if (is_single_input_effect(*effect_strip)) {
330 item.effects().push_back(strip_to_effect(ctx, strip, *effect_strip));
331 }
332 }
333}
334
335static SerializableObject::Retainer<Clip> strip_to_clip(StripExportContext &ctx,
336 Editing &editing,
337 const Strip &strip)
338{
339 SerializableObject::Retainer<MediaReference> reference = media_reference(ctx, strip);
340 if (!reference) {
341 CLOG_WARN(&LOG, "Skipping strip '%s' of unsupported type", strip.name + 2);
344 "Strip '%s' was not exported, its type is currently unsupported",
345 strip.name + 2);
346 return nullptr;
347 }
348
349 double source_start = strip.left_handle() - int(strip.content_start()) + strip.anim_startofs;
350 const int duration = strip.right_handle(ctx.scene) - strip.left_handle();
352 source_start = 0;
353 }
354 if (strip.type == STRIP_TYPE_SOUND) {
355 source_start -= strip.sound_offset * ctx.fps;
356 }
357
358 auto clip = SerializableObject::Retainer<Clip>(
359 new Clip(strip.name + 2, reference, frame_range(ctx, source_start, duration)));
360 add_strip_data(ctx, editing, strip, *clip);
362 resolve_add_clip_data(*ctx.scene, strip, ctx.resolve_link_groups, *clip);
363 }
364 return clip;
365}
366
367static Tracks export_strips(StripExportContext &ctx,
368 Editing &editing,
369 ListBaseT<Strip> &seqbase,
370 const ListBaseT<SeqTimelineChannel> *channels,
371 int origin);
372
374 Editing &editing,
375 const Strip &strip,
376 ChannelItems &items)
377{
378 ListBaseT<SeqTimelineChannel> *channels;
379 int origin;
380 ListBaseT<Strip> *seqbase = seq::get_seqbase_from_strip(
381 const_cast<Strip *>(&strip), &channels, &origin);
382 if (!seqbase) {
383 return false;
384 }
385
386 Editing &nested_editing = strip.type == STRIP_TYPE_SCENE ? *seq::editing_get(strip.scene) :
387 editing;
388 const Tracks tracks = export_strips(ctx, nested_editing, *seqbase, channels, origin);
389 const int start = strip.left_handle();
390 const int end = strip.right_handle(ctx.scene);
391 const TimeRange range = frame_range(ctx, start - int(strip.content_start()), end - start);
392
393 for (const bool is_audio : {false, true}) {
394 const Vector<SerializableObject::Retainer<Track>> &nested = is_audio ? tracks.audio :
395 tracks.video;
396 if (nested.is_empty()) {
397 continue;
398 }
399 auto stack = SerializableObject::Retainer<Stack>(new Stack(strip.name + 2, range));
400 for (const SerializableObject::Retainer<Track> &track : nested) {
401 stack->append_child(track);
402 }
403 add_strip_data(ctx, editing, strip, *stack);
404 (is_audio ? items.audio : items.video).append({&strip, start, end, stack.value});
405 }
406 return true;
407}
408
409static PlacedItem *find_item(Vector<PlacedItem> &items, const Strip *strip)
410{
411 for (PlacedItem &item : items) {
412 if (item.strip == strip) {
413 return &item;
414 }
415 }
416 return nullptr;
417}
418
420 const RationalTime before,
421 const RationalTime after)
422{
423 Item *otio_item = dynamic_cast<Item *>(item.composable.value);
424 const TimeRange range = otio_item->trimmed_range();
425 otio_item->set_source_range(
426 TimeRange(range.start_time() - before, range.duration() + before + after));
427}
428
429static void add_transition(const StripExportContext &ctx,
430 const Strip &transition,
431 std::map<int, ChannelItems> &channel_items)
432{
433 const Strip *input1 = transition.input1;
434 const Strip *input2 = transition.input2;
435 PlacedItem *from = nullptr;
436 PlacedItem *to = nullptr;
437 if (input1 && input2 && input1->channel == input2->channel) {
438 Vector<PlacedItem> &items = channel_items[input1->channel].video;
439 from = find_item(items, input1);
440 to = find_item(items, input2);
441 }
442 if (from && to && from->start > to->start) {
443 std::swap(from, to);
444 }
445 if (!from || !to || from->end >= to->start) {
446 CLOG_WARN(&LOG, "Skipping transition strip '%s'", transition.name + 2);
449 "Transition strip '%s' was not exported, its inputs must be on the same channel",
450 transition.name + 2);
451 return;
452 }
453
454 const int length = to->start - from->end;
455 const int in_offset = length / 2;
456 const int out_offset = length - in_offset;
457 extend_source_range(*from, frames(ctx, 0), frames(ctx, in_offset));
458 extend_source_range(*to, frames(ctx, out_offset), frames(ctx, 0));
459 from->end += in_offset;
460 to->start -= out_offset;
461
462 auto otio_transition = SerializableObject::Retainer<Transition>(
463 new Transition(transition.name + 2,
464 transition.type == STRIP_TYPE_WIPE ? Transition::Type::Custom :
465 Transition::Type::SMPTE_Dissolve,
466 frames(ctx, in_offset),
467 frames(ctx, out_offset)));
468 add_strip_metadata(ctx, transition, *otio_transition);
470 resolve_add_transition_data(*ctx.scene, transition, *otio_transition);
471 }
472
473 const int cut = from->end;
474 channel_items[input1->channel].video.append({&transition, cut, cut, otio_transition.value});
475}
476
477static SerializableObject::Retainer<Track> build_track(const StripExportContext &ctx,
478 Vector<PlacedItem> &items,
479 const std::string &kind,
480 const SeqTimelineChannel *channel,
481 const int channel_index,
482 const int origin)
483{
484 std::ranges::stable_sort(items, [](const PlacedItem &a, const PlacedItem &b) {
485 return std::tie(a.start, a.end) < std::tie(b.start, b.end);
486 });
487
488 auto track = SerializableObject::Retainer<Track>(
489 new Track(channel ? channel->name : "", std::nullopt, kind));
490 track->set_enabled(!(channel && channel->is_muted()));
491 AnyDictionary data;
492 data["channel"] = int64_t(channel_index);
493 track->metadata()["blender"] = data;
495 resolve_add_track_data(channel, *track);
496 }
497
498 int cursor = origin;
499 for (PlacedItem &item : items) {
500 if (item.start > cursor) {
501 track->append_child(new Gap(frames(ctx, item.start - cursor)));
502 }
503 track->append_child(item.composable);
504 cursor = item.end;
505 }
506 return track;
507}
508
510 Editing &editing,
511 ListBaseT<Strip> &seqbase,
512 const ListBaseT<SeqTimelineChannel> *channels,
513 const int origin)
514{
515 std::map<int, ChannelItems> channel_items;
516 for (const Strip &strip : seqbase) {
517 if (is_single_input_effect(strip) || is_transition(strip)) {
518 continue;
519 }
520 ChannelItems &items = channel_items[strip.channel];
521 if (is_nested(strip) && add_nested_items(ctx, editing, strip, items)) {
522 continue;
523 }
524 if (SerializableObject::Retainer<Clip> clip = strip_to_clip(ctx, editing, strip)) {
525 (strip.type == STRIP_TYPE_SOUND ? items.audio : items.video)
526 .append({&strip, strip.left_handle(), strip.right_handle(ctx.scene), clip.value});
527 }
528 }
529
530 for (const Strip &strip : seqbase) {
531 if (is_transition(strip)) {
532 add_transition(ctx, strip, channel_items);
533 }
534 }
535
536 Tracks tracks;
537 for (auto &[channel_index, items] : channel_items) {
538 const SeqTimelineChannel *channel = channels ?
539 seq::channel_get_by_index(channels, channel_index) :
540 nullptr;
541 if (!items.video.is_empty()) {
542 tracks.video.append(
543 build_track(ctx, items.video, Track::Kind::video, channel, channel_index, origin));
544 }
545 if (!items.audio.is_empty()) {
546 tracks.audio.append(
547 build_track(ctx, items.audio, Track::Kind::audio, channel, channel_index, origin));
548 }
549 }
550 return tracks;
551}
552
553static void export_markers(const StripExportContext &ctx, const int origin, Stack &stack)
554{
555 for (const TimeMarker &marker : ctx.scene->markers) {
556 stack.markers().push_back(
557 new Marker(marker.name, frame_range(ctx, marker.frame - origin, 1), Color::white));
558 }
559}
560
562{
563 Main *bmain = CTX_data_main(C);
565 Editing *editing = seq::editing_get(scene);
566 StripExportContext ctx{bmain, scene, params, scene->frames_per_second()};
567 if (params.use_resolve_metadata) {
569 }
570
571 int origin = scene->r.sfra;
572 for (const Strip &strip : editing->seqbase) {
573 origin = std::min(origin, strip.left_handle());
574 }
575
576 const Tracks tracks = export_strips(ctx, *editing, editing->seqbase, &editing->channels, origin);
577
578 auto timeline = SerializableObject::Retainer<Timeline>(
579 new Timeline(scene->id.name + 2, frames(ctx, origin)));
580 for (const SerializableObject::Retainer<Track> &track : tracks.video) {
581 timeline->tracks()->append_child(track);
582 }
583 for (const SerializableObject::Retainer<Track> &track : tracks.audio) {
584 timeline->tracks()->append_child(track);
585 }
586 export_markers(ctx, origin, *timeline->tracks());
587 AnyDictionary data;
588 data["version"] = int64_t(BLENDER_FILE_VERSION);
589 data["subversion"] = int64_t(BLENDER_FILE_SUBVERSION);
590 timeline->metadata()["blender"] = data;
591 add_foreign_metadata(scene->id.properties, *timeline);
592 if (params.use_resolve_metadata) {
594 }
595
596 opentimelineio::OPENTIMELINEIO_VERSION_NS::ErrorStatus error_status;
597 /* Some versions of editors like DaVinci Resolve will abort import of the entire timeline if
598 * there is at least one newer Marker.3 object; for better compatibility, write older schema
599 * instead. */
600 const schema_version_map schema_version_targets = {{"Marker", 2}};
601 if (!timeline->to_json_file(params.filepath, &error_status, &schema_version_targets)) {
603 "Failed to write OTIO file '%s': %s",
604 params.filepath,
605 error_status.full_description.c_str());
606 BKE_reportf(params.reports, RPT_ERROR, "Failed to write OTIO file '%s'", params.filepath);
607 return;
608 }
609
610 BKE_report(params.reports, RPT_INFO, "File exported successfully");
611
612 if (ctx.unsupported_scene_strips > 0) {
613 BKE_reportf(params.reports,
615 "%d scene strip(s) found, this is currently unsupported",
617 }
618 if (ctx.unsupported_image_sequences > 0) {
619 BKE_reportf(params.reports,
621 "%d image sequence(s) with non-sequential filenames found, this is currently "
622 "unsupported",
624 }
625}
626
627} // namespace blender::io::otio
#define BLENDER_FILE_SUBVERSION
#define BLENDER_FILE_VERSION
#define FILE_MAX
#define BLI_path_join(...)
#define CLOG_ERROR(clg_ref,...)
Definition CLG_log.h:188
#define CLOG_WARN(clg_ref,...)
Definition CLG_log.h:189
#define ELEM(...)
#define STREQ(a, b)
constexpr IndexRange()=default
Stack(Allocator allocator={}) noexcept
Definition BLI_stack.hh:118
bool is_empty() const
const T & data(const Action &owning_action) const
float length(VecOp< float, D >) RET
std::string filename(const std::string_view &str, size_t pos)
static TimeRange frame_range(const StripExportContext &ctx, const double start, const int duration)
static Tracks export_strips(StripExportContext &ctx, Editing &editing, ListBaseT< Strip > &seqbase, const ListBaseT< SeqTimelineChannel > *channels, int origin)
static std::string strip_type_identifier(const StripExportContext &ctx, const Strip &strip)
static PlacedItem * find_item(Vector< PlacedItem > &items, const Strip *strip)
static void extend_source_range(PlacedItem &item, const RationalTime before, const RationalTime after)
static void add_transition(const StripExportContext &ctx, const Strip &transition, std::map< int, ChannelItems > &channel_items)
static bool add_nested_items(StripExportContext &ctx, Editing &editing, const Strip &strip, ChannelItems &items)
void resolve_add_clip_data(const Scene &scene, const Strip &strip, const Map< const Strip *, int64_t > &link_groups, Clip &clip)
static bool is_single_input_effect(const Strip &strip)
static SerializableObject::Retainer< Track > build_track(const StripExportContext &ctx, Vector< PlacedItem > &items, const std::string &kind, const SeqTimelineChannel *channel, const int channel_index, const int origin)
AnyDictionary rna_to_dictionary(PointerRNA &ptr)
static void add_strip_metadata(const StripExportContext &ctx, const Strip &strip, SerializableObjectWithMetadata &object)
static void export_markers(const StripExportContext &ctx, const int origin, Stack &stack)
static SerializableObject::Retainer< otio::Effect > strip_to_effect(const StripExportContext &ctx, const Strip &input, const Strip &effect_strip)
static std::string media_filepath(const StripExportContext &ctx, const Strip &strip)
static float speed_factor(const StripExportContext &ctx, const Strip &input, const Strip &speed_strip)
static SerializableObject::Retainer< MediaReference > image_sequence_reference(StripExportContext &ctx, const Strip &strip)
GeneratorReference * resolve_generator_reference(const Strip &strip, const TimeRange &available_range)
static int media_length(const StripExportContext &ctx, const Strip &strip)
static bool is_transition(const Strip &strip)
static SerializableObject::Retainer< Clip > strip_to_clip(StripExportContext &ctx, Editing &editing, const Strip &strip)
void exporter_main(bContext *C, const OTIOExportParams &params)
void resolve_add_transition_data(const Scene &scene, const Strip &transition, Transition &otio_transition)
static SerializableObject::Retainer< MediaReference > media_reference(StripExportContext &ctx, const Strip &strip)
Map< const Strip *, int64_t > resolve_link_groups(const ListBaseT< Strip > &seqbase)
static CLG_LogRef LOG
void resolve_add_track_data(const SeqTimelineChannel *channel, Track &track)
static bool image_sequence_pattern_get(const StripElem *elems, const int elems_num, char *r_name_prefix, char *r_name_suffix, int &r_start_frame, int &r_frame_step, int &r_padding)
static void add_strip_data(const StripExportContext &ctx, Editing &editing, const Strip &strip, Item &item)
void resolve_add_timeline_metadata(Timeline &timeline)
static bool is_nested(const Strip &strip)
void add_foreign_metadata(IDProperty *properties, SerializableObjectWithMetadata &object)
static RationalTime frames(const StripExportContext &ctx, const double count)
Editing * editing_get(const Scene *scene)
Definition sequencer.cc:304
bool effect_is_transition(StripType type)
Definition effects.cc:381
bool transform_single_image_check(const Strip *strip)
Span< Strip * > lookup_effects_by_strip(Editing *ed, const Strip *key)
SeqTimelineChannel * channel_get_by_index(const ListBaseT< SeqTimelineChannel > *channels, const int channel_index)
Definition channels.cc:59
ListBaseT< Strip > * get_seqbase_from_strip(Strip *strip, ListBaseT< SeqTimelineChannel > **r_channels, int *r_offset)
__int64 int64_t
Definition BKE_text.h:90
uint padding(uint offset, uint alignment)
@ 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 BLI_path_abs(char path[FILE_MAX], const char *basepath) ATTR_NONNULL(1
bool RNA_property_enum_identifier(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **r_identifier)
const char * BKE_main_blendfile_path(const Main *bmain) ATTR_NONNULL()
Definition main.cc:1058
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition report.cc:162
BMesh const char void * data
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
Main * CTX_data_main(const bContext *C)
int BLI_path_sequence_decode(const char *path, char *head, size_t head_maxncpy, char *tail, size_t tail_maxncpy, unsigned short *r_digits_len)
Definition path_utils.cc:61
void BLI_path_sequence_encode(char *path, size_t path_maxncpy, const char *head, const char *tail, unsigned short numlen, int pic)
ListBaseT< SeqTimelineChannel > channels
ListBaseT< Strip > seqbase
char name[258]
Definition DNA_ID.h:433
IDProperty * properties
Definition DNA_ID.h:481
char filepath[FILE_MAX]
Definition IO_otio.hh:20
ListBaseT< TimeMarker > markers
struct RenderData r
eEffectSpeedControlType speed_control_type
Vector< PlacedItem > audio
Vector< PlacedItem > video
SerializableObject::Retainer< Composable > composable
const OTIOExportParams & params
Map< const Strip *, int64_t > resolve_link_groups
Vector< SerializableObject::Retainer< Track > > video
Vector< SerializableObject::Retainer< Track > > audio