Method new

crates/firewheel-graph/src/context.rs:329–393

Create a new Firewheel context.

(config: FirewheelConfig)

        let initial_event_group_capacity = config.initial_event_group_capacity as usize;
        let mut event_group_pool = Vec::with_capacity(16);
        for _ in 0..3 {
            event_group_pool.push(Vec::with_capacity(initial_event_group_capacity));
        }

        let graph = AudioGraph::new(&config);

        let (shared_clock_input, shared_clock_output) =
            triple_buffer::triple_buffer(&SharedClock::default());

        let (logger, logger_rx) = firewheel_core::log::realtime_logger(config.logger_config);
        let (profiler_tx, profiler_rx) = crate::processor::profiling::profiler_channel(
            config.initial_node_capacity as usize,
            #[cfg(feature = "node_profiling")]
            graph.graph_out_node(),
        );
        let shared_flags = Arc::new(SharedFlags::default());

        let store = ProcStore::with_capacity(config.proc_store_capacity);

        Self {
            graph,
            to_processor_tx,
            from_processor_rx,
            processor_drop_flag: None,
            profiler_rx,
            logger_rx,
            pending_processor_channel: Some(ProcessorChannel {
                shared_flags: Arc::clone(&shared_flags),
                from_context_rx,
                to_context_tx,
                logger,
                store,
                profiler_tx,
                shared_clock_input,
            }),
            processor_drop_rx: None,
            shared_clock_output: RefCell::new(shared_clock_output),
            sample_rate: NonZeroU32::new(44100).unwrap(),
            sample_rate_recip: 44100.0f64.recip(),
            stream_info: None,
            shared_flags,
            #[cfg(feature = "musical_transport")]
            transport_state: Box::new(TransportState::default()),
            #[cfg(feature = "musical_transport")]
            transport_state_alloc_reuse: None,
            event_group_pool,
            event_group: Vec::with_capacity(initial_event_group_capacity),
            initial_event_group_capacity,
            #[cfg(feature = "scheduled_events")]
            queued_clear_scheduled_events: Vec::new(),
            config,
        }
    }

    /// Try to modify the graph. If the given closure returns an error (or
    /// if a cycle is detected), then any changes made to the graph inside
    /// the closure will be reverted.
    ///