Struct FramePace 

pub struct FramePace {
    pub last_tick: Option<Instant>,
    /* private fields */
}

A capture’s frame pacing: the last frame it rendered, and how far a pull may still bring the next one forward.

The shared frame timer fires for the earliest due capture; each capture renders on it once its own period has (nearly) passed. Fresh input may also render a frame, and so may a frame the host compositor delivers under host capture or a region the X server reports damaged: a whole period after the last one the pull renders at once, and from half a period on it brings the frame forward, spending the time it comes early by from a budget that is paid back by a pull that arrives late and holds half a period at most. Input’s budget also refills at INPUT_BORROW_REFILL; the others’ does not (TickTrigger::refills). A pointer moving at the client’s refresh rate is thus captured as it lands rather than up to a period later, and a host’s or an application’s frames are published as they arrive rather than on the next timer tick, while input at a rate the cadence cannot follow raises the output rate by no more than the refill, and frames reported faster than the cadence not at all.

After an input frame, while the input’s own spacing sits at the cadence (PACED_INPUT_MIN_FRACTION to PACED_INPUT_MAX_FRACTION of a period), the timer stands back for TIMER_GRACE_AFTER_PULL beyond a period, so such input keeps rendering its own frames whether it runs a hair faster or slower than the timer, or jitters around it: a timer that resumed exactly a period after the frame would render just ahead of a move landing a little late, which then could not pull and waited a period. When the input stops, the timer renders after the grace and carries on from there. A faster client, a slower one, and a host’s frames leave the timer its period as before.

Damage the X server reports at the cadence earns the same grace: it is an application presenting on the server’s vblank, which runs on a clock of its own (a framebuffer server’s fake vblank fires on a millisecond timer, so its frames land up to a millisecond either side of the period). Without the grace a timer tick taken just ahead of such a frame captures the one before it again, and the frame it missed is published late or never.

Fields

last_tick: Option<Instant>

Last tick this capture actually rendered.

Implementations

impl FramePace

pub fn due(&self, trigger: TickTrigger, period: Duration, now: Instant) -> bool

Whether a capture rendering every period is due a frame at now, given what asks.

pub fn input_paced(interval: Option<Duration>, period: Duration) -> bool

Whether input spaced interval apart paces itself at the cadence of period.

pub fn ticked( &mut self, trigger: TickTrigger, period: Duration, now: Instant, input_paced: bool, )

Record the frame rendered at now. A pull ahead of the period spends the budget by what it came early; one behind the period pays back what it came late. A timer tick within half a period of when it was due counts as on time, so a timer that wakes a little late, as one does under load, keeps the rate instead of losing what it was late by every frame. input_paced says whether the input driving the capture paces itself at the cadence (Self::input_paced), which is what lets the timer stand back after an input frame.

pub fn defer(&mut self, until: Instant)

Hold the timer off this capture until until without a frame counting: a tick that published nothing must neither spin the timer nor move the cadence a fresh frame is measured against.

pub fn since_last_tick(&self, now: Instant) -> Option<Duration>

Time since this capture last rendered, if it has.

pub fn pull_at( &self, trigger: TickTrigger, period: Duration, now: Instant, ) -> Instant

The earliest trigger, one that pulls forward, may render: a whole period after the last frame, less what its budget still allows it to borrow. A caller that waits until then need not test due again, since a budget only grows with time.

pub fn next_due(&self, period: Duration, now: Instant) -> Instant

When the timer is next due for this capture: a period after the last frame, and the grace beyond that after an input frame the input paced.

Trait Implementations

impl Debug for FramePace

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for FramePace

fn default() -> FramePace

Returns the “default value” for a type.