class State

Advances all long-running positions to `dest_target_frame`. This is useful when resolving

discontinuities until an absolute target frame, without having to refer back to

`next_dest_frame`.

Advances all long-running positions by `dest_frames`. This is useful when resolving

discontinuities resulting from a gap in the source stream.

Updates long-running positions by `dest_frames`.

Resets long-running positions. This should be called when a destination discontinuity occurs

to set `next_dest_frame` to the specified value and calculate `next_source_frame` based on

the `dest_frames_to_frac_source_frames` transform.

Resets source stride with a given `source_frac_frame_per_dest_frame` rate.

Translates the long-running source position into monotonic nsecs, using the nsec-to-Fixed

`clock_mono_to_frac_source_frames` transform.

To scale from reference units to subject units, `TimelineFunction::Apply` does this:

`(in_param - reference_offset) * subject_delta / reference_delta + subject_offset`

`clock_mono_to_frac_source_frames` contains the correspondence we need (but inversed; subject

is `frac_source`, reference is monotonic nsecs). To more accurately calculate monotonic nsecs

from `frac_source` (including modulo), we scale the function by `step_size_denominator`, then

we can include `source_pos_modulo` at full resolution and round when reducing to nsecs. So in

the `TimelineFunction::Apply` equation above, we will use:

```

in_param:

next_source_frame().raw_value() * step_size_denominator() + source_pos_modulo()

reference_offset:

clock_mono_to_frac_source_frames.subject_time() * step_size_denominator()

subject_delta and reference_delta:

used as-is while remembering that the step size is inverted

subject_offset:

clock_mono_to_frac_source_frames.reference_time() * step_size_denominator()

```

Because all the initial factors are 64-bit, our denominator-scaled version must use 128-bit.

Even then, we might overflow depending on parameters, so we scale back denominator if needed.

TODO(https://fxbug.dev/42167787): Generalize this (remove the scale-down denominator

optimization) and extract the functionality into a 128-bit template specialization of

`TimelineRate` and `TimelineFunction`.

Returns corresponding destination length in frames for a given `source_length` in frames.

Returns fractional step size for the source, i.e., "stride" for how much to increment the

sampling position in the source stream, for each destination frame produced.

Expresses (along with `step_size_denominator`) leftover rate precision that `step_size`

cannot express, which is a fractional value of the `step_size` unit that source position

should advance, for each destination frame.

Expresses (along with `step_size_modulo` and `source_pos_modulo`) leftover rate and position

precision that `step_size` and `Source::frame_offset_ptr` (respectively) cannot express.

Returns corresponding source length in frames for a given `dest_length` in frames.

Expresses (along with `step_size_denominator`) leftover position precision that `Source` and

`Dest` parameters cannot express. When present, `source_pos_modulo` and

`step_size_denominator` express a fractional value of the `Source::frame_offset_ptr` unit,

for additional precision on current position.

Represents the next destination frame to process.

Represents the next source frame to process.

Represents the difference between `next_source_frame` (maintained on a relative basis after

each `Process` call), and the clock-derived absolute source position. Upon a destination

frame discontinuity, `next_source_frame` is reset to that clock-derived value, and this field

is set to zero. This field sets the direction and magnitude of any steps taken for clock

reconciliation.