Function worker_thread

ladspa/src/plugin.rs:150–382

Worker thread for audio processing. Processes audio in a separate thread to avoid blocking the real-time audio callback. Uses pre-allocated buffers to prevent memory allocations during processing. Model is created based on the initial state value.

(
    mut input_consumer: ringbuf::HeapCons<f32>,
    mut output_producer: ringbuf::HeapProd<f32>,
    state: Arc<SharedState>,
    host_sample_rate: usize,
)

/// audio callback. Uses pre-allocated buffers to prevent memory allocations
/// during processing. Model is created based on the initial state value.
fn worker_thread(
    mut input_consumer: ringbuf::HeapCons<f32>,
    mut output_producer: ringbuf::HeapProd<f32>,
    state: Arc<SharedState>,
    host_sample_rate: usize,
) {
    let needs_resample = host_sample_rate != MODEL_SAMPLE_RATE;
    let resample_ratio = host_sample_rate as f64 / MODEL_SAMPLE_RATE as f64;

    // Calculate chunk sizes for resampling
    // At 48kHz host and 16kHz model, ratio is 3.0
    // We process HOP_SIZE (256) samples at model rate per frame
    let host_chunk_size = (HOP_SIZE as f64 * resample_ratio).ceil() as usize;

    // Initialize high-quality sinc resamplers
    let mut downsampler: Option<FftFixedIn<f32>> = if needs_resample {
        Some(
            FftFixedIn::new(host_sample_rate, MODEL_SAMPLE_RATE, host_chunk_size, 1, 1)
                .expect("Failed to create downsampler"),
        )
    } else {
        None
    };

    let mut upsampler: Option<FftFixedOut<f32>> = if needs_resample {
        Some(
            FftFixedOut::new(MODEL_SAMPLE_RATE, host_sample_rate, host_chunk_size, 1, 1)
                .expect("Failed to create upsampler"),
        )
    } else {
        None
    };

    // Initialize STFT processor
    let mut stft = StftProcessor::new(NFFT, HOP_SIZE);

    // Wait for first run() call to set port values before creating model
    while !state.is_initialized() {
        if state.should_shutdown() {
            return;
        }
        thread::sleep(Duration::from_millis(1));
    }

    // Create model based on current state value (now set by run() call)
    let initial_model_type = state.get_model_type();
    let mut model = GtcrnModel::new(initial_model_type);

    // Pre-allocated fixed-size buffers (no heap allocations during processing)
    let mut input_buffer = vec![0.0_f32; host_chunk_size + 64];
    let mut window = vec![0.0_f32; NFFT];
    let mut model_accum = vec![0.0_f32; HOP_SIZE * 4]; // Accumulator for downsampled samples
    let mut model_accum_len: usize = 0;

    // Resampler I/O buffers (single channel, fixed size)
    let mut resample_in = vec![vec![0.0_f32; host_chunk_size + 64]];
    let mut resample_out = vec![vec![0.0_f32; HOP_SIZE + 64]];
    let mut upsample_in = vec![vec![0.0_f32; HOP_SIZE + 64]];