tracktion_EditTime.h

Go to the documentation of this file.

 /*
    ,--.                     ,--.     ,--.  ,--.
  ,-'  '-.,--.--.,--,--.,---.|  |,-.,-'  '-.`--' ,---. ,--,--,      Copyright 2024
  '-.  .-'|  .--' ,-.  | .--'|     /'-.  .-',--.| .-. ||      \   Tracktion Software
    |  |  |  |  \ '-'  \ `--.|  \  \  |  |  |  |' '-' '|  ||  |       Corporation
    `---' `--'   `--`--'`---'`--'`--' `---' `--' `---' `--''--'    www.tracktion.com
 
    Tracktion Engine uses a GPL/commercial licence - see LICENCE.md for details.
*/
 
 
namespace tracktion { inline namespace engine
{
 
BeatPosition toBeats (TimePosition, const TempoSequence&);
 
TimePosition toTime (BeatPosition, const TempoSequence&);
 
//==============================================================================
BeatRange toBeats (TimeRange, const TempoSequence&);
 
TimeRange toTime (BeatRange, const TempoSequence&);
 
 
//==============================================================================
//==============================================================================
struct EditTime
{
    EditTime();
 
    EditTime (TimePosition);
 
    EditTime (BeatPosition);
 
    bool isBeats() const;
 
private:
    friend TimePosition toTime (EditTime, const TempoSequence&);
    friend BeatPosition toBeats (EditTime, const TempoSequence&);
 
    std::variant<TimePosition, BeatPosition> position;
};
 
//==============================================================================
TimePosition toTime (EditTime, const TempoSequence&);
 
BeatPosition toBeats (EditTime, const TempoSequence&);
 
 
//==============================================================================
//==============================================================================
struct EditTimeRange
{
    EditTimeRange (TimeRange);
 
    EditTimeRange (TimePosition, TimePosition);
 
    EditTimeRange (TimePosition, TimeDuration);
 
    EditTimeRange (BeatRange);
 
    EditTimeRange (BeatPosition, BeatPosition);
 
    EditTimeRange (BeatPosition, BeatDuration);
 
    bool isBeats() const;
 
private:
    friend TimeRange toTime (EditTimeRange, const TempoSequence&);
    friend BeatRange toBeats (EditTimeRange, const TempoSequence&);
 
    std::variant<TimeRange, BeatRange> range;
};
 
TimeRange toTime (EditTimeRange, const TempoSequence&);
 
BeatRange toBeats (EditTimeRange, const TempoSequence&);
 
 
//==============================================================================
struct ClipPosition
{
    TimeRange time;             
    TimeDuration offset = {};   
    TimePosition getStart() const             { return time.getStart(); }
    TimePosition getEnd() const               { return time.getEnd(); }
    TimeDuration getLength() const            { return time.getLength(); }
    TimeDuration getOffset() const            { return offset; }
    TimePosition getStartOfSource() const     { return time.getStart() - offset; }
 
    bool operator== (const ClipPosition& other) const  { return offset == other.offset && time == other.time; }
    bool operator!= (const ClipPosition& other) const  { return ! operator== (other); }
 
    ClipPosition rescaled (TimePosition anchorTime, double factor) const;
};
 
ClipPosition createClipPosition (const TempoSequence&, TimeRange, TimeDuration offset = {});
 
ClipPosition createClipPosition (const TempoSequence&, BeatRange, BeatDuration offset = {});
 
 
//==============================================================================
//==============================================================================
}} // namespace tracktion { inline namespace engine
 
namespace juce
{
    template<>
    struct VariantConverter<tracktion::core::TimePosition>
    {
        static tracktion::core::TimePosition fromVar (const var& v)   { return tracktion::core::TimePosition::fromSeconds (static_cast<double> (v)); }
        static var toVar (tracktion::core::TimePosition v)            { return v.inSeconds(); }
    };
 
    template<>
    struct VariantConverter<tracktion::core::TimeDuration>
    {
        static tracktion::core::TimeDuration fromVar (const var& v)   { return tracktion::core::TimeDuration::fromSeconds (static_cast<double> (v)); }
        static var toVar (tracktion::core::TimeDuration v)            { return v.inSeconds(); }
    };
 
    template<>
    struct VariantConverter<tracktion::core::BeatPosition>
    {
        static tracktion::core::BeatPosition fromVar (const var& v)   { return tracktion::core::BeatPosition::fromBeats (static_cast<double> (v)); }
        static var toVar (tracktion::core::BeatPosition v)            { return v.inBeats(); }
    };
 
    template<>
    struct VariantConverter<tracktion::core::BeatDuration>
    {
        static tracktion::core::BeatDuration fromVar (const var& v)   { return tracktion::core::BeatDuration::fromBeats (static_cast<double> (v)); }
        static var toVar (tracktion::core::BeatDuration v)            { return v.inBeats(); }
    };
}
 
namespace tracktion { inline namespace engine {
 
//==============================================================================
//        _        _           _  _
//     __| |  ___ | |_   __ _ (_)| | ___
//    / _` | / _ \| __| / _` || || |/ __|
//   | (_| ||  __/| |_ | (_| || || |\__ \ _  _  _
//    \__,_| \___| \__| \__,_||_||_||___/(_)(_)(_)
//
//   Code beyond this point is implementation detail...
//
//==============================================================================
 
inline EditTime::EditTime()
    : EditTime (TimePosition())
{
}
 
inline EditTime::EditTime (TimePosition tp)
    : position (tp)
{
}
 
inline EditTime::EditTime (BeatPosition bp)
    : position (bp)
{
}
 
inline bool EditTime::isBeats() const
{
    return std::holds_alternative<BeatPosition> (position);
}
 
//==============================================================================
inline TimePosition toTime (EditTime et, const TempoSequence& ts)
{
    // N.B. std::get unavailable prior to macOS 10.14
    if (const auto tp = std::get_if<TimePosition> (&et.position))
        return *tp;
 
    return tracktion::engine::toTime (*std::get_if<BeatPosition> (&et.position), ts);
}
 
inline BeatPosition toBeats (EditTime et, const TempoSequence& ts)
{
    if (const auto bp = std::get_if<BeatPosition> (&et.position))
        return *bp;
 
    return tracktion::engine::toBeats (*std::get_if<TimePosition> (&et.position), ts);
}
 
//==============================================================================
inline EditTimeRange::EditTimeRange (TimeRange r)
    : range (r)
{
}
 
inline EditTimeRange::EditTimeRange (BeatRange r)
    : range (r)
{
}
 
inline EditTimeRange::EditTimeRange (TimePosition start, TimePosition end)
    : range (TimeRange (start, end))
{
}
 
inline EditTimeRange::EditTimeRange (TimePosition start, TimeDuration length)
    : range (TimeRange (start, length))
{
}
 
inline EditTimeRange::EditTimeRange (BeatPosition start, BeatPosition end)
    : range (BeatRange (start, end))
{
}
 
inline EditTimeRange::EditTimeRange (BeatPosition start, BeatDuration length)
    : range (BeatRange (start, length))
{
}
 
inline bool EditTimeRange::isBeats() const
{
    return std::holds_alternative<BeatRange> (range);
}
 
//==============================================================================
inline TimeRange toTime (EditTimeRange r, const TempoSequence& ts)
{
    // N.B. std::get unavailable prior to macOS 10.14
    if (const auto tr = std::get_if<TimeRange> (&r.range))
        return *tr;
 
    return tracktion::engine::toTime (*std::get_if<BeatRange> (&r.range), ts);
}
 
inline BeatRange toBeats (EditTimeRange r, const TempoSequence& ts)
{
    if (const auto br = std::get_if<BeatRange> (&r.range))
        return *br;
 
    return tracktion::engine::toBeats (*std::get_if<TimeRange> (&r.range), ts);
}
 
//==============================================================================
inline ClipPosition ClipPosition::rescaled (TimePosition anchorTime, double factor) const
{
    return { time.rescaled (anchorTime, factor), offset * factor };
}
 
 
}} // namespace tracktion { inline namespace engine