总线操作还可以作为一个函数：bus(A, B) 等于 A & B。

堆栈

堆栈（|）运算符构建组合组件。它可以应用于任何两个组件。

作为一个图运算符，堆栈对应于不交并。在 A | B 中，A 和 B 的输入和输出是不交的，并且它们是独立、并行处理的。

在堆栈中，组件按通道顺序书写。在 A | B | C 中，首先是 A 的通道，然后是 B 的通道，最后是 C 的通道。

堆栈通常用于构建过滤器参数。例如，在 (pass() | constant((440.0, 1.0))) >> lowpass() 中，输入信号通过堆栈和两个其他信号，频率和Q，连接到它，以形成低通滤波器的输入。

堆栈操作也可以作为一个函数：stack(A, B) 等于 A | B。

表达式是图

表达式 A >> (B ^ C ^ D) 定义了一个信号处理图。它具有任何输入 A，并从 B、C 和 D 并行输出所有内容。

整个结构被打包、单态化和内联，构成节点被消耗。如果您想重用组件，请将其定义为函数或闭包，或克隆它们。请参阅示例预读。

在编译期间检查连接性。不匹配的连接性将导致编译错误，错误信息将关于不匹配的 typenum 类型。连接 tick 中组件的数组 Frame<f32, Size> 来自 generic-array 和 numeric-array 库。

计算结构

图组合子消耗它们的参数。这防止了循环，并使结果计算图具有整体树形结构。

隐式循环防止意味着构建的结构在数据流意义上总是计算高效的。所有计算数据的重用都在组合子和组件的本地进行。

在 FunDSP 图表示法中，有两种主要方式来结构信号的重用：分支和总线。两者都作为基本运算符公开，指导计算的有效结构。因此，数据流问题在图表示法本身中得到阐述。

网络

图表示法对于复杂的图可能会变得繁琐。此外，有时输入和输出的数量直到运行时才知道。

Net 组件为连接 AudioUnit 节点提供了一个显式的图接口。网络的阿基米德数作为构造函数参数指定。

例如，使用 Net 动态构建 dc(220.0) >> sine()。

use fundsp::hacker::*;
// Instantiate network with 0 inputs and 1 output.
let mut net = Net::new(0, 1);
// Add nodes, obtaining their IDs.
let dc_id = net.push(Box::new(dc(220.0)));
let sine_id = net.push(Box::new(sine()));
// Connect nodes.
net.pipe(dc_id, sine_id);
net.pipe_output(sine_id);

Net的开销是调用Box<dyn AudioUnit>对象的开销。除此之外，动态版本与静态版本大致一样高效。

图语法也可用于组合Net实例。连接性检查将延迟到运行时。

网络还可以与预定义组件内联组合。组件首先被转换为Net。

当需要动态处理时，可以使用Net::wrap开始，它将任何单元转换为网络。

use fundsp::hacker::*;
// Wrap saw wave in a network.
let mut net = Net::wrap(Box::new(saw()));
// Now we can add filters conditionally.
let add_filter = true;
if add_filter {
    net = net >> lowpass_hz(1000.0, 1.0);
}

对于实时情况，Net可以分成前端和后端。前端处理网络的变化，而实时安全的后端渲染音频。

use fundsp::hacker::*;
let mut net = Net::new(0, 1);
let noise_id = net.chain(Box::new(pink()));
// Create the backend.
let mut backend = net.backend();
// The backend is now ready to be sent into an audio thread.
// We can make changes to the frontend and then commit them to the backend.
net.replace(noise_id, Box::new(brown()));
net.commit();
// We can also use the graph syntax to make changes, as long as connectivity
// is maintained at commit time.
net = net >> peak_hz(1000.0, 1.0);
net.commit();

使用动态网络会带来一些开销，因此使用块处理是一个特别好的主意，它可以有效地分摊这些开销。

序列器

Sequencer组件可以动态混合生成节点。它可以以采样精度启动和停止渲染节点。

序列器没有输入，但有用户指定的输出数量。

use fundsp::hacker::*;
// Create stereo sequencer.
// The first argument should be set true if we want to replay events after `reset`.
let mut sequencer = Sequencer::new(false, 2);

可以添加新事件，设置其开始和结束时间以及淡入和淡出包络。序列器返回一个ID，可用于稍后编辑事件。

// Add a new event with start time 1.0 seconds and end time 2.0 seconds.
// Fade-in time is 0.1 seconds, while the fade-out time is 0.2 seconds.
// This returns an `EventId`.
let id1 = sequencer.push(1.0, 2.0, Fade::Smooth, 0.1, 0.2, Box::new(noise() | noise()));
// Add a new event that starts immediately and plays indefinitely.
let id2 = sequencer.push_relative(0.0, f64::INFINITY, Fade::Smooth, 0.1, 0.2, Box::new(pink() | pink()));

用作动态混音器时，序列器可以分成前端和后端。前端用于添加和编辑事件，而实时安全的后端渲染音频。

// Get a backend for this sequencer. This sequencer is then the frontend.
let mut backend = sequencer.backend();
// Now we can insert the backend into, for example, a `Net`.
// Later we can use the frontend to create events and make edits to them; the end time and fade-out time
// can be changed. Here we start fading out the event immediately with an envelope duration of 0.1 seconds.
sequencer.edit_relative(id2, 0.0, 0.1);

输入模式和范围

一些在音频网络中发现的信号。

与波形一起工作

FunDSP包括一个多通道波形抽象，称为Wave。例如，渲染10秒的粉红噪声

use fundsp::hacker::*;
let wave1 = Wave::render(44100.0, 10.0, &mut (pink()));

然后使用移动带通滤波器过滤它，并将样本归一化到-1..1

let mut wave2 = wave1.filter(10.0, &mut ((pass() | lfo(|t| (xerp11(110.0, 880.0, spline_noise(0, t * 5.0)), 1.0))) >> bandpass()));
wave2.normalize();

启用std功能时，可以将波形保存为16位或32位WAV。16位格式是整数格式，而32位格式是浮点格式。

例如，将wave2保存到test.wav

wave2.save_wav16("test.wav").expect("Could not save wave.");

处理各种格式的音频文件由Symphonia包处理。Symphonia集成通过默认启用的files功能启用。必须启用std功能。

例如，加载test.wav

let wave3 = Wave::load("test.wav").expect("Could not load wave.");

可以使用wavech和wavech_at操作码播放回波形的单个通道。

信号流分析

FunDSP具有一个全面的信号流系统，它分析音频网络中的因果延迟和频率响应。

系统可以通过组合传递函数和折叠常数，从理论上计算出任何线性网络的频率响应。线性网络由线性滤波器、延迟以及以下操作构成：

• 混合。
• 链式连接。线性滤波器和延迟的链式连接保持线性。
• 恒定缩放。信号可以被常数因子缩放。

信号延迟在输入到输出的整个过程中都会被详细分析，这有助于自动从效果链中去除预延迟。

例如，FIR滤波器可以通过单样本延迟（tick操作码）和算术直接组合。信号流分析将立即揭示，2点平均滤波器在奈奎斯特频率处增益为零，而3点平均滤波器则不是。

use fundsp::hacker::*;
assert!((pass() & tick()).response(0, 22050.0).unwrap().norm() < 1.0e-9);
assert!((pass() & tick() & tick() >> tick()).response(0, 22050.0).unwrap().norm() > 0.1);

然而，通过适当的缩放，3点FIR也可以消失。

use fundsp::hacker::*;
assert!((0.5 * pass() & tick() & 0.5 * tick() >> tick()).response(0, 22050.0).unwrap().norm() < 1.0e-9);

滤波器

线性滤波器列表

所有线性滤波器都有经过验证的频率响应。

参数平滑滤波器

follow滤波器是特殊的。它支持上升（攻击）和下降（释放）段的不同速率。例如，afollow(0.1, 0.2)具有0.1秒的攻击和0.2秒的释放。

它还会立即跳转到输入流中的第一个值，并从那里开始平滑。这意味着输出值始终在输入范围内。

非线性滤波器列表

与线性滤波器不同，非线性滤波器可能对输入信号级别敏感。由于非线性，我们不尝试为这些滤波器计算频率响应。

频域重合分析

使用resynth操作码，滤波和其他效果也可以在频域中完成。

重合分析器将输入窗口以四个重叠的窗口转换到频域。然后，处理函数将这些输入转换为频域输出。输出窗口进行逆变换并重叠添加。

重合分析器可以精确地重建输入，因此可以将效果从输入和处理版本之间平滑地变化。

例如，要实现一个高度选择性的FFT带通滤波器

use fundsp::hacker32::*;

// The window length, which must be a power of two and at least four,
// determines the frequency resolution. Latency is equal to the window length.
let window_length = 1024;

// Passband in Hz.
let pass_min = 1000.0;
let pass_max = 2000.0;

// The number of input and output channels is user configurable.
// Here both are 1 (`U1`).
let synth = resynth::<U1, U1, _>(window_length, |fft|
    for i in 0..fft.bins() {
        if fft.frequency(i) >= pass_min && fft.frequency(i) <= pass_max {
            fft.set(0, i, fft.at(0, i));
        }
    });

处理函数可以从提供的FFT窗口对象中获取窗口时间，以支持时间变化的效果。

有关该技术的更多信息，请参阅音频信号的四阶分析和重建。

关于多线程和实时控制的更多信息

除了Net和Sequencer前端外，还有两种方法可以将实时控制引入图表达式：共享原子变量和设置监听器。

原子变量

我们可以使用共享原子变量与外部上下文通信数据。共享变量用初始值声明

use fundsp::hacker::*;
let amp = shared(1.0);

共享变量可以被克隆并发送到另一个线程。要将共享变量输出实例化到音频图中，请使用var和var_fn操作码。例如，要控制振幅

let amp_controlled = noise() * var(&amp);

稍后我们可以从任何地方设置振幅

amp.set_value(0.5);

一个有用的模式是将共享变量通过一个follow滤波器管道传递以平滑参数变化，这里以0.1秒的响应时间

let amp_controlled = noise() * (var(&amp) >> follow(0.1));

timer操作码在共享变量中维护流时间。定时器节点没有输入或输出，可以通过堆叠与任何节点连接。

设置

设置是所有没有专用输入的节点参数。一个节点可以响应一种或多种设置类型，这些设置通过set方法应用。

use fundsp::hacker::*;
let mut node = afollow(0.1, 1.0);
node.set(Setting::attack_release(0.2, 2.0));

要从其他线程调整设置，可以将节点包装在一个设置监听器中，使用listen(node)操作码。它返回一个(sender, node)对。

发送者可以被克隆并从其他线程调用。通过sender可用的设置格式取决于图类型。

可以通过寻址访问结构内的节点

地址在参数构造函数之后指定。它们可以嵌套到四层。

如果监听器连接到二进制操作，则可以使用left或right方法选择不同的侧面。例如，常量作为标量设置公开

use fundsp::hacker::*;
let (sender, node) = listen(dc(0.5) >> resample(pink()));
sender.try_send(Setting::value(0.6).left()).expect("Cannot send setting.");

如果一个参数有专门的输入，则它不能是设置。要获取通过设置控制的参数的过滤器，需要使用指定所有参数为常数的表单，例如，lowpass_hz。

use fundsp::hacker::*;
let (sender, node) = listen(lowpass_hz(1000.0, 1.0));

之后我们可以通过 sender 从任何地方发送过滤器参数。例如，低通滤波器支持设置截止频率和 Q 值。将滤波器截止频率设置为 2 kHz，Q 值为 2.0

sender.try_send(Setting::center_q(2000.0, 2.0)).expect("Cannot send setting.");

以下表格总结了可用的设置。

如果节点对 center_q_gain 做出响应，则它也对 center_q 和 center 做出响应。如果节点对 center_q 做出响应，则它也对 center 做出响应。

参数均衡器配方

在这个例子中，我们使用峰值 bell 滤波器制作了一个 12 带双精度参数均衡器。样本类型，像往常一样，是 32 位浮点数（f32）。

首先，声明处理管道。在这里，我们从 1 kHz 开始，以 1 kHz 的增量间隔设置波段，将 Q 值设置为 1.0，并将所有波段的增益最初设置为 0 dB

use fundsp::hacker::*;
let mut equalizer = pipei::<U12, _, _>(|i| bell_hz(1000.0 + 1000.0 * i as f32, 1.0, db_amp(0.0)));

均衡器的类型是 An<Chain<U12, FixedSvf<f64, BellMode<f64>>>>。均衡器可以立即使用。滤波器样本

let output_sample = equalizer.filter_mono(input_sample);

equalizer.node_mut(0).set_gain(db_amp(10.0));
equalizer.node_mut(0).set_center(500.0);
equalizer.node_mut(0).set_q(2.0);

let decibel_gain_at_1k = equalizer.response_db(0, 1000.0).unwrap();

equalizer.set_sample_rate(48_000.0);

let (sender, equalizer) = listen(equalizer);

sender.try_send(Setting::center_q_gain(1000.0, 2.0, db_amp(3.0)).index(1)).expect("Cannot send setting.");

C:\rust>evcxr
Welcome to evcxr. For help, type :help
>> :dep fundsp
>> use fundsp::hacker::*;
>> print!("{}", bell_hz(1000.0, 1.0, db_amp(50.0)).display())
 60 dB ------------------------------------------------  60 dB
 
 50 dB -------------------------.----------------------  50 dB
                                *
 40 dB -------------------------*----------------------  40 dB
                               ** 
 30 dB -----------------------.***---------------------  30 dB
                             ******.
 20 dB -------------------..*********.-----------------  20 dB
                       ..**************.
 10 dB -------------..********************..-----------  10 dB
               ..*****************************...
  0 dB ....***************************************.....   0 dB
       |   |    |    |     |    |    |     |    |    |
       10  50   100  200   500  1k   2k    5k   10k  20k Hz

Peak Magnitude : 50.00 dB (1000 Hz)
Inputs         : 1
Outputs        : 1
Latency        : 0.0 samples
Footprint      : 96 bytes

>>

use fundsp::hacker::*;
let partials = busi::<U20, _, _>(|i| noise() >> resonator_hz(xerp(1_000.0, 2_000.0, rnd1(i) as f32), 20.0));

use fundsp::hacker::*;
let partials = busf::<U20, _, _>(|f| noise() >> resonator_hz(xerp(1_000.0, 2_000.0, f), 20.0));

use fundsp::hacker::*;
fn pure_tone_amp(hz: f32) -> f32 { lerp(1.0, 0.0, smooth5(clamp01(delerp(20_000.0, 22_050.0, hz)))) }