midi-cli 0.1.0__py3-none-any.whl

midi_cli/app.py

@@ -0,0 +1,179 @@
+import os
+import select
+import sys
+import termios
+import threading
+import tty
+
+import sounddevice as sd
+
+import midi_cli.state as st
+from midi_cli.audio import audio_callback
+from midi_cli.sampler import load_samples, load_pitch_offsets, save_sample, adjust_pitch, compute_chromatic_samples_async, execute_copy, stop_recording
+from midi_cli.midi import open_midi_input, trigger_keyboard_note, midi_callback
+from midi_cli.ui import draw_ui, reset_trim_state, reset_copy_state
+from midi_cli.loop import reset_loop_state, cycle_loop_state
+
+
+def main():
+    from midi_cli.config import run_setup_wizard
+    cfg = run_setup_wizard()
+    st.input_device = cfg.get("input_device")
+    st.output_device = cfg.get("output_device")
+    st.midi_port = cfg.get("midi_port")
+    sys.stdout.write("\033[2J\033[H")
+    sys.stdout.flush()
+
+    midi_in, port_name = open_midi_input(st.midi_port)
+    if midi_in is None:
+        st.keyboard_mock_mode = True
+    else:
+        st.ui_midi_port = port_name
+
+    load_samples()
+    load_pitch_offsets()
+
+    stream = sd.OutputStream(
+        samplerate=st.SAMPLE_RATE,
+        blocksize=st.BLOCK_SIZE,
+        channels=1,
+        callback=audio_callback,
+        device=st.output_device,
+    )
+    stream.start()
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    sys.stdout.write(st.HIDE_CURSOR)
+    sys.stdout.flush()
+
+    try:
+        tty.setraw(fd)
+        initialized = False
+        while True:
+            draw_ui(initialized)
+            initialized = True
+
+            ready, _, _ = select.select([fd], [], [], 0.05)
+            if ready:
+                ch = os.read(fd, 1).decode("utf-8", errors="replace")
+                if ch in ("q", "\x03"):  # q or Ctrl+C
+                    break
+                elif ch == "\r" and st.mode == "trim" and st.trim_selected_note is not None:
+                    if st.trim_step == 0:
+                        # Confirm start, advance to end adjustment
+                        st.trim_step = 1
+                        st.trim_loop_pos = st.trim_start
+                    else:
+                        # Confirm end, slice and save
+                        audio = st.samples[st.trim_selected_note][st.trim_start:st.trim_end]
+                        note = st.trim_selected_note
+                        save_sample(note, audio)
+                        # Recompute chromatic if this was the root
+                        if st.chromatic_root_note == note:
+                            compute_chromatic_samples_async(note)
+                        reset_trim_state()
+                elif ch == "\r" and st.mode == "copy" and st.copy_confirm_pending:
+                    execute_copy()
+                elif ch == "\t":  # Tab: next mode
+                    if st.mode == "record":
+                        st.keyboard_recording_notes.clear()
+                        if st.recording_note is not None:
+                            threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
+                    if st.mode == "trim":
+                        reset_trim_state()
+                    if st.mode == "copy":
+                        reset_copy_state()
+                    if st.mode == "loop":
+                        with st.voices_lock:
+                            reset_loop_state()
+                    st.mode = st.MODES[(st.MODES.index(st.mode) + 1) % len(st.MODES)]
+                    if st.mode == "chromatic":
+                        st.chromatic_selecting = st.chromatic_root_note is None
+                elif ch == "r" and st.mode == "chromatic" and not st.chromatic_selecting:
+                    st.chromatic_selecting = True
+                elif ch == "\x1b":  # escape sequence
+                    # Use select on fd with timeout to distinguish bare Escape from sequences
+                    esc_ready, _, _ = select.select([fd], [], [], 0.02)
+                    if not esc_ready:
+                        # Bare Escape
+                        if st.mode == "trim" and st.trim_selected_note is not None:
+                            reset_trim_state()
+                        elif st.mode == "copy" and (st.copy_source_note is not None or st.copy_confirm_pending):
+                            reset_copy_state()
+                        elif st.mode == "loop":
+                            with st.voices_lock:
+                                reset_loop_state()
+                    else:
+                        seq = os.read(fd, 2).decode("utf-8", errors="replace")
+                        if seq == "[Z":  # Shift+Tab: previous mode
+                            if st.mode == "record":
+                                st.keyboard_recording_notes.clear()
+                                if st.recording_note is not None:
+                                    threading.Thread(target=stop_recording, args=(st.recording_note,), daemon=True).start()
+                            if st.mode == "trim":
+                                reset_trim_state()
+                            if st.mode == "copy":
+                                reset_copy_state()
+                            if st.mode == "loop":
+                                with st.voices_lock:
+                                    reset_loop_state()
+                            st.mode = st.MODES[(st.MODES.index(st.mode) - 1) % len(st.MODES)]
+                            if st.mode == "chromatic":
+                                st.chromatic_selecting = st.chromatic_root_note is None
+                        elif st.mode == "trim" and st.trim_selected_note is not None:
+                            sample_len = len(st.samples[st.trim_selected_note])
+                            fine = max(1, sample_len // 1000)    # 0.1%
+                            coarse = max(1, sample_len // 100)   # 1%
+                            if st.trim_step == 0:
+                                if seq == "[D":    # Left: decrease start
+                                    st.trim_start = max(0, st.trim_start - fine)
+                                elif seq == "[C":  # Right: increase start
+                                    st.trim_start = min(st.trim_end - st.MIN_TRIM_SAMPLES, st.trim_start + fine)
+                                elif seq == "[B":  # Down: decrease start (coarse)
+                                    st.trim_start = max(0, st.trim_start - coarse)
+                                elif seq == "[A":  # Up: increase start (coarse)
+                                    st.trim_start = min(st.trim_end - st.MIN_TRIM_SAMPLES, st.trim_start + coarse)
+                            else:
+                                if seq == "[D":    # Left: decrease end
+                                    st.trim_end = max(st.trim_start + st.MIN_TRIM_SAMPLES, st.trim_end - fine)
+                                elif seq == "[C":  # Right: increase end
+                                    st.trim_end = min(sample_len, st.trim_end + fine)
+                                elif seq == "[B":  # Down: decrease end (coarse)
+                                    st.trim_end = max(st.trim_start + st.MIN_TRIM_SAMPLES, st.trim_end - coarse)
+                                elif seq == "[A":  # Up: increase end (coarse)
+                                    st.trim_end = min(sample_len, st.trim_end + coarse)
+                            st.trim_start = max(0, st.trim_start)
+                            st.trim_end = max(st.trim_start + st.MIN_TRIM_SAMPLES, st.trim_end)
+                        elif st.mode == "pitch" and st.pitch_selected_note is not None:
+                            if seq == "[A":    # Up: +1 semitone
+                                adjust_pitch(st.pitch_selected_note, 1, 0)
+                            elif seq == "[B":  # Down: -1 semitone
+                                adjust_pitch(st.pitch_selected_note, -1, 0)
+                            elif seq == "[C":  # Right: +10 cents
+                                adjust_pitch(st.pitch_selected_note, 0, st.CENTS_STEP)
+                            elif seq == "[D":  # Left: -10 cents
+                                adjust_pitch(st.pitch_selected_note, 0, -st.CENTS_STEP)
+                elif ch == 'l' and st.mode == "loop":
+                    with st.voices_lock:
+                        cycle_loop_state()
+                elif st.keyboard_mock_mode and ch in st.KEYBOARD_NOTE_MAP:
+                    trigger_keyboard_note(st.KEYBOARD_NOTE_MAP[ch])
+                elif st.keyboard_mock_mode and ch == '`':
+                    new_val = 0 if st.sustain else 127
+                    midi_callback(([0xB0, 64, new_val], 0), None)
+    except (KeyboardInterrupt, EOFError):
+        pass
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+        sys.stdout.write(st.SHOW_CURSOR)
+        sys.stdout.flush()
+        stream.stop()
+        stream.close()
+        if midi_in is not None:
+            midi_in.close_port()
+            midi_in.delete()
+
+
+if __name__ == "__main__":
+    main()

midi_cli/audio.py

@@ -0,0 +1,278 @@
+import numpy as np
+
+import midi_cli.state as st
+
+
+def build_synth_envelope(gain, releasing, faded_in, age, frames):
+    """Vectorized envelope: returns (gains_array, new_gain, new_age, new_faded_in)."""
+    idx = np.arange(frames)
+
+    if releasing:
+        gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (idx + 1))
+        new_gain = max(0.0, gain - st.FADE_OUT_STEP * frames)
+        return gains, new_gain, age, faded_in
+
+    if not faded_in:
+        # Fade-in with concurrent stage1 decay:
+        # Recurrence: g' = (g + FADE_IN_STEP) * STAGE1_DECAY
+        # We compute iteratively to find the clamp point, then switch to pure decay.
+        gains = np.empty(frames)
+        g = gain
+        clamp_idx = frames  # assume no clamp within block
+        for i in range(frames):
+            g = (g + st.FADE_IN_STEP) * st.STAGE1_DECAY
+            if g >= 1.0:
+                g = 1.0
+                clamp_idx = i
+                break
+            gains[i] = g
+
+        if clamp_idx < frames:
+            # Faded in at clamp_idx
+            gains[clamp_idx] = g
+            remaining = frames - clamp_idx - 1
+            if remaining > 0:
+                post_age = age + clamp_idx + 1
+                if post_age < st.STAGE1_SAMPLES:
+                    s1_left = st.STAGE1_SAMPLES - post_age
+                    if remaining <= s1_left:
+                        gains[clamp_idx + 1:] = g * st.STAGE1_DECAY ** (idx[:remaining] + 1)
+                    else:
+                        gains[clamp_idx + 1:clamp_idx + 1 + s1_left] = g * st.STAGE1_DECAY ** (idx[:s1_left] + 1)
+                        g_at_boundary = g * st.STAGE1_DECAY ** s1_left
+                        rest = remaining - s1_left
+                        gains[clamp_idx + 1 + s1_left:] = g_at_boundary * st.STAGE2_DECAY ** (idx[:rest] + 1)
+                else:
+                    gains[clamp_idx + 1:] = g * st.STAGE2_DECAY ** (idx[:remaining] + 1)
+            new_gain = gains[-1]
+            new_age = age + frames
+            return gains, new_gain, new_age, True
+        else:
+            # Still fading in at end of block
+            new_gain = g
+            new_age = age + frames
+            return gains, new_gain, new_age, False
+
+    # Already faded in — pure decay
+    if age >= st.STAGE1_SAMPLES:
+        # Pure stage2
+        gains = gain * st.STAGE2_DECAY ** (idx + 1)
+    elif age + frames <= st.STAGE1_SAMPLES:
+        # Pure stage1
+        gains = gain * st.STAGE1_DECAY ** (idx + 1)
+    else:
+        # Stage1 → stage2 boundary mid-block
+        s1_left = st.STAGE1_SAMPLES - age
+        gains = np.empty(frames)
+        gains[:s1_left] = gain * st.STAGE1_DECAY ** (idx[:s1_left] + 1)
+        g_at_boundary = gain * st.STAGE1_DECAY ** s1_left
+        s2_count = frames - s1_left
+        gains[s1_left:] = g_at_boundary * st.STAGE2_DECAY ** (idx[:s2_count] + 1)
+
+    new_gain = gains[-1]
+    new_age = age + frames
+    return gains, new_gain, new_age, faded_in
+
+
+def audio_callback(outdata, frames, time_info, status):
+    with st.voices_lock:
+        if st.mode == "trim" and st.trim_looping and st.trim_selected_note is not None:
+            sample_data = st.samples.get(st.trim_selected_note)
+            if sample_data is None or st.trim_end <= st.trim_start:
+                outdata[:] = 0
+                return
+            # Bounds-check loop pos
+            region_len = st.trim_end - st.trim_start
+            cycle_len = max(region_len, st.MIN_LOOP_PERIOD)
+            if st.trim_loop_pos < 0 or st.trim_loop_pos >= cycle_len:
+                st.trim_loop_pos = 0
+            mix = np.zeros(frames)
+            written = 0
+            while written < frames:
+                if st.trim_loop_pos < region_len:
+                    # Playing audio portion
+                    src_pos = st.trim_start + st.trim_loop_pos
+                    avail = region_len - st.trim_loop_pos
+                    n = min(frames - written, avail)
+                    mix[written:written + n] = sample_data[src_pos:src_pos + n]
+                    st.trim_loop_pos += n
+                    written += n
+                else:
+                    # Silence padding portion
+                    avail = cycle_len - st.trim_loop_pos
+                    n = min(frames - written, avail)
+                    # mix is already zeros
+                    st.trim_loop_pos += n
+                    written += n
+                if st.trim_loop_pos >= cycle_len:
+                    st.trim_loop_pos = 0
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
+        if st.mode == "loop":
+            mix = np.zeros(frames)
+
+            # Sample voice mixing (same logic as sample mode)
+            finished = []
+            for note, sv in st.sample_voices.items():
+                if note not in st.samples:
+                    finished.append(note)
+                    continue
+                pos = sv["pos"]
+                gain = sv["gain"]
+                releasing = sv["releasing"]
+                sample_data = st.samples[note]
+                remaining = len(sample_data) - pos
+                n = min(frames, remaining)
+                if n <= 0:
+                    finished.append(note)
+                    continue
+                buf = np.zeros(frames)
+                buf[:n] = sample_data[pos:pos + n] * gain
+                if releasing:
+                    fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
+                    buf[:n] *= fade_gains
+                    gain = max(0.0, gain - st.FADE_OUT_STEP * n)
+                else:
+                    gain = min(1.0, gain + st.FADE_IN_STEP * n)
+                mix += buf
+                sv["pos"] = pos + n
+                sv["gain"] = gain
+                if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
+                    finished.append(note)
+            for note in finished:
+                del st.sample_voices[note]
+
+            # Loop capture/playback
+            if st.loop_state == "recording":
+                st.loop_record_chunks.append(mix.copy())
+            elif st.loop_state in ("playing", "overdub") and st.loop_buffer is not None:
+                buf = st.loop_buffer
+                buf_len = len(buf)
+                loop_chunk = np.zeros(frames)
+                written = 0
+                pos = st.loop_pos
+                while written < frames:
+                    avail = buf_len - pos
+                    take = min(avail, frames - written)
+                    loop_chunk[written:written + take] = buf[pos:pos + take]
+                    if st.loop_state == "overdub":
+                        buf[pos:pos + take] += mix[written:written + take]
+                        np.clip(buf[pos:pos + take], -1.0, 1.0, out=buf[pos:pos + take])
+                    written += take
+                    pos = (pos + take) % buf_len
+                mix += loop_chunk
+                st.loop_pos = (st.loop_pos + frames) % buf_len
+
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
+        if st.mode in ("sample", "pitch", "chromatic", "trim"):
+            if not st.sample_voices:
+                outdata[:] = 0
+                return
+
+            mix = np.zeros(frames)
+            finished = []
+
+            for note, sv in st.sample_voices.items():
+                if st.mode == "chromatic":
+                    sample_data = st.chromatic_samples.get(note)
+                    if sample_data is None:
+                        finished.append(note)
+                        continue
+                else:
+                    if note not in st.samples:
+                        finished.append(note)
+                        continue
+                    ps = st.pitched_samples.get(note)
+                    sample_data = ps if ps is not None else st.samples.get(note)
+                pos = sv["pos"]
+                gain = sv["gain"]
+                releasing = sv["releasing"]
+
+                remaining = len(sample_data) - pos
+                n = min(frames, remaining)
+                if n <= 0:
+                    finished.append(note)
+                    continue
+
+                buf = np.zeros(frames)
+                buf[:n] = sample_data[pos:pos + n] * gain
+
+                if releasing:
+                    fade_gains = np.maximum(0.0, gain - st.FADE_OUT_STEP * (np.arange(n) + 1))
+                    buf[:n] *= fade_gains
+                    gain = max(0.0, gain - st.FADE_OUT_STEP * n)
+                else:
+                    gain = min(1.0, gain + st.FADE_IN_STEP * n)
+
+                mix += buf
+                sv["pos"] = pos + n
+                sv["gain"] = gain
+                if (releasing and gain <= 0.0) or pos + n >= len(sample_data):
+                    finished.append(note)
+
+            for note in finished:
+                del st.sample_voices[note]
+
+            mix *= 0.25
+            np.clip(mix, -1.0, 1.0, out=mix)
+            outdata[:, 0] = mix
+            return
+
+        # Synth mode
+        if not st.voices:
+            outdata[:] = 0
+            return
+
+        mix = np.zeros(frames)
+        finished = []
+
+        for note, v in st.voices.items():
+            freq = st.note_to_freq(note)
+            phase = v["phase"]
+            gain = v["gain"]
+            releasing = v["releasing"]
+            age = v["age"]
+            faded_in = v["faded_in"]
+
+            phase_step = 2.0 * np.pi * freq / st.SAMPLE_RATE
+            phases = phase + np.arange(frames) * phase_step
+            phase_matrix = phases[:, None] * st.H_MULTIPLIERS[None, :]
+            raw_signal = np.sin(phase_matrix) @ st.HARMONICS
+            gains, gain, age, faded_in = build_synth_envelope(gain, releasing, faded_in, age, frames)
+            buf = raw_signal * gains
+            phase = phases[-1] + phase_step
+
+            mix += buf
+            v["phase"] = phase % (2.0 * np.pi)
+            v["gain"] = gain
+            v["age"] = age
+            v["faded_in"] = faded_in
+            if (releasing and gain == 0.0) or gain < st.SILENCE_THRESHOLD:
+                finished.append(note)
+
+        for note in finished:
+            del st.voices[note]
+
+        mix *= 0.25  # fixed headroom (up to ~4 voices at full level)
+        np.clip(mix, -1.0, 1.0, out=mix)
+        outdata[:, 0] = mix
+
+
+def trim_silence(audio, threshold_db=-20):
+    """Trim leading and trailing silence from an audio array."""
+    threshold = 10 ** (threshold_db / 20.0)  # convert dB to linear
+    above = np.abs(audio) > threshold
+    if not np.any(above):
+        return audio  # all silence, return as-is
+    indices = np.where(above)[0]
+    pad = int(0.05 * st.SAMPLE_RATE)  # 50ms pad
+    start = max(indices[0] - pad, 0)
+    end = min(indices[-1] + 1 + pad, len(audio))
+    return audio[start:end]

midi_cli/config.py

@@ -0,0 +1,133 @@
+import json
+import os
+
+import rtmidi
+import sounddevice as sd
+
+
+CONFIG_PATH = "config.json"
+
+
+def load_config():
+    """Read config.json; return empty dict if missing."""
+    if not os.path.isfile(CONFIG_PATH):
+        return {}
+    with open(CONFIG_PATH, "r") as f:
+        return json.load(f)
+
+
+def save_config(cfg):
+    """Write config.json."""
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(cfg, f, indent=2)
+
+
+def _get_input_devices():
+    """Return input device names with the system default first."""
+    devs = sd.query_devices()
+    names = [d["name"] for d in devs if d["max_input_channels"] > 0]
+    try:
+        idx = sd.default.device[0]
+        if idx >= 0:
+            default_name = devs[idx]["name"]
+            if default_name in names:
+                names.remove(default_name)
+                names.insert(0, default_name)
+    except Exception:
+        pass
+    return names
+
+
+def _get_output_devices():
+    """Return output device names with the system default first."""
+    devs = sd.query_devices()
+    names = [d["name"] for d in devs if d["max_output_channels"] > 0]
+    try:
+        idx = sd.default.device[1]
+        if idx >= 0:
+            default_name = devs[idx]["name"]
+            if default_name in names:
+                names.remove(default_name)
+                names.insert(0, default_name)
+    except Exception:
+        pass
+    return names
+
+
+def _prompt_device(label, names):
+    """Prompt user to pick from a numbered list; Enter accepts the first."""
+    print(f"\n{label}:")
+    for i, name in enumerate(names):
+        suffix = " (default)" if i == 0 else ""
+        print(f"  {i + 1}. {name}{suffix}")
+    while True:
+        try:
+            raw = input("Select [1]: ").strip()
+        except EOFError:
+            return names[0]
+        if raw == "":
+            return names[0]
+        try:
+            idx = int(raw) - 1
+            if 0 <= idx < len(names):
+                return names[idx]
+        except ValueError:
+            pass
+        print(f"  Please enter 1\u2013{len(names)}.")
+
+
+def run_setup_wizard():
+    """
+    Detect audio/MIDI devices, prompt only when there is ambiguity (>1 option)
+    or when a saved device has disappeared. Returns config dict.
+    """
+    cfg = load_config()
+    changed = False
+
+    # --- Audio input ---
+    input_names = _get_input_devices()
+    saved = cfg.get("input_device")
+    if "input_device" in cfg and saved is not None and saved not in input_names:
+        print(f"Warning: saved input device '{saved}' not found.")
+        del cfg["input_device"]
+        changed = True
+    # Re-prompt if previously defaulted but new devices have appeared
+    if "input_device" in cfg and cfg["input_device"] is None and len(input_names) > 1:
+        del cfg["input_device"]
+        changed = True
+    if "input_device" not in cfg:
+        changed = True
+        cfg["input_device"] = _prompt_device("Input device", input_names) if len(input_names) > 1 else None
+
+    # --- Audio output ---
+    output_names = _get_output_devices()
+    saved = cfg.get("output_device")
+    if "output_device" in cfg and saved is not None and saved not in output_names:
+        print(f"Warning: saved output device '{saved}' not found.")
+        del cfg["output_device"]
+        changed = True
+    # Re-prompt if previously defaulted but new devices have appeared
+    if "output_device" in cfg and cfg["output_device"] is None and len(output_names) > 1:
+        del cfg["output_device"]
+        changed = True
+    if "output_device" not in cfg:
+        changed = True
+        cfg["output_device"] = _prompt_device("Output device", output_names) if len(output_names) > 1 else None
+
+    # --- MIDI ---
+    _tmp = rtmidi.MidiIn()
+    midi_ports = _tmp.get_ports()
+    _tmp.delete()
+    saved = cfg.get("midi_port")
+    if "midi_port" in cfg and saved is not None and saved not in midi_ports:
+        print(f"Warning: saved MIDI port '{saved}' not found.")
+        del cfg["midi_port"]
+        changed = True
+    if "midi_port" not in cfg:
+        changed = True
+        cfg["midi_port"] = _prompt_device("MIDI input port", midi_ports) if len(midi_ports) > 1 else None
+
+    if changed:
+        save_config(cfg)
+
+    return cfg

midi_cli/loop.py

@@ -0,0 +1,30 @@
+import numpy as np
+
+import midi_cli.state as st
+
+
+def reset_loop_state():
+    """Clear loop buffer and return to idle. Must be called with voices_lock held."""
+    st.loop_state = "idle"
+    st.loop_buffer = None
+    st.loop_pos = 0
+    st.loop_record_chunks = []
+
+
+def cycle_loop_state():
+    """Advance the loop state machine. Must be called with voices_lock held."""
+    if st.loop_state == "idle":
+        st.loop_record_chunks = []
+        st.loop_state = "recording"
+    elif st.loop_state == "recording":
+        if st.loop_record_chunks:
+            st.loop_buffer = np.concatenate(st.loop_record_chunks)
+        else:
+            st.loop_buffer = None
+        st.loop_record_chunks = []
+        st.loop_pos = 0
+        st.loop_state = "playing"
+    elif st.loop_state == "playing":
+        st.loop_state = "overdub"
+    elif st.loop_state == "overdub":
+        st.loop_state = "playing"