Struct D3d11Renderer 

pub struct D3d11Renderer { /* private fields */ }

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

Terminal sink that submits Pixel::D3D11 video frames to a caller-supplied D3d11FrameRenderer — the D3D11 sibling of crate::elements::D3d12Renderer. Only built with the d3d11 feature.

Every producer in this crate’s D3D11 stack (crate::elements::D3d11Upload, crate::elements::D3d11Decoder, crate::elements::DxgiCaptureSource’s GPU capture mode) is meant to share one ID3D11Device (and its one immediate context) with whatever D3d11FrameRenderer impl this wraps. That single-context requirement is what makes zero-copy here need no explicit fence, unlike crate::elements::D3d12Renderer’s submit_nv12_texture (which needs one because the D3D12 decoder and renderer are genuinely different devices/queues with nothing else to serialize them): an ID3D11Device created without D3D11_CREATE_DEVICE_SINGLETHREADED has its immediate context auto-serialized by the runtime across threads, and as long as every element funnels its GPU commands through that one context, the driver executes them in submission order — no separate sync object needed. This only holds because everything shares the same context; a second ID3D11Device in the mix would need its own explicit synchronization, same as the D3D12 case.

Dispatches on the texture’s own DXGI_FORMAT (via GetDesc), not on any extra tag carried by the frame. D3d11Upload and GPU screen capture wrap manually-created textures, while D3d11Decoder receives textures from FFmpeg’s D3D11VA frame pool; reading the actual texture description gives all of those producer paths one reliable source of truth for the pixel layout.

Implementations

impl D3d11Renderer

pub fn new( name: impl Into<String>, renderer: Box<dyn D3d11FrameRenderer>, ) -> Self

renderer is whatever the caller’s own D3d11FrameRenderer implementation is — already constructed and pointed at a real window/device by the time it gets here.

pub fn resize(&self, width: u32, height: u32) -> Result<()>

Call when the target window resizes.

Trait Implementations

impl Element for D3d11Renderer

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 Sink for D3d11Renderer

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.