Method process_node

crates/firewheel-graph/src/processor/event_scheduler.rs:567–814

(
        &mut self,
        node_id: NodeID,
        node_entry: &mut NodeEntry,
        block_frames: usize,
        clock_samples: InstantSamples,
        info: &mut ProcInfo,
        extra: &mut P

                    }

                    // Keep track of the number of elapsed schedueld events this
                    // block to further optimize the linear search.
                    node_entry.event_data.num_scheduled_events_this_block += 1;
                } else {
                    self.scheduled_event_arena[*slot as usize] = None;
                }

                self.num_elapsed_sorted_events += 1;
            } else {
                // The event happens after this processing block, so we are done
                // searching.
                break;
            }
        }
    }

    /// Process in sub-chunks for each new scheduled event (or process a single
    /// chunk if there are no scheduled events).
    #[expect(clippy::too_many_arguments, reason = "Function needs many arguments")]
    pub fn process_node(
        &mut self,
        node_id: NodeID,
        node_entry: &mut NodeEntry,
        block_frames: usize,
        clock_samples: InstantSamples,
        info: &mut ProcInfo,
        extra: &mut ProcExtra,
        proc_event_queue: &mut Vec<ProcEventsIndex>,
        mut proc_buffers: ProcBuffers,
        mut on_sub_chunk: impl FnMut(ProcessSubChunkInfo),
    ) {
        // Rust is getting confused when the cfg is put on the argument for some reason,
        // so just duplicate the closure.
        #[cfg(not(feature = "scheduled_events"))]
        let push_event = |node_event_queue: &mut Vec<ProcEventsIndex>,
                          immediate_event_buffer: &[Option<NodeEvent>],
                          event: ProcEventsIndex,
                          logger: &mut RealtimeLogger,
                          set_bypassed: &mut Option<bool>| {
            match event {
                ProcEventsIndex::Immediate(i) => {
                    if let Some(event) = immediate_event_buffer
                        .get(i as usize)
                        .and_then(|e| e.as_ref())
                        && let NodeEventType::SetBypassed(bypassed) = &event.event
                    {
                        *set_bypassed = Some(*bypassed);
                        return;
                    }
                }
            }

            if node_event_queue.len() == node_event_queue.capacity() {
                match self.buffer_out_of_space_mode {
                    BufferOutOfSpaceMode::AllocateOnAudioThread => {
                        let _ = logger.try_error("Firewheel event queue is full! Please increase FirewheelConfig::event_queue_capacity to avoid audio glitches.");
                    }
                    BufferOutOfSpaceMode::Panic => {