OpenTimelineIO/src/opentimelineio/transition.cpp at d3e7aa759502933147a440e09581eb11b876d5c4 · AcademySoftwareFoundation/OpenTimelineIO · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
// SPDX-License-Identifier: Apache-2.0
// Copyright Contributors to the OpenTimelineIO project

#include "opentimelineio/transition.h"
#include "opentimelineio/composition.h"

namespace opentimelineio { namespace OPENTIMELINEIO_VERSION_NS {

Transition::Transition(
    std::string const&   name,
    std::string const&   transition_type,
    RationalTime         in_offset,
    RationalTime         out_offset,
    AnyDictionary const& metadata,
    bool                 enabled)
    : Parent(name, metadata)
    , _transition_type(transition_type)
    , _in_offset(in_offset)
    , _out_offset(out_offset)
    , _enabled(enabled)
{}

Transition::~Transition()
{}

bool
Transition::overlapping() const
{
    return true;
}

bool
Transition::read_from(Reader& reader)
{
    return reader.read("in_offset", &_in_offset)
           && reader.read("out_offset", &_out_offset)
           && reader.read("transition_type", &_transition_type)
           && reader.read_if_present("enabled", &_enabled)
           && Parent::read_from(reader);
}

void
Transition::write_to(Writer& writer) const
{
    Parent::write_to(writer);
    writer.write("in_offset", _in_offset);
    writer.write("out_offset", _out_offset);
    writer.write("transition_type", _transition_type);
    writer.write("enabled", _enabled);
}

RationalTime
Transition::duration(ErrorStatus* /* error_status */) const
{
    return _in_offset + _out_offset;
}

std::optional<TimeRange>
Transition::range_in_parent(ErrorStatus* error_status) const
{
    if (!parent())
    {
        if (error_status)
        {
            *error_status = ErrorStatus(
                ErrorStatus::NOT_A_CHILD,
                "cannot compute range in parent because item has no parent",
                this);
        }
    }

    return parent()->range_of_child(this, error_status);
}

std::optional<TimeRange>
Transition::trimmed_range_in_parent(ErrorStatus* error_status) const
{
    if (!parent())
    {
        if (error_status)
        {
            *error_status = ErrorStatus(
                ErrorStatus::NOT_A_CHILD,
                "cannot compute trimmed range in parent because item has no parent",
                this);
        }
    }

    return parent()->trimmed_range_of_child(this, error_status);
}

}} // namespace opentimelineio::OPENTIMELINEIO_VERSION_NS