oscen 0.1.4

A library for building modular synthesizers
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
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

use super::signal::*;
use super::utils::ExpInterp;
use crate::{as_any_mut, std_signal};
use crossbeam::crossbeam_channel::Sender;
use midir::{Ignore, MidiInput};
use pitch_calc::calc::hz_from_step;
use std::any::Any;
use std::error::Error;
use std::io::{stdin, stdout, Write};

/// The most recent note received from the midi source.
#[derive(Clone)]
pub struct MidiPitch {
    tag: Tag,
    step: f32,
    offset: f32, // In semitones
    factor: f32,
}

impl MidiPitch {
    pub fn new() -> Self {
        MidiPitch {
            tag: mk_tag(),
            step: 0.0,
            offset: 0.0,
            factor: 1.0,
        }
    }

    pub fn step(&mut self, arg: f32) -> &mut Self {
        self.step = arg;
        self
    }

    pub fn offset(&mut self, arg: f32) -> &mut Self {
        self.offset = arg;
        self
    }

    pub fn factor(&mut self, arg: f32) -> &mut Self {
        self.factor = arg;
        self
    }
}

impl Builder for MidiPitch {}

impl Signal for MidiPitch {
    std_signal!();
    fn signal(&mut self, _rack: &Rack, _sample_rate: Real) -> Real {
        hz_from_step(self.factor * self.step + self.offset) as Real
    }
}

#[derive(Clone)]
pub struct MidiControl {
    tag: Tag,
    pub controller: u8,
    value: u8,
    exp_interp: ExpInterp,
}

impl MidiControl {
    pub fn new(controller: u8, value: u8, low: Real, mid: Real, high: Real) -> Self {
        Self {
            tag: mk_tag(),
            controller,
            value,
            exp_interp: ExpInterp::new(low, mid, high),
        }
    }

    fn map_range(&self, input: Real) -> Real {
        let x = input / 127.0;
        self.exp_interp.interp(x)
    }

    pub fn controller(&mut self, arg: u8) -> &mut Self {
        self.controller = arg;
        self
    }

    pub fn value(&mut self, arg: u8) -> &mut Self {
        self.value = arg;
        self
    }
}

impl Builder for MidiControl {}

impl Signal for MidiControl {
    std_signal!();

    fn signal(&mut self, _rack: &Rack, _sample_rate: Real) -> Real {
        self.map_range(self.value as Real)
    }
}

pub fn listen_midi(midi_sender: Sender<Vec<u8>>) -> Result<(), Box<dyn Error>> {
    let mut input = String::new();
    let mut midi_in = MidiInput::new("midir reading input")?;
    midi_in.ignore(Ignore::None);

    // Get an input port (read from console if multiple are available)
    let in_ports = midi_in.port_count();
    let in_port = match in_ports {
        0 => return Err("no input port found".into()),
        1 => {
            println!(
                "Choosing the only available input port: {}",
                midi_in.port_name(0).unwrap()
            );
            0
        }
        _ => {
            println!("\nAvailable input ports:");
            for i in 0..in_ports {
                println!("{}: {}", i, midi_in.port_name(i).unwrap());
            }
            print!("Please select input port: ");
            stdout().flush()?;
            let mut input = String::new();
            stdin().read_line(&mut input)?;
            input.trim().parse::<usize>()?
        }
    };

    println!("\nOpening connection");

    // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
    let _conn_in = midi_in.connect(
        in_port,
        "midir-read-input",
        move |_, message, _| {
            midi_sender.send(message.to_vec()).unwrap();
        },
        (),
    )?;

    // println!("Connection open, reading input from '{}' (press enter to exit) ...", in_port_name);

    input.clear();
    stdin().read_line(&mut input)?; // wait for next enter key press

    println!("Closing connection");
    Ok(())
}