remodularize 3

cli/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "tek_cli"
+edition = "2021"
+version = "0.2.0"
+
+[dependencies]
+tek = { path = ".." }
+clap = { version = "4.5.4", features = [ "derive" ] }

cli/src/main.rs

@@ -0,0 +1,282 @@
+use tek::*;
+#[allow(unused_imports)] use clap::{self, Parser, Subcommand, ValueEnum};
+
+#[derive(Debug, Parser)]
+#[command(version, about, long_about = None)]
+pub struct TekCli {
+    /// Which app to initialize
+    #[command(subcommand)] mode: TekMode,
+    /// Name of JACK client
+    #[arg(short='t', long)] name: Option<String>,
+    /// Whether to attempt to become transport master
+    #[arg(short='S', long, default_value_t = false)] sync_lead: bool,
+    /// Whether to sync to external transport master
+    #[arg(short='s', long, default_value_t = true)] sync_follow: bool,
+    /// Initial tempo in beats per minute
+    #[arg(short='b', long, default_value = None)] bpm: Option<f64>,
+}
+
+#[derive(Debug, Clone, Subcommand)]
+pub enum TekMode {
+    /// A standalone transport view.
+    Clock,
+    /// A MIDI sequencer.
+    Sequencer {
+        /// Whether to include a transport toolbar (default: true)
+        #[arg(short='t', long, default_value_t = true)] show_clock: bool,
+        /// MIDI outs to connect to (multiple instances accepted)
+        #[arg(short='i', long)] midi_from: Vec<String>,
+        /// MIDI ins to connect to (multiple instances accepted)
+        #[arg(short='o', long)] midi_to: Vec<String>,
+    },
+    /// A MIDI-controlled audio sampler.
+    Sampler {
+        /// MIDI outs to connect to (multiple instances accepted)
+        #[arg(short='i', long)] midi_from: Vec<String>,
+        /// Audio outs to connect to left input
+        #[arg(short='l', long)] l_from: Vec<String>,
+        /// Audio outs to connect to right input
+        #[arg(short='r', long)] r_from: Vec<String>,
+        /// Audio ins to connect from left output
+        #[arg(short='L', long)] l_to: Vec<String>,
+        /// Audio ins to connect from right output
+        #[arg(short='R', long)] r_to: Vec<String>,
+    },
+    /// Sequencer and sampler together.
+    Groovebox {
+        /// Whether to include a transport toolbar (default: true)
+        #[arg(short='t', long, default_value_t = true)] show_clock: bool,
+        /// MIDI outs to connect to (multiple instances accepted)
+        #[arg(short='i', long)] midi_from: Vec<String>,
+        /// MIDI ins to connect to (multiple instances accepted)
+        #[arg(short='o', long)] midi_to: Vec<String>,
+        /// Audio outs to connect to left input
+        #[arg(short='l', long)] l_from: Vec<String>,
+        /// Audio outs to connect to right input
+        #[arg(short='r', long)] r_from: Vec<String>,
+        /// Audio ins to connect from left output
+        #[arg(short='L', long)] l_to: Vec<String>,
+        /// Audio ins to connect from right output
+        #[arg(short='R', long)] r_to: Vec<String>,
+    },
+    /// Multi-track MIDI sequencer.
+    Arranger {
+        /// Whether to include a transport toolbar (default: true)
+        #[arg(short='t', long, default_value_t = true)] show_clock: bool,
+        /// MIDI outs to connect to (multiple instances accepted)
+        #[arg(short='i', long)] midi_from: Vec<String>,
+        /// MIDI ins to connect to (multiple instances accepted)
+        #[arg(short='o', long)] midi_to: Vec<String>,
+        /// Audio outs to connect to left input
+        #[arg(short='l', long)] l_from: Vec<String>,
+        /// Audio outs to connect to right input
+        #[arg(short='r', long)] r_from: Vec<String>,
+        /// Audio ins to connect from left output
+        #[arg(short='L', long)] l_to: Vec<String>,
+        /// Audio ins to connect from right output
+        #[arg(short='R', long)] r_to: Vec<String>,
+        /// Number of tracks
+        #[arg(short = 'x', long, default_value_t = 16)] tracks: usize,
+        /// Width of tracks
+        #[arg(short = 'w', long, default_value_t = 6)] track_width: usize,
+        /// Number of scenes
+        #[arg(short = 'y', long, default_value_t = 8)] scenes: usize,
+    },
+    /// TODO: A MIDI-controlled audio mixer
+    Mixer,
+    /// TODO: A customizable channel strip
+    Track,
+    /// TODO: An audio plugin host
+    Plugin,
+}
+
+/// Application entrypoint.
+pub fn main () -> Usually<()> {
+    use TekMode::*;
+    let cli    = TekCli::parse();
+    let name   = cli.name.as_ref().map_or("tek", |x|x.as_str());
+    let jack   = JackConnection::new(name)?;
+    let engine = Tui::new()?;
+    Ok(match cli.mode {
+
+        Clock => engine.run(&jack.activate_with(|jack|Ok(crate::TransportTui {
+            clock: crate::Clock::from(jack),
+            jack:  jack.clone()
+        }))?)?,
+
+        Sequencer {
+            midi_from,
+            midi_to, ..
+        } => engine.run(&jack.activate_with(|jack|Ok({
+            let clock = crate::Clock::from(jack);
+            let phrase = Arc::new(RwLock::new(crate::MidiClip::new(
+                "Clip", true, 4 * clock.timebase.ppq.get() as usize,
+                None, Some(ItemColor::random().into())
+            )));
+            let midi_in  = jack.read().unwrap().register_port("i", MidiIn::default())?;
+            connect_from(&jack, &midi_in, &midi_from)?;
+            let midi_out = jack.read().unwrap().register_port("o", MidiOut::default())?;
+            connect_to(&jack, &midi_out, &midi_to)?;
+            crate::Sequencer {
+                _jack:     jack.clone(),
+                pool:      PoolModel::from(&phrase),
+                editor:    crate::MidiEditor::from(&phrase),
+                player:    crate::MidiPlayer::new(&clock, &phrase, &[midi_in], &[midi_out])?,
+                compact:   true,
+                transport: true,
+                selectors: true,
+                size:      Measure::new(),
+                midi_buf:  vec![vec![];65536],
+                note_buf:  vec![],
+                perf:      PerfModel::default(),
+                status:    true,
+                clock,
+            }
+        }))?)?,
+
+        Sampler {
+            midi_from, l_from, r_from, l_to, r_to, ..
+        } => engine.run(&jack.activate_with(|jack|Ok(
+            tek::SamplerTui {
+                cursor:  (0, 0),
+                editing: None,
+                mode:    None,
+                size:    Measure::new(),
+                note_lo: 36.into(),
+                note_pt: 36.into(),
+                color:   ItemPalette::from(Color::Rgb(64, 128, 32)),
+                state:   tek::Sampler::new(jack, &"sampler",
+                    &midi_from,
+                    &[&l_from, &r_from],
+                    &[&l_to, &r_to],
+                )?,
+            }
+        ))?)?,
+
+        Groovebox {
+            midi_from, midi_to, l_from, r_from, l_to, r_to, ..
+        } => engine.run(&jack.activate_with(|jack|Ok({
+            let phrase = Arc::new(RwLock::new(MidiClip::new(
+                "Clip", true, 4 * player.clock.timebase.ppq.get() as usize,
+                None, Some(ItemColor::random().into())
+            )));
+            let mut player = crate::midi::MidiPlayer::new(jack, &"sequencer", Some(&phrase),
+                &midi_from,
+                &midi_to
+            )?;
+            player.play_phrase = Some((Moment::zero(&player.clock.timebase), Some(phrase.clone())));
+            let sampler = crate::sampler::Sampler::new(jack, &"sampler",
+                midi_from,
+                &[l_from, r_from],
+                &[l_to,   r_to  ],
+            )?;
+            jack.read().unwrap().client().connect_ports(
+                &player.midi_outs[0],
+                &sampler.midi_in
+            )?;
+            let app = tek::Groovebox {
+                player,
+                sampler,
+                _jack:    jack.clone(),
+
+                pool:     PoolModel::from(&phrase),
+                editor:   MidiEditor::from(&phrase),
+
+                compact:  true,
+                status:   true,
+                size:     Measure::new(),
+                midi_buf: vec![vec![];65536],
+                note_buf: vec![],
+                perf:     PerfModel::default(),
+            };
+
+            let app = tek::Groovebox::new(
+                jack,
+                &midi_from, &midi_to,
+                &[&l_from, &r_from],
+                &[&l_to,   &r_to],
+            )?;
+            if let Some(bpm) = cli.bpm {
+                app.clock().timebase.bpm.set(bpm);
+            }
+            if cli.sync_lead {
+                jack.read().unwrap().client().register_timebase_callback(false, |mut state|{
+                    app.clock().playhead.update_from_sample(state.position.frame() as f64);
+                    state.position.bbt = Some(app.clock().bbt());
+                    state.position
+                })?
+            } else if cli.sync_follow {
+                jack.read().unwrap().client().register_timebase_callback(false, |state|{
+                    app.clock().playhead.update_from_sample(state.position.frame() as f64);
+                    state.position
+                })?
+            }
+            app
+        }))?)?,
+
+        Arranger {
+            scenes, tracks, track_width, midi_from, midi_to, ..
+        } => engine.run(&jack.activate_with(|jack|Ok({
+            let mut app = crate::Arranger::new(jack);
+            app.tracks_add(tracks, track_width, midi_from.as_slice(), midi_to.as_slice())?;
+            app.scenes_add(scenes)?;
+            app
+        }))?)?,
+
+        _ => todo!()
+    })
+}
+
+#[allow(unused)]
+fn connect_from (jack: &JackConnection, input: &Port<MidiIn>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(port, input)?;
+        } else {
+            panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+#[allow(unused)]
+fn connect_to (jack: &JackConnection, output: &Port<MidiOut>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(output, port)?;
+        } else {
+            panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+#[allow(unused)]
+fn connect_audio_from (jack: &JackConnection, input: &Port<AudioIn>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(port, input)?;
+        } else {
+            panic!("Missing MIDI output: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+#[allow(unused)]
+fn connect_audio_to (jack: &JackConnection, output: &Port<AudioOut>, ports: &[String]) -> Usually<()> {
+    for port in ports.iter() {
+        if let Some(port) = jack.port_by_name(port).as_ref() {
+            jack.client().connect_ports(output, port)?;
+        } else {
+            panic!("Missing MIDI input: {port}. Use jack_lsp to list all port names.");
+        }
+    }
+    Ok(())
+}
+
+
+#[test] fn verify_cli () {
+    use clap::CommandFactory;
+    TekCli::command().debug_assert();
+}

cli/src/todo_cli_mixer.rs

@@ -0,0 +1,25 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    MixerCli::parse().run()
+}
+
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct MixerCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Number of tracks
+    #[arg(short, long)] channels: Option<usize>,
+}
+
+impl MixerCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackConnection::new("tek_mixer")?.activate_with(|jack|{
+            let mut mixer = Mixer::new(jack, self.name.as_ref().map(|x|x.as_str()).unwrap_or("mixer"))?;
+            for channel in 0..self.channels.unwrap_or(8) {
+                mixer.track_add(&format!("Track {}", channel + 1), 1)?;
+            }
+            Ok(mixer)
+        })?)?;
+        Ok(())
+    }
+}

cli/src/todo_cli_plugin.rs

@@ -0,0 +1,26 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    PluginCli::parse().run()
+}
+
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct PluginCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Path to plugin
+    #[arg(short, long)] path: Option<String>,
+}
+
+impl PluginCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackConnection::new("tek_plugin")?.activate_with(|jack|{
+            let mut plugin = Plugin::new_lv2(
+                jack,
+                self.name.as_ref().map(|x|x.as_str()).unwrap_or("mixer"),
+                self.path.as_ref().expect("pass --path /to/lv2/plugin.so")
+            )?;
+            Ok(plugin)
+        })?)?;
+        Ok(())
+    }
+}

cli/src/todo_cli_sampler.rs

@@ -0,0 +1,26 @@
+include!("./lib.rs");
+
+pub fn main () -> Usually<()> {
+    SamplerCli::parse().run()
+}
+
+#[derive(Debug, Parser)] #[command(version, about, long_about = None)] pub struct SamplerCli {
+    /// Name of JACK client
+    #[arg(short, long)] name: Option<String>,
+    /// Path to plugin
+    #[arg(short, long)] path: Option<String>,
+}
+
+impl SamplerCli {
+    fn run (&self) -> Usually<()> {
+        Tui::run(JackConnection::new("tek_sampler")?.activate_with(|jack|{
+            let mut plugin = Sampler::new(
+                jack,
+                self.name.as_ref().map(|x|x.as_str()).unwrap_or("mixer"),
+                None,
+            )?;
+            Ok(plugin)
+        })?)?;
+        Ok(())
+    }
+}