C++

#include <iostream>

#include <opentimelineio/otio.hpp>

int main() {
    // An EDL never says what rate its timecode is at, so this has to be
    // right: a file read at the wrong rate puts every event in the wrong
    // place rather than failing.
    otio::ReadOptions options = otio::read_options_default();
    options.rate = 24;

    // Reading hands back the file's root object; there is no container
    // around it to hold.
    const otio::SerializableObject root =
        otio::read_from_file(otio::Format::CMX_3600, "cut.edl", options);

    for (const otio::SerializableObject &node : root.find_clips()) {
        if (std::optional<otio::Clip> clip = node.as<otio::Clip>()) {
            std::cout << clip->name() << "\n";
        }
    }

    return 0;
}

#include <iostream>

#include <opentimelineio/otio.hpp>

int main() {
    // Each object is made on its own and joins a timeline when you put it
    // into one. Nothing has to exist before the thing it goes into.
    otio::Timeline timeline = otio::Timeline::create("Cut");
    otio::Stack stack = otio::Stack::create("tracks");
    otio::Track track = otio::Track::create("V1", "Video");

    timeline.set_tracks(stack);
    stack.append_child(track);

    const std::vector<std::string> names = {"A", "B", "C"};
    for (std::size_t index = 0; index < names.size(); ++index) {
        otio::Clip clip = otio::Clip::create(names[index]);
        const otio::RationalTime start(static_cast<double>(index) * 24, 24);
        clip.set_source_range(otio::TimeRange(start, otio::RationalTime(24, 24)));
        track.append_child(clip);
    }

    // Three seconds of picture, written as canonical OpenTimelineIO JSON.
    // Objects keep their timeline alive between them, so there is nothing
    // to close.
    std::cout << track.duration().to_seconds() << "\n";
    otio::save(timeline, "cut.otio");
    return 0;
}

#include <iostream>
#include <string>

#include <opentimelineio/otio.hpp>

/// One second of picture, named.
static otio::Clip second(const std::string &name) {
    otio::Clip clip = otio::Clip::create(name);
    clip.set_source_range(
        otio::TimeRange(otio::RationalTime(0, 24), otio::RationalTime(24, 24)));
    return clip;
}

static void show(const otio::Track &track) {
    std::string names;
    for (const otio::SerializableObject &child : track.children()) {
        if (!names.empty()) names += " ";
        names += child.name();
    }
    std::cout << names << " - " << track.duration().value << " frames\n";
}

int main() {
    otio::Track track = otio::Track::create("V1", "Video");
    for (const char *name : {"A", "B", "C"}) {
        track.append_child(second(name));
    }
    show(track);

    // Insert makes room: everything from the insertion point onwards moves
    // later, and the track gets longer.
    otio::insert(second("D"), track, otio::RationalTime(24, 24), false);
    show(track);

    // Overwrite does not: it lays an item over a span and whatever was in
    // that span gives way. The track is the same length afterwards.
    otio::overwrite(
        second("E"), track,
        otio::TimeRange(otio::RationalTime(48, 24), otio::RationalTime(24, 24)),
        false);
    show(track);

    return 0;
}

#include <opentimelineio/otio.hpp>

int main() {
    // An EDL never says what rate its timecode is at, so this has to be
    // right: a file read at the wrong rate puts every event in the wrong
    // place rather than failing.
    otio::ReadOptions options = otio::read_options_default();
    options.rate = 24;

    const otio::SerializableObject root =
        otio::read_from_file(otio::Format::CMX_3600, "cut.edl", options);

    // Nothing happens in between. The timeline an EDL parses to is the same
    // timeline FCP X writes out, so converting is a read and a write: the
    // object model is the interchange, and the file formats are two ways of
    // spelling it.
    otio::write_to_file(otio::Format::FCPX_XML, root, "cut.fcpxml");

    return 0;
}

#include <cstdint>
#include <iostream>
#include <optional>
#include <string>
#include <vector>

#include <opentimelineio/otio.hpp>

// A cut of two clips, as an .otio file would hold it.
const std::string cut = R"({
  "OTIO_SCHEMA": "Track.1",
  "name": "V1",
  "kind": "Video",
  "children": [
    {"OTIO_SCHEMA": "Clip.2", "name": "A"},
    {"OTIO_SCHEMA": "Clip.2", "name": "B"}
  ]
})";

int main() {
    // A media linker is handed each clip as it is read, with the arguments
    // the read was given, and answers with the media the clip should use.
    // An empty optional leaves the clip as it was.
    otio::register_media_linker(
        "proxies",
        [](const otio::Clip &clip, const otio::Metadata &arguments)
            -> std::optional<otio::MediaReference> {
            const std::string root = arguments.get_string("root");
            return otio::ExternalReference::create(
                clip.name(), root + "/" + clip.name() + ".mov");
        });

    // A hook script is handed the whole result, and answers with what the
    // read goes on with: here the same object, stamped. An exception thrown
    // from either fails the read with Status::PLUGIN_ERROR and its message.
    otio::register_hook_script(
        "stamp", [](const otio::SerializableObject &target, const otio::Metadata &arguments) {
            otio::Metadata(target).set_string("read_by", arguments.get_string("who"));
            return target;
        });
    otio::attach_hook_script("post_adapter_read", "stamp");

    // The read names the linker, and carries both sets of arguments as JSON.
    otio::ReadOptions options = otio::read_options_default();
    options.media_linker = "proxies";
    options.media_linker_arguments = R"({"root": "/proxies"})";
    options.hook_arguments = R"({"who": "the conform"})";
    const otio::SerializableObject track = otio::read_from_bytes(
        otio::Format::OTIO_JSON, std::vector<std::uint8_t>(cut.begin(), cut.end()), options);

    std::cout << "read by " << otio::Metadata(track).get_string("read_by") << "\n";
    for (const otio::SerializableObject &node : track.find_clips()) {
        const otio::Clip clip = *node.as<otio::Clip>();
        const otio::ExternalReference media =
            *clip.media_reference()->as<otio::ExternalReference>();
        std::cout << clip.name() << " -> " << media.target_url() << "\n";
    }

    // The registry is the whole process's, so take them out again.
    otio::detach_hook_script("post_adapter_read", "stamp");
    otio::unregister_hook_script("stamp");
    otio::unregister_media_linker("proxies");
    return 0;
}