Rust Async/Await

Explain why calling an async function creates a lazy Future rather than immediately executing its body.

Compose async functions and async blocks with await.

Trace which local values remain in a future across an await suspension point.

Distinguish a future returning Poll::Pending from code that blocks an executor thread.

Explain how Pin and Unpin protect self-referential future state.

Explain how a Waker makes a pending future eligible to be polled again.

Implement a small custom Future by defining its poll state transitions.

Demonstrate how dropping a future cancels it and identify any partial side effects left behind.

Configure an appropriate Tokio runtime flavor for a native player.

Run independent futures concurrently with join and try_join.

Spawn a task whose captured state satisfies Send and 'static requirements.

Inspect JoinHandle results to distinguish task success, cancellation, and panic.

Implement deadlines and periodic work with Tokio timers.

Use select to react to the first of several asynchronous events.

Choose between spawn_blocking and a dedicated worker thread for blocking or thread-affine native code.

Connect a producer and consumer with a bounded Tokio mpsc channel.

Implement a request-response operation with a oneshot channel.

Distribute the latest player state with a watch channel.

Protect shared state with an async mutex without holding its guard across await.

Limit concurrent operations with a semaphore.

Process an asynchronous sequence through the Stream interface.

Shut down a task hierarchy with cancellation tokens and explicit channel closure.

Write deterministic async tests using paused time and controlled channel inputs.

Interpret the Period, AdaptationSet, and Representation hierarchy in an on-demand DASH MPD.

Parse an MPD XML document into validated Rust domain types.

Select compatible audio and video adaptation sets from MIME type and codec metadata.

Resolve BaseURL and SegmentTemplate data into initialization and media-segment URLs.

Expand a SegmentTimeline into a timestamped segment index.

Use Kaitai-generated types to locate required boxes in an ISO-BMFF file.

Extract track timescales and codec initialization data from an initialization segment.

Derive encoded sample offsets, sizes, decode times, and presentation times from a moof/mdat fragment.

Configure a reusable async HTTP client with connection reuse, request deadlines, and byte-range support.

Fetch MPD and media resources without blocking Tokio executor threads.

Stream an HTTP response into bounded chunks while measuring transferred bytes and elapsed time.

Retry an idempotent segment request with bounded exponential backoff.

Schedule initialization and media requests with a bounded look-ahead window.

Coordinate audio and video fetchers through channels and shared concurrency limits.

Test the acquisition pipeline against a local server that injects latency, throttling, and failures.

Calculate a segment throughput sample using byte counts and monotonic time.

Smooth noisy throughput samples with an exponentially weighted moving average.

Select the highest sustainable representation using a configurable safety margin.

Modify representation choices using low and high buffer-occupancy thresholds.

Prevent oscillation with upgrade hysteresis and a minimum representation residence time.

Allocate an estimated bandwidth budget across paired audio and video representations.

Define startup and rebuffer-recovery behavior for the ABR controller.

Evaluate ABR behavior against deterministic bandwidth traces and buffer metrics.

Wrap an owned FFmpeg handle in a Rust type that releases the handle through Drop.

Configure FFmpeg decoders from codec metadata extracted from initialization segments.

Translate fragmented-MP4 sample metadata into encoded packets for FFmpeg.

Drive FFmpeg send-packet and receive-frame loops through EAGAIN and end-of-stream draining.

Run decoding on dedicated workers connected to async code by bounded channels.

Feed decoded audio to a CPAL callback without blocking or allocating in the callback.

Derive an audio playback clock from rendered sample counts and media timestamps.

Schedule, delay, or drop video frames according to their presentation-time offset from the audio clock.

Allocate and recycle a Wayland shared-memory buffer pool.

Convert decoded video frames into a pixel layout accepted by the Wayland shared-memory path.

Integrate Wayland event dispatch with Tokio without polling in a busy loop.

Transfer frames to the thread-affine Wayland presentation path through a bounded channel.

Implement play, pause, and stop as commands to the player task hierarchy.

Instrument network, buffer, ABR, decode, synchronization, and rendering behavior with structured metrics.

Validate the complete player under network shaping while checking adaptation decisions, bounded memory use, and audio-video synchronization.