--- name: bass-transcribe description: Use when the user has played bass or another single-note instrument (or sung a line) and wants the take as a MIDI file, an Ableton Live clip, or a tab/chart. --- # Bass Transcribe — played take → MIDI / Live clip / chart Default for bass is the offline **pyin** pipeline. For vocals and expressive leads (sax, synth lead) switch to **CREPE** (§2b). For in-Live plugin options (NeuralNote, Jam Origin) read `references/realtime-options.md`. **Why pyin, not CREPE, for bass:** in a side-by-side A/B in Live on a separated bass stem, the CREPE line was rejected by ear ("CREPE is not for bass") — it over-segments a slow-moving line into spurious adjacent notes. Published evidence agrees: pYIN beats CREPE on bass lines because CREPE's training set has almost no sub-bass examples (Araz, ISMIR 2021 LBD), and no public pitch benchmark covers the bass register. pyin is also ~30× faster. On vocals the same A/B went the other way — CREPE caught quiet, legato notes pyin dropped. ## 1. Get the audio - **User points at a file** — wav/mp3/aiff of the take. Mono preferred; DI cleaner than mic. - **Record in Live** — audio track, arm, record the take. MCP **cannot export audio**: the user does File → Export, or point at the raw recording under the Set's `Samples/Recorded/` folder. - Ask for (or detect) the take's **BPM** if the output will go into a Live clip. ## 2. Default pipeline — pyin → MIDI ```python import librosa, numpy as np, pretty_midi y, sr = librosa.load(AUDIO, sr=22050, mono=True) HOP = 256 # 11.6 ms f0, voiced, vprob = librosa.pyin(y, sr=sr, fmin=40.0, fmax=220.0, # E1 … A3 frame_length=4096, hop_length=HOP) t = librosa.times_like(f0, sr=sr, hop_length=HOP) rms = librosa.feature.rms(y=y, frame_length=4096, hop_length=HOP)[0] rms = rms / (rms.max() + 1e-9) VPROB, MIN_LEN, GAP = 0.55, 0.10, 0.05 # voicing gate, min note s, bridgeable dropout s pitch = np.where(voiced & (vprob >= VPROB), np.round(librosa.hz_to_midi(np.nan_to_num(f0, nan=40.0))), -1).astype(int) notes, cur = [], None for i, (ti, p) in enumerate(zip(t, pitch)): if cur and p == cur['p']: cur['end'], cur['i1'] = ti, i # same pitch: extend continue if cur and p < 0 and ti - cur['end'] <= GAP: continue # short dropout: bridge it if cur and cur['end'] - cur['start'] >= MIN_LEN: notes.append(cur) # pitch change / long gap: close cur = {'p': p, 'start': ti, 'end': ti, 'i0': i, 'i1': i} if p >= 0 else None if cur and cur['end'] - cur['start'] >= MIN_LEN: notes.append(cur) pm = pretty_midi.PrettyMIDI() inst = pretty_midi.Instrument(program=33) # Electric Bass (finger) for n in notes: vel = int(np.clip(50 + 70 * rms[n['i0']:n['i1'] + 1].mean(), 35, 120)) inst.notes.append(pretty_midi.Note(velocity=vel, pitch=n['p'], start=n['start'], end=n['end'])) pm.instruments.append(inst) pm.write(OUT_MID) ``` Tuning knobs: `fmin=36` for drop-D (D1), `fmin=30` + `frame_length=8192` for a 5-string low B; `fmax` up to ~400 Hz only for high solos (a wider range invites octave jumps); `VPROB` up to 0.6–0.7 for noisy takes; `MIN_LEN` down to 0.06 for fast lines. Measured on separated bass stems: ~13 s for a 2-minute song on an M3. ## 2b. Vocals and expressive leads — CREPE Same segmentation, with CREPE's confidence in place of `vprob`: ```python import crepe y16, _ = librosa.load(AUDIO, sr=16000, mono=True) t, freq, conf, _ = crepe.predict(y16, 16000, model_capacity='full', viterbi=True, step_size=10) # pitch = where(conf >= 0.55, round(hz_to_midi(freq)), -1); then the loop above ``` `full` + viterbi is deterministic on CPU. Expect more notes than pyin, including breaths and glottal onsets — post-filter sub-100 ms notes. CREPE `full` runs at ~1× real time; for a quick preview, **SwiftF0** (`swift-f0==0.3.0`, ONNX, ~250× real time) agrees with it within 50 cents on 97–99% of frames both call voiced — but it voices only 27–80% of the frames CREPE does, dropping exactly the quiet, sparse singing CREPE was chosen for. A sung line is never the tonic source: on a drone track the singer never held the tonic, and the melody's longest pitch class was the 2nd. ## 2c. Octave cross-check (when a line looks wrong, or on drone material) Run a second tracker, band-limited to the same range, and flag where the two disagree by more than 50 cents — don't auto-correct; listen to those spots. ```python import crepe.core as cc y16, _ = librosa.load(AUDIO, sr=16000, mono=True) act = cc.get_activation(y16, 16000, model_capacity='tiny', step_size=10, verbose=0) cents = np.linspace(0, 7180, 360) + 1997.3794084376191 # CREPE bin → cents act[:, (cents < 1200 * np.log2(40 / 10)) | (cents > 1200 * np.log2(220 / 10))] = 0 f_crepe = 10 * 2 ** (cc.to_viterbi_cents(act) / 1200) # band-limited Viterbi t_crepe = np.arange(len(f_crepe)) * 0.01 # compare with pyin's f0 on t_crepe where both are voiced; flag |Δ| > 50 cents ``` Zeroing the out-of-band bins *before* Viterbi keeps the decoder inside the bass range (filtering afterwards can't). `tiny` is ~17× faster than `full`. On separated bass stems this flagged ~4% of frames on a busy line — almost all exact-octave splits — and ~9% on a drone, where the disagreements also include harmonic locks, not just octaves. ## 3. Cleanup rules - **Drop blips** < 80 ms (tracker flicker, fret noise). - **Octave sanity**: 4-string bass ≈ MIDI 26–67 (drop-D D1 … 24th-fret G4). Tracker octave errors land a 5th/octave out — flag and correct outliers to the nearest in-range octave. - **Legato-join** same-pitch notes split by < 50 ms gaps. - **Ghost notes / slides** show as short low-confidence fragments — either drop (chart use) or keep (feel/groove analysis). Ask which the user wants. - **Double-stops or chords played?** pyin is monophonic and will pick one note — rerun with **basic-pitch** (`basic-pitch