NeuralAmpModeler-rs 3.0.2

An opinionated, high-performance Neural Amp Modeler (NAM) client and core implementation in Rust for Linux/PipeWire and CLAP plugins.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 Fábio Henrique de Lima Silva (fhl.bsb@gmail.com) All rights reserved.

use super::super::NamClapProcessor;
use crate::clap::processor::dsp::peaks;
use crate::math::dsp::stereo::compute_peak_abs_stereo;
use clack_plugin::{prelude::*, process::audio::PortPair};

impl<'a> NamClapProcessor<'a> {
    #[inline(always)]
    pub(super) fn process_bypass(
        &self,
        port_pair: &mut PortPair<'_>,
        n_samples: usize,
    ) -> Result<bool, PluginError> {
        if !self.params.bypass {
            return Ok(false);
        }
        self.process_bypass_cold(port_pair, n_samples)
    }

    #[cold]
    #[inline(never)]
    fn process_bypass_cold(
        &self,
        port_pair: &mut PortPair<'_>,
        n_samples: usize,
    ) -> Result<bool, PluginError> {
        let Some(channel_pairs) = port_pair.channels()?.into_f32() else {
            return Ok(true);
        };
        let mut peak_l = 0.0f32;
        let mut peak_r = 0.0f32;
        let mut channel_iter = channel_pairs.into_iter();

        if let Some(pair) = channel_iter.next() {
            match pair {
                ChannelPair::InputOutput(i, o) => {
                    let n = n_samples.min(o.len());
                    o[..n].copy_from_slice(&i[..n]);
                    // SAFETY: both slices reference the same valid buffer `o`
                    // with identical length `n`, satisfying the equal-length
                    // requirement of `compute_peak_abs_stereo`.
                    let (p, _) = unsafe { compute_peak_abs_stereo(&o[..n], &o[..n]) };
                    peak_l = p;
                }
                ChannelPair::InPlace(io) => {
                    let n = n_samples.min(io.len());
                    // SAFETY: both slices reference the same valid buffer `io`
                    // with identical length `n`, satisfying the equal-length
                    // requirement of `compute_peak_abs_stereo`.
                    let (p, _) = unsafe { compute_peak_abs_stereo(&io[..n], &io[..n]) };
                    peak_l = p;
                }
                ChannelPair::InputOnly(_) | ChannelPair::OutputOnly(_) => {}
            }
        }
        if let Some(pair) = channel_iter.next() {
            match pair {
                ChannelPair::InputOutput(i, o) => {
                    let n = n_samples.min(o.len());
                    o[..n].copy_from_slice(&i[..n]);
                    // SAFETY: both slices reference the same valid buffer `o`
                    // with identical length `n`, satisfying the equal-length
                    // requirement of `compute_peak_abs_stereo`.
                    let (p, _) = unsafe { compute_peak_abs_stereo(&o[..n], &o[..n]) };
                    peak_r = p;
                }
                ChannelPair::InPlace(io) => {
                    let n = n_samples.min(io.len());
                    // SAFETY: both slices reference the same valid buffer `io`
                    // with identical length `n`, satisfying the equal-length
                    // requirement of `compute_peak_abs_stereo`.
                    let (p, _) = unsafe { compute_peak_abs_stereo(&io[..n], &io[..n]) };
                    peak_r = p;
                }
                ChannelPair::InputOnly(_) | ChannelPair::OutputOnly(_) => {}
            }
        }

        peaks::store_peaks(self.shared, peak_l, peak_r);
        Ok(true)
    }
}