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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use libpd_rs::{
functions::{receive::on_float, send::send_list_to, util::calculate_ticks},
Pd,
};
use sys_info::loadavg;
fn main() -> Result<(), Box<dyn std::error::Error>> {
// Initialize cpal
// This could have been another cross platform audio library
// basically anything which gets you the audio callback of the os.
let host = cpal::default_host();
// Currently we're only going to output to the default device
let device = host.default_output_device().unwrap();
// Using the default config
let config = device.default_output_config()?;
// Let's get the default configuration from the audio driver.
let sample_rate = config.sample_rate().0 as i32;
let output_channels = config.channels() as i32;
// Initialize libpd with that configuration,
// with no input channels since we're not going to use them.
let mut pd = Pd::init_and_configure(0, output_channels, sample_rate)?;
let ctx = pd.audio_context();
// Let's evaluate another pd patch.
// We could have opened a `.pd` file also.
pd.eval_patch(
r#"
#N canvas 832 310 625 448 12;
#X obj 18 27 r cpu_load;
#X obj 55 394 s response;
#X obj 13 261 *~;
#X obj 112 240 vline~;
#X obj 118 62 bng 15 250 50 0 empty empty empty 17 7 0 10 -262144 -1
-1;
#X obj 14 395 dac~;
#X obj 50 299 sig~;
#X floatatom 50 268 5 0 0 0 - - -;
#X obj 13 228 phasor~ 120;
#X obj 139 61 metro 2000;
#X obj 139 38 tgl 15 0 empty empty empty 17 7 0 10 -262144 -1 -1 1
1;
#X obj 18 52 unpack f f;
#X obj 14 362 *~ 2;
#X obj 14 336 vcf~ 12;
#X obj 139 12 loadbang;
#X msg 118 86 1 8 \, 0 0 10;
#X obj 149 197 expr (480 + 80) * ($f1 - 8) / (4 - 16) + 480;
#X obj 29 128 * 20;
#X obj 167 273 expr (520 + 120) * ($f1 - 5) / (12 - 5) + 120;
#X connect 0 0 11 0;
#X connect 2 0 13 0;
#X connect 3 0 2 1;
#X connect 4 0 15 0;
#X connect 6 0 13 1;
#X connect 7 0 6 0;
#X connect 8 0 2 0;
#X connect 9 0 15 0;
#X connect 10 0 9 0;
#X connect 11 0 16 0;
#X connect 11 0 18 0;
#X connect 11 1 17 0;
#X connect 12 0 5 0;
#X connect 12 0 5 1;
#X connect 13 0 12 0;
#X connect 14 0 10 0;
#X connect 15 0 3 0;
#X connect 16 0 9 1;
#X connect 17 0 1 0;
#X connect 17 0 13 2;
#X connect 18 0 7 0;
"#,
)?;
// Here we are registering a listener (hook in libpd lingo) for
// float values which are received from the pd patch.
on_float(|source, value| {
if source == "response" {
print!("\r");
print!("Pd says that the q value of the vcf~ is: {value}");
}
});
// Pd can send data to many different endpoints at a time.
// This is why we need to declare our subscription to one or more first.
// In this case we're subscribing to one, but it could have been many,
pd.subscribe_to("response")?;
// Build the audio stream.
let output_stream = device.build_output_stream(
&config.into(),
move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
// Provide the ticks to advance per iteration for the internal scheduler.
let ticks = calculate_ticks(output_channels, data.len() as i32);
// Here if we had an input buffer
// we could have modified it to do pre-processing.
// To receive messages from the pd patch we need to read the ring buffers
// filled by the pd patch repeatedly to check if there are messages there.
// Audio callback is a nice place to do that.
ctx.receive_messages_from_pd();
// Process audio, advance internal scheduler.
ctx.process_float(ticks, &[], data);
// Here we could have done post processing after
// pd processed our output buffer in place.
},
|err| eprintln!("an error occurred on stream: {}", err),
None,
)?;
// Turn audio processing on
pd.activate_audio(true)?;
// Run the stream
output_stream.play()?;
// This program does not terminate.
// You would need to explicitly quit it.
loop {
// We sample in 2 hz.
std::thread::sleep(std::time::Duration::from_millis(500));
// Read the average load of the cpu.
let load = loadavg()?;
let one_minute_cpu_load_average = load.one;
let five_minutes_cpu_load_average = load.five;
// Lists are one of the types we can send to pd.
// Although pd allows for heterogeneous lists,
// even if we're not using them heterogeneously in this example,
// we still need to send it as a list of Atoms.
// Atom is an encapsulating type in pd to unify
// various types of data together under the same umbrella.
// Check out `libpd_rs::types` module for more details.
// Atoms have From trait implemented for them for
// floats and strings.
send_list_to(
"cpu_load",
&[
one_minute_cpu_load_average.into(),
five_minutes_cpu_load_average.into(),
],
)?;
}
}