Struct AudioRenderThread 

pub struct AudioRenderThread {
    pub graph: AudioGraph,
    pub sink: Sink,
    pub sink_factory: Box<dyn Fn() -> Result<Box<dyn AudioSink + 'static>, AudioSinkError>>,
    pub reader_factory: Box<ReaderFactoryCallback>,
    pub state: ProcessingState,
    pub sample_rate: f32,
    pub current_time: f64,
    pub current_frame: Tick,
    pub muted: bool,
}

Fields

graph: AudioGraph

sink: Sink

sink_factory: Box<dyn Fn() -> Result<Box<dyn AudioSink + 'static>, AudioSinkError>>

reader_factory: Box<ReaderFactoryCallback>

state: ProcessingState

sample_rate: f32

current_time: f64

current_frame: Tick

muted: bool

Implementations

impl AudioRenderThread

fn prepare_thread<B: AudioBackend>( sender: Sender<AudioRenderThreadMsg>, sample_rate: f32, graph: AudioGraph, options: AudioContextOptions, ) -> Result<Self, AudioSinkError>

Initializes the AudioRenderThread object

You must call .event_loop() on this to run it!

pub fn start<B: AudioBackend>( event_queue: Receiver<AudioRenderThreadMsg>, sender: Sender<AudioRenderThreadMsg>, sample_rate: f32, graph: AudioGraph, options: AudioContextOptions, init_sender: Sender<Result<(), AudioSinkError>>, )

Start the audio render thread

In case something fails, it will instead start a thread with a dummy backend

fn resume(&mut self) -> StateChangeResult

fn suspend(&mut self) -> StateChangeResult

fn create_node( &mut self, node_type: AudioNodeInit, ch: ChannelInfo, ) -> Option<NodeId>

fn connect_ports( &mut self, output: PortId<OutputPort>, input: PortId<InputPort>, )

fn process(&mut self) -> Chunk

fn set_mute(&mut self, val: bool)

fn event_loop(&mut self, event_queue: Receiver<AudioRenderThreadMsg>)