Struct WasapiRenderer 

pub struct WasapiRenderer { /* private fields */ }

Available on Windows and crate feature wasapi-renderer and (crate features d3d11 or d3d12 or wasapi-renderer) only.

Terminal audio sink backed by a WASAPI shared-mode render endpoint. The endpoint’s mix format is returned by WasapiRenderer::open so a caller can place an crate::elements::AudioResampler immediately before this sink. This element intentionally performs no hidden format conversion. Call WasapiRenderer::bind_playback_clock while wiring a fixed A/V pipeline to publish this endpoint’s actual played-sample position as that pipeline’s audio master. A branch attached to a running dynamic Tee uses WasapiRenderer::bind_playback_clock_deferred instead, so it cannot stall video before the first audio frame reaches the renderer.

Device-buffer backpressure is the playback clock: consume waits for enough WASAPI ring-buffer space to submit the whole input frame. Put a crate::queue::Queue immediately before this sink when its blocking must not hold up another branch.

Implementations

impl WasapiRenderer

pub fn list_devices() -> Result<Vec<WasapiDevice>, WasapiRendererError>

pub fn open( name: impl Into<String>, options: WasapiRendererOptions, ) -> Result<(Self, AudioFormat), WasapiRendererError>

pub fn format(&self) -> AudioFormat

pub fn bind_playback_clock( &mut self, playback_clock: Arc<PlaybackClock>, ) -> Result<(), WasapiRendererError>

Makes this endpoint the pipeline’s exclusive audio playback master. Call during the wiring closure, before boxing the renderer into its terminal branch.

pub fn bind_playback_clock_deferred( &mut self, playback_clock: Arc<PlaybackClock>, ) -> Result<(), WasapiRendererError>

Binds a dynamically attached endpoint without claiming the audio-master slot until its first non-empty audio frame arrives.

This avoids a priming deadlock when an upstream demuxer can block on a full video queue before reaching the first packet for the newly attached audio branch. Unlike Self::bind_playback_clock, an exclusive-master conflict is therefore returned from that first Sink::consume call.

Trait Implementations

impl Drop for WasapiRenderer

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Element for WasapiRenderer

fn name(&self) -> Arc<str>

Returns a cheap clone (refcount bump, not a deep copy) of this element’s name — crate::bus::BusEvent stores names as Arc<str> for exactly this reason: a hot path like crate::queue::Queue posting BusEvent::Dropped once per overflowed buffer shouldn’t pay for a fresh heap allocation every time it wants to report which element it is.

fn element_type(&self) -> ElementType

See ElementType.

fn pp_log(&self) -> &PpLog

This element’s identity for crate::bus::Bus::post — same id/name as Element::name, just already wrapped as the crate::pp_log::PpLog its pp_info!/pp_warn!/pp_error! macros need. A stored private field, not built fresh per call, for the same reason name() returns a cheap Arc<str> clone instead of a fresh String — see its own docs.

fn pp_log_mut(&mut self) -> &mut PpLog

Mutable access to the same field Element::pp_log reads — used by crate::pipeline::ChainBuilder to stamp the owning crate::pipeline::Pipeline’s id onto every element that passes through it, via element_pp_log. Not meant to be called from anywhere else.

fn graph_id(&self) -> Option<ElementId>

A pre-reserved graph identity for elements that expose dynamic attachment handles. Most elements receive an ID from ChainBuilder and keep the default None implementation.

impl Send for WasapiRenderer

impl Sink for WasapiRenderer

fn consume(&mut self, buf: MediaBuffer) -> Result<()>

fn control(&mut self, msg: ControlMsg) -> Result<()>

Reacts to a ControlMsg (pause/resume/stop) and, for anything with a downstream of its own, forwards it on — same shape as consume, just a separate channel from MediaBuffer so it can reach every element (not just ones that already know how to interpret a data buffer) and, at a crate::queue::Queue, jump ahead of whatever data is backed up instead of waiting behind it. No default: every Sink has to consciously decide what this means for it, rather than silently dropping it.