midi-cli 0.1.0__py3-none-any.whl

midi_cli/midi.py

@@ -0,0 +1,154 @@
+import threading
+
+import rtmidi
+
+import midi_cli.state as st
+from midi_cli.sampler import start_recording, stop_recording, compute_chromatic_samples_async, execute_copy
+from midi_cli.loop import cycle_loop_state
+
+
+def midi_callback(event, data):
+    message, delta_time = event
+    if len(message) < 3:
+        return
+
+    status, note, velocity = message[0], message[1], message[2]
+    msg_type = status & 0xF0
+
+    if msg_type == 0x90 and velocity > 0:
+        if st.mode == "record":
+            threading.Thread(target=start_recording, args=(note,), daemon=True).start()
+            return
+
+        if st.mode == "trim":
+            if st.trim_selected_note is None and note in st.samples:
+                st.trim_selected_note = note
+                st.trim_step = 0
+                st.trim_start = 0
+                st.trim_end = len(st.samples[note])
+                st.trim_loop_pos = 0
+                st.trim_looping = True
+            return
+
+        if st.mode == "copy":
+            if st.copy_confirm_pending:
+                return
+            if st.copy_source_note is None:
+                if note in st.samples:
+                    st.copy_source_note = note
+                return
+            else:
+                st.copy_dest_note = note
+                if note in st.samples:
+                    st.copy_confirm_pending = True
+                else:
+                    execute_copy()
+                return
+
+        st.ui_active_note = st.midi_note_name(note)
+        if st.mode == "pitch":
+            with st.voices_lock:
+                if note in st.samples:
+                    st.sample_voices[note] = {"pos": 0, "releasing": False, "gain": 1.0}
+                    st.pitch_selected_note = note
+            return
+        if st.mode == "chromatic":
+            if st.chromatic_selecting:
+                if note in st.samples:
+                    st.chromatic_root_note = note
+                    with st.voices_lock:
+                        st.sample_voices.clear()
+                    st.chromatic_selecting = False
+                    compute_chromatic_samples_async(note)
+            else:
+                with st.voices_lock:
+                    if note in st.chromatic_samples:
+                        st.sample_voices[note] = {"pos": 0, "releasing": False, "gain": 1.0}
+            return
+        with st.voices_lock:
+            if st.mode in ("sample", "loop"):
+                if note in st.samples:
+                    st.sample_voices[note] = {"pos": 0, "releasing": False, "gain": 1.0}
+            else:
+                st.voices[note] = {"phase": 0.0, "gain": 0.0, "releasing": False, "age": 0, "faded_in": False}
+                st.sustained_notes.discard(note)
+    elif msg_type == 0x80 or (msg_type == 0x90 and velocity == 0):
+        if st.mode == "record":
+            threading.Thread(target=stop_recording, args=(note,), daemon=True).start()
+            return
+        if st.mode in ("trim", "copy"):
+            return
+        # Only clear if this note is still the active one
+        note_name = st.midi_note_name(note)
+        if st.ui_active_note == note_name:
+            st.ui_active_note = None
+        with st.voices_lock:
+            if st.mode in ("sample", "pitch", "chromatic"):
+                if note in st.sample_voices:
+                    st.sample_voices[note]["releasing"] = True
+            else:
+                if note in st.voices:
+                    if st.sustain:
+                        st.sustained_notes.add(note)
+                    else:
+                        st.voices[note]["releasing"] = True
+    elif msg_type == 0xB0 and note == 64:
+        pedal_on = velocity >= 64
+        st.ui_sustain = pedal_on
+        if pedal_on and st.mode == "loop":
+            with st.voices_lock:
+                cycle_loop_state()
+            return
+        with st.voices_lock:
+            st.sustain = pedal_on
+            if not pedal_on:
+                for n in st.sustained_notes:
+                    if n in st.voices:
+                        st.voices[n]["releasing"] = True
+                st.sustained_notes.clear()
+
+
+def trigger_keyboard_note(note):
+    if st.mode == "record":
+        if note in st.keyboard_recording_notes:
+            st.keyboard_recording_notes.discard(note)
+            threading.Thread(target=stop_recording, args=(note,), daemon=True).start()
+        else:
+            st.keyboard_recording_notes.add(note)
+            threading.Thread(target=start_recording, args=(note,), daemon=True).start()
+        return
+
+    old = st.keyboard_timers.pop(note, None)
+    if old:
+        old.cancel()
+    midi_callback(([0x90, note, 100], 0), None)
+    if st.mode in ("sample", "pitch", "chromatic", "trim", "copy", "loop"):
+        # Sample modes: one-shot, let the sample play to its natural end
+        return
+    if st.sustain:
+        midi_callback(([0x80, note, 0], 0), None)
+    else:
+        def note_off():
+            st.keyboard_timers.pop(note, None)
+            midi_callback(([0x80, note, 0], 0), None)
+        t = threading.Timer(st.KEYBOARD_NOTE_RELEASE_S, note_off)
+        t.daemon = True
+        st.keyboard_timers[note] = t
+        t.start()
+
+
+def open_midi_input(port_name=None):
+    midi_in = rtmidi.MidiIn()
+    ports = midi_in.get_ports()
+    if not ports:
+        midi_in.delete()
+        return None, ""
+    port_index = 0
+    if port_name is not None:
+        if port_name in ports:
+            port_index = ports.index(port_name)
+        else:
+            print(f"Warning: MIDI port '{port_name}' not found, using port 0.")
+    midi_in.open_port(port_index)
+    midi_in.set_callback(midi_callback)
+    return midi_in, ports[port_index]

midi_cli/sampler.py

@@ -0,0 +1,221 @@
+import json
+import os
+import threading
+import time
+import wave
+
+import numpy as np
+import pyrubberband as pyrb
+import sounddevice as sd
+
+import midi_cli.state as st
+from midi_cli.audio import trim_silence
+
+
+def load_pitch_offsets():
+    """Load pitch offsets from samples/pitch_offsets.json if it exists."""
+    path = os.path.join("samples", "pitch_offsets.json")
+    if not os.path.isfile(path):
+        return
+    with open(path, "r") as f:
+        raw = json.load(f)
+    st.pitch_offsets = {int(k): v for k, v in raw.items()}
+    for note, offset in st.pitch_offsets.items():
+        if note in st.samples:
+            recompute_pitched_sample(note)
+
+
+def save_pitch_offsets():
+    """Save pitch offsets to samples/pitch_offsets.json, pruning zero entries."""
+    to_save = {k: v for k, v in st.pitch_offsets.items()
+                if v["semitones"] != 0 or v["cents"] != 0}
+    os.makedirs("samples", exist_ok=True)
+    path = os.path.join("samples", "pitch_offsets.json")
+    with open(path, "w") as f:
+        json.dump(to_save, f, indent=2)
+
+
+def recompute_pitched_sample(note):
+    """Recompute the pitched version of a sample for the given note."""
+    offset = st.pitch_offsets.get(note)
+    if offset is None or (offset["semitones"] == 0 and offset["cents"] == 0):
+        with st.voices_lock:
+            st.pitched_samples.pop(note, None)
+        return
+    total_steps = offset["semitones"] + offset["cents"] / 100.0
+    result = pyrb.pitch_shift(st.samples[note], sr=st.SAMPLE_RATE, n_steps=total_steps)
+    with st.voices_lock:
+        st.pitched_samples[note] = result
+
+
+def recompute_pitched_sample_async(note):
+    """Recompute pitched sample in a background thread."""
+    threading.Thread(target=recompute_pitched_sample, args=(note,), daemon=True).start()
+
+
+def compute_chromatic_samples(root_note):
+    """Pre-compute pitched versions of the root sample across two octaves (one up, one down)."""
+    range_start = max(0, root_note - 12)
+    range_end = min(127, root_note + 12)
+    source = st.samples[root_note]
+    result = {}
+    for midi_note in range(range_start, range_end + 1):
+        offset = midi_note - root_note
+        if offset == 0:
+            result[midi_note] = source
+        else:
+            result[midi_note] = pyrb.pitch_shift(source, sr=st.SAMPLE_RATE, n_steps=offset)
+    with st.voices_lock:
+        st.chromatic_samples.clear()
+        st.chromatic_samples.update(result)
+    st.chromatic_computing = False
+
+
+def compute_chromatic_samples_async(root_note):
+    """Launch chromatic pre-computation in a background thread."""
+    st.chromatic_computing = True
+    threading.Thread(target=compute_chromatic_samples, args=(root_note,), daemon=True).start()
+
+
+def format_pitch_info(note, offset):
+    """Return a formatted string like 'C4  +3st +20c'."""
+    s = offset["semitones"]
+    c = offset["cents"]
+    s_str = f"+{s}st" if s >= 0 else f"{s}st"
+    c_str = f"+{c}c" if c >= 0 else f"{c}c"
+    return f"{st.midi_note_name(note):<4} {s_str} {c_str}"
+
+
+def adjust_pitch(note, semitones, cents):
+    """Adjust pitch offset for a note by the given semitone/cent deltas."""
+    if note not in st.pitch_offsets:
+        st.pitch_offsets[note] = {"semitones": 0, "cents": 0}
+    offset = st.pitch_offsets[note]
+    offset["semitones"] += semitones
+    offset["cents"] += cents
+    # Normalize cents overflow into semitones
+    while offset["cents"] >= 100:
+        offset["cents"] -= 100
+        offset["semitones"] += 1
+    while offset["cents"] <= -100:
+        offset["cents"] += 100
+        offset["semitones"] -= 1
+    save_pitch_offsets()
+    recompute_pitched_sample_async(note)
+
+
+def save_sample(note_number, audio):
+    """Store a sample in memory and save to disk as WAV."""
+    st.samples[note_number] = audio
+
+    os.makedirs("samples", exist_ok=True)
+    filepath = f"samples/note_{note_number}.wav"
+    with wave.open(filepath, "w") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)  # 16-bit
+        wf.setframerate(st.SAMPLE_RATE)
+        int_data = np.clip(audio * 32767, -32768, 32767).astype(np.int16)
+        wf.writeframes(int_data.tobytes())
+
+    if note_number in st.pitch_offsets:
+        recompute_pitched_sample_async(note_number)
+
+
+def execute_copy():
+    """Copy sample and pitch offset from source to destination."""
+    src = st.copy_source_note
+    dst = st.copy_dest_note
+    if src is None or dst is None or src not in st.samples:
+        st.copy_source_note = None
+        st.copy_dest_note = None
+        st.copy_confirm_pending = False
+        return
+
+    # Copy pitch offset (or remove dest's offset if source has none)
+    if src in st.pitch_offsets:
+        st.pitch_offsets[dst] = dict(st.pitch_offsets[src])
+    else:
+        st.pitch_offsets.pop(dst, None)
+
+    # Copy sample data
+    save_sample(dst, st.samples[src].copy())
+    save_pitch_offsets()
+
+    # Recompute chromatic samples if dest was the chromatic root
+    if st.chromatic_root_note == dst:
+        compute_chromatic_samples_async(dst)
+
+    # Reset copy state
+    st.copy_source_note = None
+    st.copy_dest_note = None
+    st.copy_confirm_pending = False
+
+
+def start_recording(note_number):
+    with st.voices_lock:
+        if st.recording_note is not None:
+            return  # already recording; ignore
+        st.recording_note = note_number
+        st.recording_chunks = []
+        st.ui_recording = {"note": st.midi_note_name(note_number), "start_time": time.time()}
+
+    def _callback(indata, frames, time_info, status):
+        st.recording_chunks.append(indata[:, 0].copy())
+
+    stream = sd.InputStream(
+        samplerate=st.SAMPLE_RATE, channels=1, dtype="float32",
+        device=st.input_device, callback=_callback,
+    )
+    stream.start()
+    with st.voices_lock:
+        st.recording_stream = stream
+
+
+def stop_recording(note_number):
+    with st.voices_lock:
+        if st.recording_note != note_number:
+            return  # not recording this note; ignore
+        stream = st.recording_stream
+        chunks = list(st.recording_chunks)
+        st.recording_note = None
+        st.recording_stream = None
+        st.recording_chunks = []
+        st.ui_recording = None
+
+    if stream is not None:
+        stream.stop()
+        stream.close()
+
+    if chunks:
+        audio = np.concatenate(chunks).astype("float64")
+        audio = trim_silence(audio)
+        save_sample(note_number, audio)
+
+
+def load_samples():
+    """Load any existing .wav files from ./samples/ directory."""
+    if not os.path.isdir("samples"):
+        return
+    for filename in os.listdir("samples"):
+        if filename.startswith("note_") and filename.endswith(".wav"):
+            try:
+                note_num = int(filename[5:-4])
+            except ValueError:
+                continue
+            filepath = os.path.join("samples", filename)
+            with wave.open(filepath, "r") as wf:
+                n_frames = wf.getnframes()
+                raw = wf.readframes(n_frames)
+                width = wf.getsampwidth()
+                if width == 2:
+                    int_data = np.frombuffer(raw, dtype=np.int16)
+                    audio = int_data.astype(np.float64) / 32767.0
+                elif width == 4:
+                    int_data = np.frombuffer(raw, dtype=np.int32)
+                    audio = int_data.astype(np.float64) / 2147483647.0
+                else:
+                    continue
+                # If stereo, take first channel
+                if wf.getnchannels() > 1:
+                    audio = audio[::wf.getnchannels()]
+                st.samples[note_num] = audio

midi_cli/state.py

@@ -0,0 +1,121 @@
+import threading
+
+import numpy as np
+
+# Audio constants
+SAMPLE_RATE = 48000
+BLOCK_SIZE = 256
+FADE_SAMPLES = int(0.005 * SAMPLE_RATE)  # 5ms fade
+
+# Note/keyboard constants
+NOTE_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+KEYBOARD_NOTE_MAP = {'1': 60, '2': 61, '3': 62, '4': 63, '5': 64,
+                     '6': 65, '7': 66, '8': 67, '9': 68, '0': 69}
+KEYBOARD_NOTE_RELEASE_S = 0.25
+
+# ANSI escape helpers
+RST = "\033[0m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+CYAN = "\033[36m"
+ORANGE = "\033[38;5;208m"
+CLEAR_LINE = "\033[2K"
+HIDE_CURSOR = "\033[?25l"
+SHOW_CURSOR = "\033[?25h"
+NUM_UI_LINES = 4
+
+# Per-sample gain step for 5ms fade
+FADE_IN_STEP = 1.0 / FADE_SAMPLES
+FADE_OUT_STEP = 1.0 / FADE_SAMPLES
+
+# Two-stage exponential decay (piano-like)
+# Stage 1: fast initial decay (~0.5s) — hammer brightness fading
+STAGE1_SAMPLES = int(0.5 * SAMPLE_RATE)
+STAGE1_DECAY = 0.4 ** (1.0 / STAGE1_SAMPLES)  # drops to ~40% over 0.5s
+# Stage 2: slow ring-out (~7s to silence)
+STAGE2_DECAY = 0.001 ** (1.0 / (7.0 * SAMPLE_RATE))
+SILENCE_THRESHOLD = 0.001
+
+# Harmonic amplitudes (piano-like spectrum)
+HARMONICS = np.array([1.0, 0.5, 0.25, 0.12, 0.06])
+HARMONICS /= HARMONICS.sum()  # normalize so total max = 1.0
+H_MULTIPLIERS = np.arange(1, len(HARMONICS) + 1)  # [1, 2, 3, 4, 5]
+
+
+def midi_note_name(note_number):
+    return f"{NOTE_NAMES[note_number % 12]}{(note_number // 12) - 1}"
+
+
+def note_to_freq(note):
+    return 440.0 * 2.0 ** ((note - 69) / 12.0)
+
+
+# Voice: {note: {"phase": float, "gain": float, "releasing": bool}}
+voices = {}
+voices_lock = threading.Lock()
+sustain = False
+sustained_notes = set()
+
+# Sampler state
+MODES = ["synth", "sample", "record", "pitch", "chromatic", "trim", "copy", "loop"]
+mode = "synth"
+samples = {}  # note_number -> numpy array (mono float64)
+sample_voices = {}  # note -> {"pos": int, "releasing": bool, "gain": float}
+
+# Dynamic recording state
+recording_note = None       # int: MIDI note currently recording, or None
+recording_chunks = []       # list of np.ndarray frames from InputStream callback
+recording_stream = None     # sd.InputStream instance, or None
+keyboard_recording_notes = set()  # notes with in-progress keyboard-toggle recordings
+
+# Pitch mode state
+pitch_offsets = {}        # note_number -> {"semitones": int, "cents": int}
+pitched_samples = {}      # note_number -> pre-computed pitched numpy array
+pitch_selected_note = None  # currently selected note for pitch adjustment
+CENTS_STEP = 10           # cents per left/right arrow press
+
+# Chromatic mode state
+chromatic_root_note = None      # selected root MIDI note
+chromatic_samples = {}          # midi_note -> numpy array (pre-computed)
+chromatic_computing = False     # True while background thread runs
+chromatic_selecting = False     # True when waiting for user to pick root
+
+# Trim mode state
+trim_selected_note = None   # MIDI note being trimmed (None = selecting)
+trim_step = 0               # 0 = adjusting start, 1 = adjusting end
+trim_start = 0              # start sample index
+trim_end = 0                # end sample index
+trim_loop_pos = 0           # current playback position for loop preview
+trim_looping = False        # True while preview loop is active
+TRIM_WAVEFORM_HEIGHT = 6    # rows for waveform display
+MIN_TRIM_SAMPLES = 480      # ~10ms minimum trim length
+MIN_LOOP_PERIOD = int(2.0 * SAMPLE_RATE)  # minimum loop cycle including silence
+
+# Loop mode state
+loop_state = "idle"       # "idle", "recording", "playing", "overdub"
+loop_buffer = None        # np.ndarray once recorded, None when idle
+loop_pos = 0              # current playback position (int)
+loop_record_chunks = []   # list of np.ndarray, accumulated during recording
+
+# Copy mode state
+copy_source_note = None       # MIDI note selected as source
+copy_dest_note = None         # MIDI note selected as destination
+copy_confirm_pending = False  # True when awaiting overwrite confirmation
+
+# UI state
+ui_active_note = None
+ui_sustain = False
+ui_recording = None  # None or {"note": str, "start_time": float}
+ui_midi_port = ""
+prev_ui_lines = NUM_UI_LINES
+
+keyboard_mock_mode = False
+keyboard_timers = {}  # note -> threading.Timer, for pending note-offs
+
+# Device selections (set by startup wizard, None = system default / port 0)
+input_device = None   # audio input device name or None
+output_device = None  # audio output device name or None
+midi_port = None      # MIDI port name or None