tek/cli/src/main.rs

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();
}