unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-07 04:06:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

refactor: device abstraction, layout components

Browse source
This commit is contained in:
🪞👃🪞 2024-06-12 16:55:57 +03:00
parent d330d31ce4
commit 788dc1ccde
21 changed files with 1144 additions and 1166 deletions
Download patch file Download diff file Expand all files Collapse all files

21
src/device/README.md Normal file
View file

@ -0,0 +1,21 @@
Device.inputs is Port[]
Device.outputs is Port[]
Transport is Device
Transport.session is Device
Mixer is Device
Mixer.tracks is Device[]
Chain is Device
Chain.devices is Device[]
Sequencer is Device
Sampler is Device
Plugin is Device
Mixer -> [Track1, Track2... TrackN]
Track -> [Device1, Device2... N]

21
src/device/chain.rs Normal file
View file

@ -0,0 +1,21 @@
use crate::prelude::*;
pub struct Chain {
name: String,
devices: Vec<Box<dyn Device>>
}
impl Chain {
pub fn new (name: &str, devices: Vec<Box<dyn Device>>) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into(),
devices
}))
}
}
pub fn render (state: &Chain, buf: &mut Buffer, area: Rect) {}
pub fn handle (state: &mut Chain, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
Ok(())
}

91
src/device/launcher.rs
View file

@ -1,37 +1,56 @@
let mut x = areas[1].x;
for (index, track) in [
"Track 1",
"Track 2",
"Track 3",
"Track 4",
"Track 5",
"Bus 1",
"Bus 2",
"Mix",
].iter().enumerate() {
buffer.set_string(
x + 10 * (index + 1) as u16, areas[1].y,
"┬", Style::default().not_bold().dim()
);
buffer.set_string(
x + 10 * (index + 1) as u16, areas[1].y + areas[1].height - 1,
"┴", Style::default().not_bold().dim()
);
for y in areas[1].y+1..areas[1].y+areas[1].height - 1 {
buffer.set_string(
x + 10 * (index + 1) as u16, y,
"│", Style::default().not_bold().gray().dim()
);
}
for y in areas[1].y+2..areas[1].y+areas[1].height - 1 {
buffer.set_string(
x + 10 * index as u16 + 1, y,
"--------", Style::default().not_bold().gray().dim()
);
}
buffer.set_string(
x + 10 * index as u16 + 1, areas[1].y + 1,
track, Style::default().bold().not_dim()
);
}
use crate::prelude::*;
pub struct Launcher {
name: String
}
impl Launcher {
pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into(),
}))
}
}
pub fn render (state: &Launcher, buf: &mut Buffer, area: Rect) {}
pub fn handle (state: &mut Launcher, event: &Event) -> Result<(), Box<dyn Error>> {
Ok(())
}
//let mut x = areas[1].x;
//for (index, track) in [
//"Track 1",
//"Track 2",
//"Track 3",
//"Track 4",
//"Track 5",
//"Bus 1",
//"Bus 2",
//"Mix",
//].iter().enumerate() {
//buffer.set_string(
//x + 10 * (index + 1) as u16, areas[1].y,
//"┬", Style::default().not_bold().dim()
//);
//buffer.set_string(
//x + 10 * (index + 1) as u16, areas[1].y + areas[1].height - 1,
//"┴", Style::default().not_bold().dim()
//);
//for y in areas[1].y+1..areas[1].y+areas[1].height - 1 {
//buffer.set_string(
//x + 10 * (index + 1) as u16, y,
//"│", Style::default().not_bold().gray().dim()
//);
//}
//for y in areas[1].y+2..areas[1].y+areas[1].height - 1 {
//buffer.set_string(
//x + 10 * index as u16 + 1, y,
//"--------", Style::default().not_bold().gray().dim()
//);
//}
//buffer.set_string(
//x + 10 * index as u16 + 1, areas[1].y + 1,
//track, Style::default().bold().not_dim()
//);
//}

69
src/device/looper.rs
View file

@ -1,58 +1,35 @@
use crate::prelude::*;
pub struct Looper {
exited: bool
name: String
}
impl Looper {
pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into(),
}))
}
}
pub fn render (state: &Looper, buf: &mut Buffer, area: Rect) {
//let move_to = |col, row| MoveTo(offset.0 + col, offset.1 + row);
//stdout
//.queue(move_to(0, 0))?.queue(Print(" Name Input Length Route"))?
//.queue(move_to(0, 1))?.queue(PrintStyledContent(" Metronome [ ] ████ Track 1".bold()))?
//.queue(move_to(0, 2))?.queue(PrintStyledContent(" Loop 1 [ ] ████ Track 1".bold()))?
//.queue(move_to(0, 3))?.queue(PrintStyledContent(" Loop 2 [ ] ████████ Track 2".bold()))?
//.queue(move_to(0, 4))?.queue(PrintStyledContent(" Loop 3 [ ] ████████ Track 3".bold()))?;
}
pub fn handle (state: &mut Looper, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
Ok(())
}
pub const ACTIONS: [(&'static str, &'static str);1] = [
("Ins/Del", "Add/remove loop"),
];
impl Looper {
pub fn new () -> Result<Self, Box<dyn Error>> {
Ok(Self { exited: false })
}
}
impl Exitable for Looper {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}
impl WidgetRef for Looper {
fn render_ref (&self, area: Rect, buf: &mut Buffer) {
}
}
pub fn render (
state: &mut Looper,
stdout: &mut std::io::Stdout,
mut offset: (u16, u16),
) -> Result<(), Box<dyn Error>> {
let move_to = |col, row| MoveTo(offset.0 + col, offset.1 + row);
stdout
.queue(move_to(0, 0))?.queue(Print(" Name Input Length Route"))?
.queue(move_to(0, 1))?.queue(PrintStyledContent(" Metronome [ ] ████ Track 1".bold()))?
.queue(move_to(0, 2))?.queue(PrintStyledContent(" Loop 1 [ ] ████ Track 1".bold()))?
.queue(move_to(0, 3))?.queue(PrintStyledContent(" Loop 2 [ ] ████████ Track 2".bold()))?
.queue(move_to(0, 4))?.queue(PrintStyledContent(" Loop 3 [ ] ████████ Track 3".bold()))?;
Ok(())
}
impl HandleInput for Looper {
fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
handle(self, event)
}
}
pub fn handle (state: &mut Looper, event: &Event) -> Result<(), Box<dyn Error>> {
Ok(())
}
pub struct Notifications;
impl NotificationHandler for Notifications {

270
src/device/mixer.rs
View file

@ -1,45 +1,17 @@
use crate::prelude::*;
// TODO:
// - Meters: propagate clipping:
// - If one stage clips, all stages after it are marked red
// - If one track clips, all tracks that feed from it are marked red?
pub const ACTIONS: [(&'static str, &'static str);2] = [
("+/-", "Adjust"),
("Ins/Del", "Add/remove track"),
];
pub struct Mixer {
exited: bool,
name: String,
jack: Jack<Notifications>,
tracks: Vec<Track>,
selected_track: usize,
selected_column: usize,
}
pub struct Track {
name: String,
channels: u8,
input_ports: Vec<Port<AudioIn>>,
pre_gain_meter: f64,
gain: f64,
insert_ports: Vec<Port<AudioOut>>,
return_ports: Vec<Port<AudioIn>>,
post_gain_meter: f64,
post_insert_meter: f64,
level: f64,
pan: f64,
output_ports: Vec<Port<AudioOut>>,
post_fader_meter: f64,
route: String,
}
impl Mixer {
pub fn new () -> Result<Self, Box<dyn Error>> {
pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
let (client, status) = Client::new(
"bloop-mixer",
name,
ClientOptions::NO_START_SERVER
)?;
let jack = client.activate_async(
@ -50,8 +22,8 @@ impl Mixer {
}) as Box<dyn FnMut(&Client, &ProcessScope)->Control + Send>
)
)?;
Ok(Self {
exited: false,
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into(),
selected_column: 0,
selected_track: 1,
tracks: vec![
@ -65,129 +37,74 @@ impl Mixer {
Track::new(&jack.as_client(), 2, "Mix")?,
],
jack,
})
}
}
impl Track {
pub fn new (jack: &Client, channels: u8, name: &str) -> Result<Self, Box<dyn Error>> {
let mut input_ports = vec![];
let mut insert_ports = vec![];
let mut return_ports = vec![];
let mut output_ports = vec![];
for channel in 1..=channels {
input_ports.push(jack.register_port(&format!("{name} [input {channel}]"), AudioIn::default())?);
output_ports.push(jack.register_port(&format!("{name} [out {channel}]"), AudioOut::default())?);
let insert_port = jack.register_port(&format!("{name} [pre {channel}]"), AudioOut::default())?;
let return_port = jack.register_port(&format!("{name} [insert {channel}]"), AudioIn::default())?;
jack.connect_ports(&insert_port, &return_port)?;
insert_ports.push(insert_port);
return_ports.push(return_port);
}
Ok(Self {
name: name.into(),
channels,
input_ports,
pre_gain_meter: 0.0,
gain: 0.0,
post_gain_meter: 0.0,
insert_ports,
return_ports,
post_insert_meter: 0.0,
level: 0.0,
pan: 0.0,
post_fader_meter: 0.0,
route: "---".into(),
output_ports,
})
}))
}
}
impl Exitable for Mixer {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}
impl WidgetRef for Mixer {
fn render_ref (&self, area: Rect, buf: &mut Buffer) {
use ratatui::style::Stylize;
draw_box(buf, area);
let x = area.x + 1;
let y = area.y + 1;
let h = area.height - 2;
for (i, track) in self.tracks.iter().enumerate() {
//buf.set_string(
//x, y + index as u16,
//&track.name, Style::default().bold().not_dim()
//);
for (j, (column, field)) in [
(0, format!(" {:7} ", track.name)),
(12, format!(" {:.1}dB ", track.gain)),
(22, format!(" [ ] ")),
(30, format!(" C ")),
(35, format!(" {:.1}dB ", track.level)),
(45, format!(" [ ] ")),
(51, format!(" {:7} ", track.route)),
].into_iter().enumerate() {
buf.set_string(
x + column as u16,
y + i as u16,
field,
if self.selected_track == i && self.selected_column == j {
Style::default().white().bold().not_dim()
} else {
Style::default().not_dim()
}
);
//stdout.queue(move_to(column, row))?;
//if state.selected_track == i && state.selected_column == j {
//stdout.queue(PrintStyledContent(field.to_string().bold().reverse()))?;
//} else {
//stdout.queue(PrintStyledContent(field.to_string().bold()))?;
pub fn render (state: &Mixer, buf: &mut Buffer, area: Rect) {
draw_box(buf, area);
let x = area.x + 1;
let y = area.y + 1;
let h = area.height - 2;
for (i, track) in state.tracks.iter().enumerate() {
//buf.set_string(
//x, y + index as u16,
//&track.name, Style::default().bold().not_dim()
//);
for (j, (column, field)) in [
(0, format!(" {:7} ", track.name)),
(12, format!(" {:.1}dB ", track.gain)),
(22, format!(" [ ] ")),
(30, format!(" C ")),
(35, format!(" {:.1}dB ", track.level)),
(45, format!(" [ ] ")),
(51, format!(" {:7} ", track.route)),
].into_iter().enumerate() {
buf.set_string(
x + column as u16,
y + i as u16,
field,
if state.selected_track == i && state.selected_column == j {
Style::default().white().bold().not_dim()
} else {
Style::default().not_dim()
}
);
//stdout.queue(move_to(column, row))?;
//if state.selected_track == i && state.selected_column == j {
//stdout.queue(PrintStyledContent(field.to_string().bold().reverse()))?;
//} else {
//stdout.queue(PrintStyledContent(field.to_string().bold()))?;
//}
//fn render_meters (
//state: &mut Mixer,
//stdout: &mut Stdout,
//offset: (u16, u16)
//) -> Result<(), Box<dyn Error>> {
//let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
//for (i, track) in state.tracks.iter().enumerate() {
//let row = (i + 1) as u16;
//stdout
//.queue(move_to(10, row))?.queue(PrintStyledContent("▁".green()))?
//.queue(move_to(20, row))?.queue(PrintStyledContent("▁".green()))?
//.queue(move_to(28, row))?.queue(PrintStyledContent("▁".green()))?
//.queue(move_to(43, row))?.queue(PrintStyledContent("▁".green()))?;
//}
//fn render_meters (
//state: &mut Mixer,
//stdout: &mut Stdout,
//offset: (u16, u16)
//) -> Result<(), Box<dyn Error>> {
//let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
//for (i, track) in state.tracks.iter().enumerate() {
//let row = (i + 1) as u16;
//stdout
//.queue(move_to(10, row))?.queue(PrintStyledContent("▁".green()))?
//.queue(move_to(20, row))?.queue(PrintStyledContent("▁".green()))?
//.queue(move_to(28, row))?.queue(PrintStyledContent("▁".green()))?
//.queue(move_to(43, row))?.queue(PrintStyledContent("▁".green()))?;
//}
//Ok(())
//}
}
//Ok(())
//}
}
}
}
impl HandleInput for Mixer {
fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
handle(self, event)
}
}
pub fn handle (state: &mut Mixer, event: &Event) -> Result<(), Box<dyn Error>> {
if let Event::Input(crossterm::event::Event::Key(event)) = event {
pub fn handle (state: &mut Mixer, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
if let EngineEvent::Input(crossterm::event::Event::Key(event)) = event {
match event.code {
KeyCode::Char('c') => {
if event.modifiers == KeyModifiers::CONTROL {
state.exit();
}
},
//KeyCode::Char('c') => {
//if event.modifiers == KeyModifiers::CONTROL {
//state.exit();
//}
//},
KeyCode::Down => {
state.selected_track = (state.selected_track + 1) % state.tracks.len();
println!("{}", state.selected_track);
@ -224,6 +141,67 @@ pub fn handle (state: &mut Mixer, event: &Event) -> Result<(), Box<dyn Error>> {
Ok(())
}
// TODO:
// - Meters: propagate clipping:
// - If one stage clips, all stages after it are marked red
// - If one track clips, all tracks that feed from it are marked red?
pub const ACTIONS: [(&'static str, &'static str);2] = [
("+/-", "Adjust"),
("Ins/Del", "Add/remove track"),
];
pub struct Track {
name: String,
channels: u8,
input_ports: Vec<Port<AudioIn>>,
pre_gain_meter: f64,
gain: f64,
insert_ports: Vec<Port<AudioOut>>,
return_ports: Vec<Port<AudioIn>>,
post_gain_meter: f64,
post_insert_meter: f64,
level: f64,
pan: f64,
output_ports: Vec<Port<AudioOut>>,
post_fader_meter: f64,
route: String,
}
impl Track {
pub fn new (jack: &Client, channels: u8, name: &str) -> Result<Self, Box<dyn Error>> {
let mut input_ports = vec![];
let mut insert_ports = vec![];
let mut return_ports = vec![];
let mut output_ports = vec![];
for channel in 1..=channels {
input_ports.push(jack.register_port(&format!("{name} [input {channel}]"), AudioIn::default())?);
output_ports.push(jack.register_port(&format!("{name} [out {channel}]"), AudioOut::default())?);
let insert_port = jack.register_port(&format!("{name} [pre {channel}]"), AudioOut::default())?;
let return_port = jack.register_port(&format!("{name} [insert {channel}]"), AudioIn::default())?;
jack.connect_ports(&insert_port, &return_port)?;
insert_ports.push(insert_port);
return_ports.push(return_port);
}
Ok(Self {
name: name.into(),
channels,
input_ports,
pre_gain_meter: 0.0,
gain: 0.0,
post_gain_meter: 0.0,
insert_ports,
return_ports,
post_insert_meter: 0.0,
level: 0.0,
pan: 0.0,
post_fader_meter: 0.0,
route: "---".into(),
output_ports,
})
}
}
pub struct Notifications;
impl NotificationHandler for Notifications {

0
src/device/lv2_host.rs → src/device/patch.rs
View file

19
src/device/plugin.rs Normal file
View file

@ -0,0 +1,19 @@
use crate::prelude::*;
pub struct Plugin {
name: String
}
impl Plugin {
pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into()
}))
}
}
pub fn render (state: &Plugin, buf: &mut Buffer, area: Rect) {}
pub fn handle (state: &mut Plugin, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
Ok(())
}

0
src/device/port_list.rs
View file

221
src/device/sampler.rs
View file

@ -6,20 +6,17 @@ pub const ACTIONS: [(&'static str, &'static str);2] = [
];
pub struct Sampler {
exited: Arc<AtomicBool>,
jack: Jack<Notifications>,
name: String,
jack: Jack<self::Notifications>,
samples: Arc<Mutex<Vec<Sample>>>,
selected_sample: usize,
selected_column: usize,
}
impl Sampler {
pub fn new () -> Result<Self, Box<dyn Error>> {
pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
let exited = Arc::new(AtomicBool::new(false));
let (client, status) = Client::new(
"Sampler#000",
ClientOptions::NO_START_SERVER
)?;
let (client, status) = Client::new(name, ClientOptions::NO_START_SERVER)?;
let samples = vec![
Sample::new("Kick", &client, 1, 35)?,
Sample::new("Snare", &client, 1, 38)?,
@ -64,8 +61,8 @@ impl Sampler {
Control::Continue
})
});
Ok(Self {
exited,
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into(),
selected_sample: 0,
selected_column: 0,
samples,
@ -73,7 +70,7 @@ impl Sampler {
self::Notifications,
ClosureProcessHandler::new(handler)
)?,
})
}))
}
}
@ -109,131 +106,97 @@ impl Sample {
}
impl Exitable for Sampler {
fn exit (&mut self) {
self.exited.store(true, Ordering::Relaxed)
}
fn exited (&self) -> bool {
self.exited.fetch_and(true, Ordering::Relaxed)
}
pub fn render (state: &Sampler, buf: &mut Buffer, area: Rect) {
//render_table(state, stdout, offset)?;
//render_meters(state, stdout, offset)?;
}
impl WidgetRef for Sampler {
fn render_ref (&self, area: Rect, buf: &mut Buffer) {
}
}
//fn render_table (
//state: &mut Sampler,
//stdout: &mut Stdout,
//offset: (u16, u16),
//) -> Result<(), Box<dyn Error>> {
//let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
//stdout.queue(move_to(0, 3))?.queue(
//Print(" Name Rate Trigger Route")
//)?;
//for (i, sample) in state.samples.lock().unwrap().iter().enumerate() {
//let row = 4 + i as u16;
//for (j, (column, field)) in [
//(0, format!(" {:7} ", sample.name)),
//(9, format!(" {:.1}Hz ", sample.rate)),
//(18, format!(" MIDI C{} {} ", sample.trigger.0, sample.trigger.1)),
//(33, format!(" {:.1}dB -> Output ", sample.gain)),
//(50, format!(" {} ", sample.playing.unwrap_or(0))),
//].into_iter().enumerate() {
//stdout.queue(move_to(column, row))?;
//if state.selected_sample == i && state.selected_column == j {
//stdout.queue(PrintStyledContent(field.to_string().bold().reverse()))?;
//} else {
//stdout.queue(PrintStyledContent(field.to_string().bold()))?;
//}
//}
//}
//Ok(())
//}
pub fn render (
state: &mut Sampler,
stdout: &mut Stdout,
offset: (u16, u16),
) -> Result<(), Box<dyn Error>> {
render_table(state, stdout, offset)?;
render_meters(state, stdout, offset)?;
//fn render_meters (
//state: &mut Sampler,
//stdout: &mut Stdout,
//offset: (u16, u16),
//) -> Result<(), Box<dyn Error>> {
//let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
//for (i, sample) in state.samples.lock().iter().enumerate() {
//let row = 4 + i as u16;
//stdout.queue(move_to(32, row))?.queue(
//PrintStyledContent("▁".green())
//)?;
//}
//Ok(())
//}
pub fn handle (state: &mut Sampler, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
//if let Event::Input(crossterm::event::Event::Key(event)) = event {
//match event.code {
//KeyCode::Char('c') => {
//if event.modifiers == KeyModifiers::CONTROL {
//state.exit();
//}
//},
//KeyCode::Down => {
//state.selected_sample = (state.selected_sample + 1) % state.samples.lock().unwrap().len();
//println!("{}", state.selected_sample);
//},
//KeyCode::Up => {
//if state.selected_sample == 0 {
//state.selected_sample = state.samples.lock().unwrap().len() - 1;
//} else {
//state.selected_sample = state.selected_sample - 1;
//}
//println!("{}", state.selected_sample);
//},
//KeyCode::Left => {
//if state.selected_column == 0 {
//state.selected_column = 6
//} else {
//state.selected_column = state.selected_column - 1;
//}
//},
//KeyCode::Right => {
//if state.selected_column == 6 {
//state.selected_column = 0
//} else {
//state.selected_column = state.selected_column + 1;
//}
//},
//_ => {
//println!("{event:?}");
//}
//}
//}
Ok(())
}
fn render_table (
state: &mut Sampler,
stdout: &mut Stdout,
offset: (u16, u16),
) -> Result<(), Box<dyn Error>> {
let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
stdout.queue(move_to(0, 3))?.queue(
Print(" Name Rate Trigger Route")
)?;
for (i, sample) in state.samples.lock().unwrap().iter().enumerate() {
let row = 4 + i as u16;
for (j, (column, field)) in [
(0, format!(" {:7} ", sample.name)),
(9, format!(" {:.1}Hz ", sample.rate)),
(18, format!(" MIDI C{} {} ", sample.trigger.0, sample.trigger.1)),
(33, format!(" {:.1}dB -> Output ", sample.gain)),
(50, format!(" {} ", sample.playing.unwrap_or(0))),
].into_iter().enumerate() {
stdout.queue(move_to(column, row))?;
if state.selected_sample == i && state.selected_column == j {
stdout.queue(PrintStyledContent(field.to_string().bold().reverse()))?;
} else {
stdout.queue(PrintStyledContent(field.to_string().bold()))?;
}
}
}
Ok(())
}
fn render_meters (
state: &mut Sampler,
stdout: &mut Stdout,
offset: (u16, u16),
) -> Result<(), Box<dyn Error>> {
let move_to = |col, row| crossterm::cursor::MoveTo(offset.0 + col, offset.1 + row);
for (i, sample) in state.samples.lock().iter().enumerate() {
let row = 4 + i as u16;
stdout.queue(move_to(32, row))?.queue(
PrintStyledContent("▁".green())
)?;
}
Ok(())
}
impl HandleInput for Sampler {
fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
handle(self, event)
}
}
pub fn handle (
state: &mut Sampler,
event: &Event
) -> Result<(), Box<dyn Error>> {
if let Event::Input(crossterm::event::Event::Key(event)) = event {
match event.code {
KeyCode::Char('c') => {
if event.modifiers == KeyModifiers::CONTROL {
state.exit();
}
},
KeyCode::Down => {
state.selected_sample = (state.selected_sample + 1) % state.samples.lock().unwrap().len();
println!("{}", state.selected_sample);
},
KeyCode::Up => {
if state.selected_sample == 0 {
state.selected_sample = state.samples.lock().unwrap().len() - 1;
} else {
state.selected_sample = state.selected_sample - 1;
}
println!("{}", state.selected_sample);
},
KeyCode::Left => {
if state.selected_column == 0 {
state.selected_column = 6
} else {
state.selected_column = state.selected_column - 1;
}
},
KeyCode::Right => {
if state.selected_column == 6 {
state.selected_column = 0
} else {
state.selected_column = state.selected_column + 1;
}
},
_ => {
println!("{event:?}");
}
}
}
Ok(())
}
pub struct Notifications;
impl NotificationHandler for Notifications {

166
src/device/sequencer.rs
View file

@ -1,44 +1,23 @@
use crate::prelude::*;
use ratatui::style::Stylize;
mod midi;
pub use midi::*;
pub const ACTIONS: [(&'static str, &'static str);4] = [
("+/-", "Zoom"),
("A/D", "Add/delete note"),
("]/[", "Duration"),
("CapsLock", "Auto advance"),
];
pub struct Sequencer {
name: Arc<str>,
exited: Arc<AtomicBool>,
playing: Arc<AtomicBool>,
recording: Arc<AtomicBool>,
overdub: Arc<AtomicBool>,
inputs_open: Arc<AtomicBool>,
outputs_open: Arc<AtomicBool>,
cursor: (u16, u16, u16),
timesig: (f32, f32),
pub jack_client: Jack<Notifications>,
sequence: Arc<Mutex<Vec<Vec<Option<Event>>>>>,
sequences: Arc<Mutex<Vec<MIDISequence>>>,
}
#[derive(Clone)]
pub enum Event {
NoteOn(u8, u8),
NoteOff(u8)
name: String,
playing: Arc<AtomicBool>,
recording: Arc<AtomicBool>,
overdub: Arc<AtomicBool>,
inputs_open: Arc<AtomicBool>,
outputs_open: Arc<AtomicBool>,
cursor: (u16, u16, u16),
timesig: (f32, f32),
pub jack_client: Jack<self::Notifications>,
sequence: Arc<Mutex<Vec<Vec<Option<SequencerEvent>>>>>,
sequences: Arc<Mutex<Vec<MIDISequence>>>,
}
impl Sequencer {
pub fn new (
name: Option<&str>,
connect_inputs: Option<&[String]>,
connect_outputs: Option<&[String]>,
) -> Result<Self, Box<dyn Error>> {
pub fn new (name: &str) -> Result<DynamicDevice<Self>, Box<dyn Error>> {
let beats = 4;
let steps = 16;
let bpm = 120.0;
@ -52,7 +31,6 @@ impl Sequencer {
let playing = Arc::new(AtomicBool::new(true));
let recording = Arc::new(AtomicBool::new(true));
let overdub = Arc::new(AtomicBool::new(false));
let name = name.unwrap_or("sequencer");
let (client, _status) = Client::new(
name, ClientOptions::NO_START_SERVER
)?;
@ -62,7 +40,7 @@ impl Sequencer {
let mut output = client.register_port(
"output", ::jack::MidiOut::default()
)?;
let sequence: Arc<Mutex<Vec<Vec<Option<Event>>>>> = Arc::new(
let sequence: Arc<Mutex<Vec<Vec<Option<SequencerEvent>>>>> = Arc::new(
Mutex::new(vec![vec![None;64];128])
);
let mut step_frames = vec![];
@ -75,9 +53,8 @@ impl Sequencer {
for (index, frame) in step_frames.iter().enumerate() {
frame_steps[*frame] = Some(index);
}
Ok(Self {
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: name.into(),
exited: exited.clone(),
playing: playing.clone(),
recording: recording.clone(),
overdub: overdub.clone(),
@ -88,7 +65,7 @@ impl Sequencer {
])),
cursor: (11, 0, 0),
timesig: (4.0, 4.0),
jack_client: crate::engine::activate_jack_client(
jack_client: crate::device::activate_jack_client(
client,
Notifications,
Box::new(move |client: &Client, scope: &ProcessScope| -> Control {
@ -123,12 +100,12 @@ impl Sequencer {
writer.write(&::jack::RawMidi {
time: frame as u32,
bytes: &match event {
Event::NoteOn(pitch, velocity) => [
SequencerEvent::NoteOn(pitch, velocity) => [
0b10010000,
*pitch,
*velocity
],
Event::NoteOff(pitch) => [
SequencerEvent::NoteOff(pitch) => [
0b10000000,
*pitch,
0b00000000
@ -144,29 +121,21 @@ impl Sequencer {
Control::Continue
})
)?
})
}))
}
}
impl Exitable for Sequencer {
fn exit (&mut self) {
self.exited.store(true, Ordering::Relaxed)
}
fn exited (&self) -> bool {
self.exited.fetch_and(true, Ordering::Relaxed)
}
}
pub const ACTIONS: [(&'static str, &'static str);4] = [
("+/-", "Zoom"),
("A/D", "Add/delete note"),
("]/[", "Duration"),
("CapsLock", "Auto advance"),
];
impl HandleInput for Sequencer {
fn handle (&mut self, event: &crate::engine::Event) -> Result<(), Box<dyn Error>> {
handle(self, event)
}
}
pub fn handle (state: &mut Sequencer, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
fn handle (state: &mut Sequencer, event: &crate::engine::Event) -> Result<(), Box<dyn Error>> {
if let crate::engine::Event::Input(crossterm::event::Event::Key(event)) = event {
if let EngineEvent::Input(Event::Key(event)) = event {
match event.code {
KeyCode::Down => {
state.cursor.0 = if state.cursor.0 >= 23 {
@ -215,9 +184,9 @@ fn handle (state: &mut Sequencer, event: &crate::engine::Event) -> Result<(), Bo
let step = state.cursor.1 as usize;
let duration = state.cursor.2 as usize;
let mut sequence = state.sequence.lock().unwrap();
sequence[row][step] = Some(self::Event::NoteOn(48 - row as u8, 128));
sequence[row][step] = Some(SequencerEvent::NoteOn(48 - row as u8, 128));
if state.cursor.2 > 0 {
sequence[row][step + duration] = Some(self::Event::NoteOff(35));
sequence[row][step + duration] = Some(SequencerEvent::NoteOff(35));
}
},
_ => {
@ -236,13 +205,7 @@ const KEYS_VERTICAL: [&'static str; 6] = [
"▀", "▀", "▀", "█", "▄", "▄",
];
impl WidgetRef for Sequencer {
fn render_ref (&self, mut area: Rect, buf: &mut Buffer) {
draw_sequencer(self, buf, area)
}
}
fn draw_sequencer (sequencer: &Sequencer, buf: &mut Buffer, mut area: Rect) {
fn render (sequencer: &Sequencer, buf: &mut Buffer, mut area: Rect) {
area.height = 18;
//draw_box(buf, area);
let Rect { x, y, width, height } = area;
@ -289,12 +252,12 @@ fn draw_sequencer (sequencer: &Sequencer, buf: &mut Buffer, mut area: Rect) {
//buf.set_string(x + 1, y + 5,
//&format!(" {} │ IN │ ⏺ REC │ ⏺ DUB │ ▶ PLAY │ ⏹ STOP │ OUT │ 00:00.00 / 00:00.00", &sequencer.name),
//Style::default().gray());
if sequencer.inputs_open.fetch_and(true, Ordering::Relaxed) {
buf.set_string(x + 15, y + 1, "IN", Style::default().green().bold());
}
if sequencer.outputs_open.fetch_and(true, Ordering::Relaxed) {
buf.set_string(x + 54, y + 1, "OUT", Style::default().green().bold());
}
//if sequencer.inputs_open.fetch_and(true, Ordering::Relaxed) {
//buf.set_string(x + 15, y + 1, "IN", Style::default().green().bold());
//}
//if sequencer.outputs_open.fetch_and(true, Ordering::Relaxed) {
//buf.set_string(x + 54, y + 1, "OUT", Style::default().green().bold());
//}
let mut command = |y2: u16, c: &str, ommand: &str, value: &str| {
buf.set_string(x + 1, y + y2, c, Style::default().bold());
@ -542,6 +505,65 @@ impl NotificationHandler for Notifications {
}
}
pub struct MIDISequence {
channels: [MIDISequenceChannel;16],
}
pub struct MIDISequenceChannel {
number: u8,
notes: [MIDISequenceVoice;128],
}
pub type MIDISequenceVoice = std::collections::BTreeMap<u32, NoteEvent>;
#[derive(Clone)]
pub enum NoteEvent {
On(u8),
Off(u8),
}
const VOICE_EMPTY: MIDISequenceVoice = MIDISequenceVoice::new();
impl MIDISequence {
fn new () -> Self {
Self {
channels: [
MIDISequenceChannel::new(1),
MIDISequenceChannel::new(2),
MIDISequenceChannel::new(3),
MIDISequenceChannel::new(4),
MIDISequenceChannel::new(5),
MIDISequenceChannel::new(6),
MIDISequenceChannel::new(7),
MIDISequenceChannel::new(8),
MIDISequenceChannel::new(9),
MIDISequenceChannel::new(10),
MIDISequenceChannel::new(11),
MIDISequenceChannel::new(12),
MIDISequenceChannel::new(13),
MIDISequenceChannel::new(14),
MIDISequenceChannel::new(15),
MIDISequenceChannel::new(16),
]
}
}
}
impl MIDISequenceChannel {
fn new (number: u8) -> Self {
Self {
number,
notes: [VOICE_EMPTY;128]
}
}
}
#[derive(Clone)]
pub enum SequencerEvent {
NoteOn(u8, u8),
NoteOff(u8)
}
#[cfg(test)]
mod test {
#[test]

52
src/device/sequencer/midi.rs
View file

@ -1,52 +0,0 @@
pub struct MIDISequence {
channels: [MIDISequenceChannel;16],
}
pub struct MIDISequenceChannel {
number: u8,
notes: [MIDISequenceVoice;128],
}
pub type MIDISequenceVoice = std::collections::BTreeMap<u32, NoteEvent>;
#[derive(Clone)]
pub enum NoteEvent {
On(u8),
Off(u8),
}
const VOICE_EMPTY: MIDISequenceVoice = MIDISequenceVoice::new();
impl MIDISequence {
fn new () -> Self {
Self {
channels: [
MIDISequenceChannel::new(1),
MIDISequenceChannel::new(2),
MIDISequenceChannel::new(3),
MIDISequenceChannel::new(4),
MIDISequenceChannel::new(5),
MIDISequenceChannel::new(6),
MIDISequenceChannel::new(7),
MIDISequenceChannel::new(8),
MIDISequenceChannel::new(9),
MIDISequenceChannel::new(10),
MIDISequenceChannel::new(11),
MIDISequenceChannel::new(12),
MIDISequenceChannel::new(13),
MIDISequenceChannel::new(14),
MIDISequenceChannel::new(15),
MIDISequenceChannel::new(16),
]
}
}
}
impl MIDISequenceChannel {
fn new (number: u8) -> Self {
Self {
number,
notes: [VOICE_EMPTY;128]
}
}
}

162
src/device/transport.rs
View file

@ -1,37 +1,32 @@
use crate::prelude::*;
pub const ACTIONS: [(&'static str, &'static str);4] = [
("?", "Toggle help"),
("(Shift-)Tab", "Switch pane"),
("Arrows", "Navigate"),
("(Shift-)Space", "⯈ Play/pause"),
];
pub struct Transport {
exited: bool,
title: String,
transport: ::jack::Transport,
name: String,
transport: Option<::jack::Transport>,
bpm: f64,
timesig: (f32, f32),
devices: Vec<Box<dyn Device>>,
}
impl Transport {
pub fn new (client: &Client) -> Result<Self, Box<dyn Error>> {
let transport = client.transport();
Ok(Self {
exited: false,
title: String::from("Untitled project"),
pub fn new (devices: Vec<Box<dyn Device>>)
-> Result<DynamicDevice<Self>, Box<dyn Error>>
{
//let transport = client.transport();
Ok(DynamicDevice::new(render, handle, |_|{}, Self {
name: "Transport".into(),
bpm: 113.0,
timesig: (4.0, 4.0),
transport,
})
transport: None,
devices
}))
}
pub fn play_from_start_or_stop_and_rewind (&mut self) {
}
pub fn play_or_pause (&mut self) -> Result<(), Box<dyn Error>> {
match self.transport.query_state()? {
match self.transport.as_ref().unwrap().query_state()? {
TransportState::Stopped => self.play(),
TransportState::Rolling => self.stop(),
_ => Ok(())
@ -39,41 +34,27 @@ impl Transport {
}
pub fn play (&mut self) -> Result<(), Box<dyn Error>> {
Ok(self.transport.start()?)
Ok(self.transport.as_ref().unwrap().start()?)
}
pub fn stop (&mut self) -> Result<(), Box<dyn Error>> {
Ok(self.transport.stop()?)
Ok(self.transport.as_ref().unwrap().stop()?)
}
}
impl Exitable for Transport {
fn exit (&mut self) {
self.exited = true
}
fn exited (&self) -> bool {
self.exited
}
}
impl WidgetRef for Transport {
fn render_ref (&self, area: Rect, buf: &mut Buffer) {
use ratatui::{layout::*, widgets::*, style::Stylize};
draw_leaf(buf, area, 0, 0, "REC");
draw_leaf(buf, area, 0, 5, "DUB");
draw_leaf(buf, area, 0, 10, "STOP");
draw_leaf(buf, area, 0, 16, "PLAY/PAUSE");
draw_leaf(buf, area, 0, 28, "START");
draw_leaf(buf, area, 0, 35, "Project: Witty Gerbil - Sha Na Na ");
let position = self.transport.query().expect("failed to query transport");
draw_leaf(buf, area, 2, 0, &format!("BPM {:03}.{:03}",
self.bpm as u64,
((self.bpm % 1.0) * 1000.0) as u64
));
//let bbt = position.pos.bbt().map(|mut bbt|*bbt
//.with_bpm(self.bpm)
//.with_timesig(self.timesig.0, self.timesig.1));
//.unwrap();
pub fn render (state: &Transport, buf: &mut Buffer, area: Rect) {
draw_leaf(buf, area, 0, 0, "REC");
draw_leaf(buf, area, 0, 5, "DUB");
draw_leaf(buf, area, 0, 10, "STOP");
draw_leaf(buf, area, 0, 16, "PLAY/PAUSE");
draw_leaf(buf, area, 0, 28, "START");
draw_leaf(buf, area, 0, 35, "Project: Witty Gerbil - Sha Na Na ");
draw_leaf(buf, area, 2, 0, &format!("BPM {:03}.{:03}",
state.bpm as u64,
((state.bpm % 1.0) * 1000.0) as u64
));
let position = state.transport.as_ref().map(|t|t.query());
if let Some(Ok(position)) = position {
let rate = position.pos.frame_rate().unwrap();
let frame = position.pos.frame();
let second = (frame as f64) / (rate as f64);
@ -105,42 +86,46 @@ impl WidgetRef for Transport {
));
draw_leaf(buf, area, 2, 48, &format!("Rate {:>6}Hz", rate));
draw_leaf(buf, area, 2, 63, &format!("Frame {:>10}", frame));
//Line::from("Project:").render(area, buf);
//if let Ok(position) = self.transport.query() {
//let frame = position.pos.frame();
//let rate = position.pos.frame_rate();
//let bbt = position.pos.bbt().map(|mut bbt|*bbt
//.with_bpm(self.bpm)
//.with_timesig(self.timesig.0, self.timesig.1));
//Line::from("Frame:").render(area.clone().offset(Offset { x: 0, y: 1 }), buf);
//Line::from(format!("{frame}")).render(area.clone().offset(Offset { x: 0, y: 2 }), buf);
//Line::from("Rate:").render(area.clone().offset(Offset { x: 10, y: 1 }), buf);
//Line::from(match rate {
//Some(rate) => format!("{rate}Hz"),
//None => String::from("(none)"),
//}).render(area.clone().offset(Offset { x: 10, y: 2 }), buf);
//Line::from("Time:").render(area.clone().offset(Offset { x: 20, y: 1 }), buf);
//Line::from(match rate {
//Some(rate) => format!("{:.03}", frame as f64 / rate as f64),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 20, y: 2 }), buf);
//Line::from("BPM:").render(area.clone().offset(Offset { x: 30, y: 1 }), buf);
//Line::from(match bbt {
//Some(bbt) => format!("{:.01}", bbt.bpm),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 30, y: 2 }), buf);
//Line::from("TimeSig:").render(area.clone().offset(Offset { x: 40, y: 1 }), buf);
//Line::from(match bbt {
//Some(bbt) => format!("{}/{}", bbt.sig_num, bbt.sig_denom),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 40, y: 2 }), buf);
//Line::from("Beat:").render(area.clone().offset(Offset { x: 50, y: 1 }), buf);
//Line::from(match bbt {
//Some(bbt) => format!("{}.{}.{}", bbt.bar, bbt.beat, bbt.tick),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 50, y: 2 }), buf);
//}
}
//let bbt = position.pos.bbt().map(|mut bbt|*bbt
//.with_bpm(state.bpm)
//.with_timesig(state.timesig.0, state.timesig.1));
//.unwrap();
//Line::from("Project:").render(area, buf);
//if let Ok(position) = state.transport.query() {
//let frame = position.pos.frame();
//let rate = position.pos.frame_rate();
//let bbt = position.pos.bbt().map(|mut bbt|*bbt
//.with_bpm(state.bpm)
//.with_timesig(state.timesig.0, state.timesig.1));
//Line::from("Frame:").render(area.clone().offset(Offset { x: 0, y: 1 }), buf);
//Line::from(format!("{frame}")).render(area.clone().offset(Offset { x: 0, y: 2 }), buf);
//Line::from("Rate:").render(area.clone().offset(Offset { x: 10, y: 1 }), buf);
//Line::from(match rate {
//Some(rate) => format!("{rate}Hz"),
//None => String::from("(none)"),
//}).render(area.clone().offset(Offset { x: 10, y: 2 }), buf);
//Line::from("Time:").render(area.clone().offset(Offset { x: 20, y: 1 }), buf);
//Line::from(match rate {
//Some(rate) => format!("{:.03}", frame as f64 / rate as f64),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 20, y: 2 }), buf);
//Line::from("BPM:").render(area.clone().offset(Offset { x: 30, y: 1 }), buf);
//Line::from(match bbt {
//Some(bbt) => format!("{:.01}", bbt.bpm),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 30, y: 2 }), buf);
//Line::from("TimeSig:").render(area.clone().offset(Offset { x: 40, y: 1 }), buf);
//Line::from(match bbt {
//Some(bbt) => format!("{}/{}", bbt.sig_num, bbt.sig_denom),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 40, y: 2 }), buf);
//Line::from("Beat:").render(area.clone().offset(Offset { x: 50, y: 1 }), buf);
//Line::from(match bbt {
//Some(bbt) => format!("{}.{}.{}", bbt.bar, bbt.beat, bbt.tick),
//None => String::from("(none)")
//}).render(area.clone().offset(Offset { x: 50, y: 2 }), buf);
//}
}
//pub fn render (
@ -206,12 +191,17 @@ impl WidgetRef for Transport {
//Ok(())
//}
impl HandleInput for self::Transport {
fn handle (&mut self, event: &Event) -> Result<(), Box<dyn Error>> {
Ok(())
}
pub fn handle (state: &mut Transport, event: &EngineEvent) -> Result<(), Box<dyn Error>> {
Ok(())
}
pub const ACTIONS: [(&'static str, &'static str);4] = [
("?", "Toggle help"),
("(Shift-)Tab", "Switch pane"),
("Arrows", "Navigate"),
("(Shift-)Space", "⯈ Play/pause"),
];
struct Notifications;
impl NotificationHandler for Notifications {