33bb08270d
- 808 bass: fixed note positions to beat 1.0 per bar (i-iv-i-V, 1.5 beat duration) - Chords: 4-note 7th voicings (Am7, F7, C7, G7) instead of 2-note intervals - Lead: constrained to 8-semitone range, pentatonic scale - Pad: arpeggiated eighth-notes instead of static 2-note drones - Ozone 12: fixed .vst3 filename paths in Calibrator - Delta-encoding: fixed cumulative timing drift in _build_midi_source() with CC events 298/298 tests pass.
510 lines
17 KiB
Python
510 lines
17 KiB
Python
"""Hook-based reggaeton melody engine — deterministic, chord-aware motif generation.
|
|
|
|
Replaces random pentatonic lead lines with structured repeating motifs
|
|
using call-and-response phrasing and arch-contour hooks.
|
|
|
|
Design: pure functions, no I/O, no global state.
|
|
RNG: random.Random(seed) per-call for full determinism.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import random
|
|
from src.core.schema import MidiNote
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Musical constants
|
|
# ---------------------------------------------------------------------------
|
|
|
|
_NOTE_TO_MIDI = {
|
|
"C": 0, "C#": 1, "D": 2, "D#": 3, "E": 4, "F": 5,
|
|
"F#": 6, "G": 7, "G#": 8, "A": 9, "A#": 10, "B": 11,
|
|
}
|
|
|
|
# i-VI-III-VII progression (reggaeton standard) — duplicated from compose.py
|
|
_CHORD_PROGRESSION: list[tuple[int, str]] = [
|
|
(0, "minor"), # i
|
|
(8, "major"), # VI
|
|
(3, "major"), # III
|
|
(10, "major"), # VII
|
|
]
|
|
|
|
_CHORD_BARS = 2 # each chord lasts 2 bars
|
|
|
|
# Dembow stab grid (beat offsets within each bar)
|
|
_DEMBOW_POSITIONS: list[float] = [1.0, 2.5, 3.0, 3.5]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Internal helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _midi_for_name(note_name: str, octave: int = 4) -> int:
|
|
"""Convert note name (e.g. "A") to MIDI pitch at given octave."""
|
|
return (octave + 1) * 12 + _NOTE_TO_MIDI[note_name]
|
|
|
|
|
|
def _get_pentatonic(key_root: str, key_minor: bool, octave: int) -> list[int]:
|
|
"""Return pentatonic scale MIDI notes for the given key and octave."""
|
|
root_midi = _midi_for_name(key_root, octave)
|
|
intervals = [0, 3, 5, 7, 10] if key_minor else [0, 2, 4, 7, 9]
|
|
return [root_midi + i for i in intervals]
|
|
|
|
|
|
def _get_diatonic(key_root: str, key_minor: bool, octave: int) -> list[int]:
|
|
"""Return full diatonic scale MIDI notes (7 notes, not pentatonic)."""
|
|
root_midi = _midi_for_name(key_root, octave)
|
|
intervals = [0, 2, 3, 5, 7, 8, 10] if key_minor else [0, 2, 4, 5, 7, 9, 11]
|
|
return [root_midi + i for i in intervals]
|
|
|
|
|
|
def _resolve_chord_tones(
|
|
key_root: str, key_minor: bool, bar: int, octave: int = 4,
|
|
) -> set[int]:
|
|
"""Return MIDI pitches for the active chord at a given bar index.
|
|
|
|
Cycles through i-VI-III-VII, each chord lasting _CHORD_BARS.
|
|
Includes chord tones across ±1 octave range for flexible voicing.
|
|
"""
|
|
tonic_midi = _midi_for_name(key_root, octave)
|
|
chord_idx = (bar // _CHORD_BARS) % len(_CHORD_PROGRESSION)
|
|
offset, quality = _CHORD_PROGRESSION[chord_idx]
|
|
root = tonic_midi + offset
|
|
|
|
if quality == "minor":
|
|
intervals = [0, 3, 7]
|
|
else:
|
|
intervals = [0, 4, 7]
|
|
|
|
tones: set[int] = set()
|
|
# Constrain to single octave (oct_shift=0 only) to keep melodies coherent.
|
|
# Expanding to ±1 octave creates 2+ octave jumps in the arch contour.
|
|
for iv in intervals:
|
|
tones.add(root + iv)
|
|
return tones
|
|
|
|
|
|
def _resolve_tension_notes(
|
|
key_root: str, key_minor: bool, octave: int = 4,
|
|
) -> tuple[int, int]:
|
|
"""Return (V, VII) MIDI pitches for call-resolution scheme."""
|
|
tonic_midi = _midi_for_name(key_root, octave)
|
|
v_pitch = tonic_midi + 7 # perfect fifth
|
|
# VII: minor = whole step below tonic, major = half step below
|
|
vii_pitch = tonic_midi + (10 if key_minor else 11)
|
|
return v_pitch, vii_pitch
|
|
|
|
|
|
def _resolve_tonic(key_root: str, octave: int = 4) -> int:
|
|
"""Return tonic MIDI pitch."""
|
|
return _midi_for_name(key_root, octave)
|
|
|
|
|
|
def _quantize_to_scale(pitch: int, scale_notes: list[int]) -> int:
|
|
"""Snap pitch to the nearest scale note (by semitone distance)."""
|
|
if not scale_notes:
|
|
return pitch
|
|
return min(scale_notes, key=lambda s: abs(s - pitch))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Style-specific motif builders
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def _build_hook(
|
|
key_root: str, key_minor: bool, bars: int, rng: random.Random,
|
|
) -> list[MidiNote]:
|
|
"""Hook style: arch contour, chord tones on quarter-beat positions.
|
|
|
|
Each bar gets 4 chord-tone notes forming a low→mid→high→mid arch,
|
|
plus an optional off-beat ghost note for reggaeton feel.
|
|
All quarter-position notes are chord tones (100% ratio).
|
|
|
|
Across bars, the peak pitch shifts to follow the chord progression,
|
|
creating a natural melodic arc.
|
|
"""
|
|
scale_oct4 = _get_pentatonic(key_root, key_minor, 4)
|
|
scale_oct5 = _get_pentatonic(key_root, key_minor, 5)
|
|
all_scale = sorted(set(scale_oct4 + scale_oct5))
|
|
|
|
notes: list[MidiNote] = []
|
|
|
|
for bar in range(bars):
|
|
chord_tones = _resolve_chord_tones(key_root, key_minor, bar, 4)
|
|
# Filter to chord tones that align with the scale
|
|
chord_in_scale = sorted(set(
|
|
p for p in chord_tones
|
|
if any(abs(p % 12 - s % 12) == 0 for s in all_scale)
|
|
))
|
|
if len(chord_in_scale) < 4:
|
|
# Not enough scale-aligned chord tones; use all chord tones
|
|
chord_in_scale = sorted(chord_tones)
|
|
|
|
bar_start = bar * 4.0
|
|
|
|
# Build arch: pick 4 distinct chord-tone pitches
|
|
# low → mid-low → high → mid-high (arch shape)
|
|
n = len(chord_in_scale)
|
|
if n >= 4:
|
|
low = chord_in_scale[0]
|
|
mid_low = chord_in_scale[n // 3]
|
|
high = chord_in_scale[-1]
|
|
mid_high = chord_in_scale[2 * n // 3]
|
|
elif n == 3:
|
|
low, mid_low, high = chord_in_scale[0], chord_in_scale[1], chord_in_scale[2]
|
|
mid_high = chord_in_scale[1] # reuse mid
|
|
elif n == 2:
|
|
low = chord_in_scale[0]
|
|
mid_low = chord_in_scale[1]
|
|
high = chord_in_scale[0] + 12 # octave up
|
|
mid_high = chord_in_scale[1]
|
|
else:
|
|
low = mid_low = high = mid_high = chord_in_scale[0]
|
|
|
|
# Ensure high > low for true arch shape
|
|
if high <= low + 2:
|
|
high = low + 12 if low + 12 in chord_tones else high + 7
|
|
if mid_high <= mid_low:
|
|
mid_high = mid_low + 5
|
|
|
|
contour = [
|
|
(0.0, low, 0.75), # beat 1 — low chord tone
|
|
(1.0, mid_low, 0.5), # beat 2 — walking up
|
|
(2.0, high, 0.75), # beat 3 — peak (chord tone)
|
|
(3.0, mid_high, 0.5), # beat 4 — coming down
|
|
]
|
|
|
|
for pos, pitch, dur in contour:
|
|
velocity = 85 if pos in (0.0, 2.0) else 70
|
|
notes.append(MidiNote(
|
|
pitch=pitch,
|
|
start=bar_start + pos,
|
|
duration=dur,
|
|
velocity=velocity,
|
|
))
|
|
|
|
# Ghost note on beat 2.5 (reggaeton syncopation) — deterministically varied
|
|
if rng.random() < 0.6:
|
|
ghost_pitch = _quantize_to_scale(
|
|
mid_low + rng.choice([-2, 0, 2, 5]), all_scale,
|
|
)
|
|
notes.append(MidiNote(
|
|
pitch=ghost_pitch,
|
|
start=bar_start + 1.5,
|
|
duration=0.25,
|
|
velocity=rng.randint(45, 60),
|
|
))
|
|
|
|
# Sort by start time so contour notes come before ghost notes
|
|
notes.sort(key=lambda n: n.start)
|
|
return notes
|
|
|
|
|
|
def _build_stabs(
|
|
key_root: str, key_minor: bool, bars: int, rng: random.Random,
|
|
) -> list[MidiNote]:
|
|
"""Stabs style: short 16th-duration hits on dembow grid positions.
|
|
|
|
All notes are on [1.0, 2.5, 3.0, 3.5] per bar with duration ≤ 0.25.
|
|
Strong positions (2.5, 3.5) favor chord tones.
|
|
"""
|
|
scale_oct4 = _get_pentatonic(key_root, key_minor, 4)
|
|
scale_oct5 = _get_pentatonic(key_root, key_minor, 5)
|
|
all_scale = sorted(set(scale_oct4 + scale_oct5))
|
|
|
|
notes: list[MidiNote] = []
|
|
|
|
for bar in range(bars):
|
|
chord_tones = _resolve_chord_tones(key_root, key_minor, bar, 4)
|
|
chord_in_scale = sorted(set(
|
|
p for p in chord_tones
|
|
if any(abs(p % 12 - s % 12) == 0 for s in all_scale)
|
|
))
|
|
if not chord_in_scale:
|
|
chord_in_scale = sorted(chord_tones)
|
|
width = len(chord_in_scale)
|
|
|
|
bar_start = bar * 4.0
|
|
for pos_offset in _DEMBOW_POSITIONS:
|
|
is_strong = pos_offset in (2.5, 3.5)
|
|
|
|
if is_strong and width > 0:
|
|
idx = rng.randint(0, width - 1)
|
|
idx = ((bar + int(pos_offset * 4)) * 7 + 3) % width # deterministic
|
|
pitch = chord_in_scale[idx]
|
|
else:
|
|
pitch = rng.choice(all_scale)
|
|
|
|
notes.append(MidiNote(
|
|
pitch=pitch,
|
|
start=bar_start + pos_offset,
|
|
duration=0.25, # 16th note
|
|
velocity=80 if is_strong else 65,
|
|
))
|
|
|
|
return notes
|
|
|
|
|
|
def _build_smooth(
|
|
key_root: str, key_minor: bool, bars: int, rng: random.Random,
|
|
) -> list[MidiNote]:
|
|
"""Smooth style: stepwise scalar eighth-note motion.
|
|
|
|
Uses the full diatonic scale (not pentatonic) so consecutive
|
|
notes differ by ≤ 2 semitones. Melody walks through the scale
|
|
with occasional direction changes for contour.
|
|
"""
|
|
scale_oct4 = _get_diatonic(key_root, key_minor, 4)
|
|
scale_oct5 = _get_diatonic(key_root, key_minor, 5)
|
|
scale = sorted(set(scale_oct4 + scale_oct5))
|
|
|
|
if not scale:
|
|
return []
|
|
|
|
notes: list[MidiNote] = []
|
|
total_eighths = bars * 8
|
|
|
|
# Start near tonic with seed-dependent offset for variation
|
|
tonic = _resolve_tonic(key_root, 4)
|
|
tonic_candidates = [s for s in scale if abs(s - tonic) <= 4]
|
|
if tonic_candidates:
|
|
current = rng.choice(tonic_candidates) if len(tonic_candidates) > 1 else tonic_candidates[0]
|
|
else:
|
|
current = tonic
|
|
direction = 1 # 1 = ascending, -1 = descending
|
|
|
|
for ei in range(total_eighths):
|
|
pos = ei * 0.5
|
|
bar = ei // 8
|
|
|
|
# Strong beats: bias toward chord tones
|
|
is_quarter = (ei % 4 == 0)
|
|
chord_tones = _resolve_chord_tones(key_root, key_minor, bar, 4)
|
|
|
|
# Find candidates: scale notes within ±2 semitones of current
|
|
candidates = [s for s in scale if abs(s - current) <= 2 and s != current]
|
|
|
|
if not candidates:
|
|
# No valid stepwise candidate; stay or jump small
|
|
candidates = [s for s in scale if abs(s - current) <= 3]
|
|
|
|
if not candidates:
|
|
candidates = [current]
|
|
|
|
# On quarter beats, prefer chord tones that are also stepwise-valid
|
|
if is_quarter:
|
|
chord_candidates = [c for c in candidates if c in chord_tones]
|
|
if chord_candidates:
|
|
candidates = chord_candidates
|
|
|
|
# Occasionally reverse direction for seed-dependent variation
|
|
if rng.random() < 0.15:
|
|
direction *= -1
|
|
|
|
# Pick: prefer candidates in the current direction
|
|
if direction > 0:
|
|
up_candidates = [c for c in candidates if c > current]
|
|
if up_candidates:
|
|
next_pitch = rng.choice(up_candidates) if len(up_candidates) > 1 else up_candidates[0]
|
|
else:
|
|
down_candidates = [c for c in candidates if c < current]
|
|
if down_candidates:
|
|
next_pitch = rng.choice(down_candidates) if len(down_candidates) > 1 else down_candidates[-1]
|
|
else:
|
|
next_pitch = rng.choice(candidates) if len(candidates) > 1 else candidates[0]
|
|
direction = -1
|
|
else:
|
|
down_candidates = [c for c in candidates if c < current]
|
|
if down_candidates:
|
|
next_pitch = rng.choice(down_candidates) if len(down_candidates) > 1 else down_candidates[-1]
|
|
else:
|
|
up_candidates = [c for c in candidates if c > current]
|
|
if up_candidates:
|
|
next_pitch = rng.choice(up_candidates) if len(up_candidates) > 1 else up_candidates[0]
|
|
else:
|
|
next_pitch = rng.choice(candidates) if len(candidates) > 1 else candidates[0]
|
|
direction = 1
|
|
|
|
# Clamp within overall range (don't go too high or low)
|
|
if next_pitch > scale[-3]:
|
|
direction = -1
|
|
elif next_pitch < scale[3]:
|
|
direction = 1
|
|
|
|
velocity = 75 if is_quarter else 60
|
|
notes.append(MidiNote(
|
|
pitch=next_pitch,
|
|
start=pos,
|
|
duration=0.5,
|
|
velocity=velocity,
|
|
))
|
|
current = next_pitch
|
|
|
|
return notes
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Public API
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def build_motif(
|
|
key_root: str,
|
|
key_minor: bool,
|
|
style: str,
|
|
bars: int = 4,
|
|
seed: int = 42,
|
|
) -> list[MidiNote]:
|
|
"""Generate a repeating motif using chord-aware scale selection.
|
|
|
|
Args:
|
|
key_root: Tonic note name (e.g. "A", "D", "F#").
|
|
key_minor: True for minor key, False for major.
|
|
style: One of "hook", "stabs", "smooth".
|
|
bars: Number of bars (2-8, clamped if outside).
|
|
seed: RNG seed for deterministic output.
|
|
|
|
Returns:
|
|
List of MidiNote objects.
|
|
|
|
Raises:
|
|
ValueError: If style is not one of "hook", "stabs", "smooth".
|
|
"""
|
|
valid = ("hook", "stabs", "smooth")
|
|
if style not in valid:
|
|
raise ValueError(
|
|
f"Invalid style '{style}'. Valid styles: {', '.join(valid)}"
|
|
)
|
|
|
|
# Clamp bars to safe range
|
|
bars = max(2, min(8, bars))
|
|
|
|
rng = random.Random(seed)
|
|
|
|
if style == "hook":
|
|
return _build_hook(key_root, key_minor, bars, rng)
|
|
elif style == "stabs":
|
|
return _build_stabs(key_root, key_minor, bars, rng)
|
|
else:
|
|
return _build_smooth(key_root, key_minor, bars, rng)
|
|
|
|
|
|
def apply_variation(
|
|
motif: list[MidiNote],
|
|
shift_beats: float = 0.0,
|
|
transpose_semitones: int = 0,
|
|
) -> list[MidiNote]:
|
|
"""Apply rhythmic shift and/or pitch transpose to a motif.
|
|
|
|
Returns a new list; the original motif is unchanged.
|
|
All inter-onset intervals and durations are preserved.
|
|
|
|
Args:
|
|
motif: Source notes.
|
|
shift_beats: Beat offset added to all start times.
|
|
transpose_semitones: Semitone offset added to all pitches.
|
|
|
|
Returns:
|
|
New list of MidiNote objects.
|
|
"""
|
|
return [
|
|
MidiNote(
|
|
pitch=note.pitch + transpose_semitones,
|
|
start=note.start + shift_beats,
|
|
duration=note.duration,
|
|
velocity=note.velocity,
|
|
)
|
|
for note in motif
|
|
]
|
|
|
|
|
|
def build_call_response(
|
|
motif: list[MidiNote],
|
|
bars: int = 8,
|
|
key_root: str = "A",
|
|
key_minor: bool = True,
|
|
seed: int = 42,
|
|
) -> list[MidiNote]:
|
|
"""Build call-and-response structure from a motif.
|
|
|
|
First half (call): motif repeated, last note forced to V or VII (tension).
|
|
Second half (response): motif repeated, last note forced to tonic i (resolution).
|
|
|
|
The motif is repeated as needed to fill the section.
|
|
|
|
Args:
|
|
motif: Source motif notes.
|
|
bars: Total bars for the call-response section.
|
|
key_root: Tonic note name.
|
|
key_minor: True for minor key.
|
|
seed: RNG seed.
|
|
|
|
Returns:
|
|
List of MidiNote objects spanning `bars` worth of beats.
|
|
"""
|
|
if not motif:
|
|
return []
|
|
|
|
rng = random.Random(seed)
|
|
half_bars = bars // 2
|
|
total_beats = bars * 4.0
|
|
half_beats = half_bars * 4.0
|
|
|
|
# Determine motif length in beats (end of last note)
|
|
motif_end = max(n.start + n.duration for n in motif)
|
|
motif_bars = max(1, int((motif_end + 3.999) / 4.0))
|
|
|
|
repeats_per_half = max(1, half_bars // motif_bars)
|
|
|
|
v_tonic, vii_tonic = _resolve_tension_notes(key_root, key_minor, 4)
|
|
tonic = _resolve_tonic(key_root, 4)
|
|
|
|
result: list[MidiNote] = []
|
|
|
|
# --- Call half ---
|
|
for r in range(repeats_per_half):
|
|
offset = r * motif_bars * 4.0
|
|
for note in motif:
|
|
new_start = note.start + offset
|
|
if new_start >= half_beats:
|
|
continue # skip notes beyond call half
|
|
result.append(MidiNote(
|
|
pitch=note.pitch,
|
|
start=new_start,
|
|
duration=note.duration,
|
|
velocity=note.velocity,
|
|
))
|
|
|
|
# Sort by start time so last-by-position = last in time
|
|
result.sort(key=lambda n: n.start)
|
|
|
|
# Force last note of call half to tension pitch
|
|
call_notes = [n for n in result if n.start < half_beats]
|
|
if call_notes:
|
|
tension_pitch = v_tonic if rng.random() < 0.5 else vii_tonic
|
|
call_notes[-1].pitch = tension_pitch
|
|
|
|
# --- Response half ---
|
|
response_start = half_beats
|
|
for r in range(repeats_per_half):
|
|
offset = response_start + r * motif_bars * 4.0
|
|
for note in motif:
|
|
new_start = note.start + offset
|
|
if new_start >= total_beats:
|
|
continue # skip notes beyond section
|
|
result.append(MidiNote(
|
|
pitch=note.pitch,
|
|
start=new_start,
|
|
duration=note.duration,
|
|
velocity=min(127, note.velocity + 5),
|
|
))
|
|
|
|
# Sort again after adding response notes
|
|
result.sort(key=lambda n: n.start)
|
|
|
|
# Force last note to tonic
|
|
response_notes = [n for n in result if n.start >= response_start]
|
|
if response_notes:
|
|
response_notes[-1].pitch = tonic
|
|
|
|
return result
|