Open bounded TimeRange support

[reinecke]

When working with media times, it can often be useful to refer to ranges that are things like "all times after two seconds" or "all times until 90 minutes". With time ranges expressing this, you can do things like: two_seconds_to_infinity_range.contains(RationalTime(36, 24)).
This can be thought of in two ways:

1. A TimeRange that goes from a concrete time to infinity or from negative infinity to a concrete time
2. A TimeRange with open end bounds or open front bounds

Modeling this as the first described solution would mean:

1. Define RationalTime constants for -infinity and infinity
2. Updating TimeRange to be expressed in terms of start_time and end_time(exclusive?) - instead of start_time and duration

For the second described solution one implementation might be to add TimeRange subclasses that are TimeRangeOpenEnd and TimeRangeOpenFront.

The second described solution would imply some API footprint changes for TimeRange.

[meshula]

I'd like if there were sentinel values in TimeRange for None, Never and Always
With these rules embodied in union and intersection:

t U None = t
t U Never = t
t U Always = Always
t ^ None = t
t ^ Never = Never
t ^ Always = t

associativity, commutativity, and distribution appear to work correctly.

A complete algebra for time ranges can be constructed using these; to satisfy what you'd like to do adding NegativeInfinity and PositiveInfinity would round out the set.

[jminor]

Lets try to enumerate the use cases for these, so we can make sure we consider the scope of this design decision broadly enough.

• A Clip has a source_range which specifies the segment of media it uses (start+duration).
• A Clip, Track or Stack trims its content to a specific segment via source_range.
• A Clip, Track or Stack specifies no trimming, falling back to a computed bounds of its children. We currently use source_range=None to mean this.
• A MediaReference knows its available_range (start+duration).
• A MediaReference does not know its available_range. We use available_range=None for this.

To handle the cases above, we allow a range to be None or TimeRange(start_time, duration)

The newly proposed use cases are:

• Trim everything after X seconds from this. (e.g. start_time=X seconds, end_time=∞)
• Trim everything before X seconds from this. (e.g. start_time=-∞, end_time=X seconds)

The first of these new cases could be handled with the existing API and data structure, as long as we take care to allow for a duration that is a RationalTime with a value=∞, but the second would require switching to use start_time and end_time (instead of start_time+duration). There is no harm making this change, since the API could stay mostly the same. We would need to clarify how this relates to end_time_inclusive and end_time_exclusive.

It might be possible to get the behavior of Always and Never by using +/- infinity and NaN in RationalTime.value.

• Always could be start_time.value=-∞, end_time.value=∞ (or duration.value=∞)
• Never could be start_time.value=NaN, end_time.value=NaN (or duration.value=NaN)

Even if we do introduce sentinels, we will need to decide what you get from Never.start_time, Always.duration, etc.

@meshula can you give examples of when you would use Never and Always? I'm unclear on when they would be handy. Would either of those map to the "A MediaReference does not know its available_range" or "A Clip, Track or Stack specifies no trimming" cases above?

[meshula]

Always example: A slate, stating SHOT MISSING, that appears in gaps not filled by anything else. In a user interface, it can be selected but not moved on its track. This is as you suggest the same as start at -∞, and end or duration of ∞.

Never example: A slate, stating COPYRIGHT 2019, NO REDISTRIBUTION, composited over top of everything. Set to NEVER so that it remains in the timeline but is not composited, except when baking out a version of the media with slate visible. Your NaN sentinel suggestion works (with the caveat of using a non-signalling NaN).

Another use of Never is as a bin. Clips I haven't decided to use, I might start at Never (with a duration), in order that they are in my timeline, but not rendered.

The distinction between muting a track versus Never, is that muting is often considered a user interface affordance that does not affect rendering, whereas Never is an editing decision, that a clip exists, but is not rendered.

[jminor]

One serious flaw in my suggestion to use NaN and Infinity for this: JSON doesn't support either.

There are optional extensions to JSON to allow this (for example in the RapidJSON implementation that we're moving towards) or we could wrap it in a string or something. Both of these have downsides for anyone using OTIO without using our implementation (e.g. just minifying the JSON).

[davidbaraff]

In the new C++ API, RationalTime is decoded with a piece of code that know it’s decoding RationalTime (and the same for writing it). So there’s the opportunity there to encode/decode particular RationalTime values using special sentinel logic, that don’t actually need to input/output a nan or infinity value in JSON, even if that’s what the C++ values inside RationalTime actually were. This wouldn’t be an option for the current Python implementation though.

[ssteinbach]

I think if they were sentinel strings ("OTIO_NaN" or something) that would be convertible in python. But if the python JSON parser doesn't allow Inf or NaN float sentinels automatically then that would be a problem.

Also, if we move RationalTime away from floats, then something more flag-based might be better anyway.

[ssteinbach]

For reference, Imath::Box has a makeInfinite method:
https://github.com/openexr/openexr/blob/0be3e8c3b4a89e22f61a8e03e2dedf223d4ef79d/IlmBase/Imath/ImathBox.h#L193

[meshula]

and makeEmpty. Those were designed together with the box comparison algebra; i.e. all the operators should have the expected outcome when comparisons are made with other boxes.

[ssteinbach]

Imath boxes are always 2d, right? Imath doesn't encode ranges of a single dimensional number line?

[meshula]

ImathInterval.h

//-------------------------------------------------------------------
//
//	class Imath::Interval<class T>
//	--------------------------------
//
//	An Interval has a min and a max and some miscellaneous
//	functions. It is basically a Box<T> that allows T to be
//	a scalar.
//
//-------------------------------------------------------------------

It's API isn't fully consistent with box's. i.e. it has makeEmpty but not makeInfinite. This more of an error of omission rather than a design choice.

[ssteinbach]

Ah, thanks!