feat: reggaeton production system with intelligent sample selection and FLP generation
This commit is contained in:
renato97
610
scripts/build_reggaeton_fuego.py
Normal file
610
scripts/build_reggaeton_fuego.py
Normal file
@@ -0,0 +1,610 @@
|
||||
"""
|
||||
Build a PROFESSIONAL reggaeton FLP with REAL SAMPLES from the user's library.
|
||||
|
||||
Key facts:
|
||||
- Only Ch10-19 are sampler channels in the reference FLP (Ch0-9 are VST/plugin)
|
||||
- Each sampler channel loads a real WAV from libreria/reggaeton/
|
||||
- MIDI notes trigger those real samples
|
||||
- 10 channels = kick, snare, hihat, 808, bell, lead, pad, clap, perc, rim
|
||||
|
||||
Sample selection (professional reggaeton):
|
||||
Ch10: kick nes 1 — classic reggaeton kick
|
||||
Ch11: snare nes 1 — clean reggaeton snare
|
||||
Ch12: hi-hat 1 — tight hihat
|
||||
Ch13: Bass Reventado — deep 808 bass (dastin.prod)
|
||||
Ch14: bell 4 — bell tone for chords
|
||||
Ch15: lead 3 — melodic lead
|
||||
Ch16: pad 1 — sustained pad
|
||||
Ch17: clap — reggaeton clap (using snap from perc loop)
|
||||
Ch18: perc 1 — perc one shot
|
||||
Ch19: rim — rim/rimshot
|
||||
|
||||
Output: output/reggaeton_fuego.flp
|
||||
"""
|
||||
import struct
|
||||
import sys
|
||||
import os
|
||||
|
||||
# ── Paths ──────────────────────────────────────────────────────────────────────
|
||||
BASE = r"C:\Users\Administrator\Documents\fl_control"
|
||||
CH11_TMPL = os.path.join(BASE, "output", "ch11_kick_template.bin")
|
||||
REF_FLP = os.path.join(BASE, r"my space ryt\my space ryt.flp")
|
||||
FLP_OUT = os.path.join(BASE, "output", "reggaeton_fuego.flp")
|
||||
|
||||
# All samples copied here — clean names, no special chars
|
||||
SAMPLES_DIR = os.path.join(BASE, "output", "fuego_samples")
|
||||
|
||||
sys.path.insert(0, BASE)
|
||||
|
||||
from src.flp_builder.events import (
|
||||
EventID,
|
||||
encode_text_event,
|
||||
encode_word_event,
|
||||
encode_data_event,
|
||||
encode_notes_block,
|
||||
)
|
||||
from src.flp_builder.skeleton import ChannelSkeletonLoader
|
||||
from src.flp_builder.arrangement import (
|
||||
ArrangementItem,
|
||||
build_arrangement_section,
|
||||
build_track_data_template,
|
||||
)
|
||||
|
||||
# ── Constants ──────────────────────────────────────────────────────────────────
|
||||
BPM = 95
|
||||
PPQ = 96
|
||||
|
||||
# Channel indices — ALL sampler channels (10-19)
|
||||
CH_KICK = 10
|
||||
CH_SNARE = 11
|
||||
CH_HH = 12
|
||||
CH_808 = 13
|
||||
CH_BELL = 14
|
||||
CH_LEAD = 15
|
||||
CH_PAD = 16
|
||||
CH_CLAP = 17
|
||||
CH_PERC = 18
|
||||
CH_RIM = 19
|
||||
|
||||
|
||||
# Sample assignment: ch_idx → (samples_dir, wav_filename)
|
||||
# All samples in fuego_samples/ with clean names
|
||||
SAMPLE_ASSIGNMENT = {
|
||||
CH_KICK: (SAMPLES_DIR, "kick.wav"),
|
||||
CH_SNARE: (SAMPLES_DIR, "snare.wav"),
|
||||
CH_HH: (SAMPLES_DIR, "hihat.wav"),
|
||||
CH_808: (SAMPLES_DIR, "bass_808.wav"),
|
||||
CH_BELL: (SAMPLES_DIR, "bell.wav"),
|
||||
CH_LEAD: (SAMPLES_DIR, "lead.wav"),
|
||||
CH_PAD: (SAMPLES_DIR, "pad.wav"),
|
||||
CH_CLAP: (SAMPLES_DIR, "clap.wav"),
|
||||
CH_PERC: (SAMPLES_DIR, "perc.wav"),
|
||||
CH_RIM: (SAMPLES_DIR, "rim.wav"),
|
||||
}
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# FUEGO CHORD PROGRESSION: Am → Dm → F → E
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
PROGRESSION = [
|
||||
{"name": "Am", "bass": 33, "chord": [45,48,52,57], "triad": [57,60,64], "root": 69},
|
||||
{"name": "Dm", "bass": 38, "chord": [50,53,57,62], "triad": [62,65,69], "root": 74},
|
||||
{"name": "F", "bass": 41, "chord": [53,57,60,65], "triad": [65,69,72], "root": 77},
|
||||
{"name": "E", "bass": 40, "chord": [52,56,59,64], "triad": [64,68,71], "root": 76},
|
||||
]
|
||||
BEATS_PER_CHORD = 8
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# DRUM GENERATORS — using correct channel indices
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
def _n(pos, length, ch, vel):
|
||||
return {"pos": pos, "len": length, "key": 60, "vel": max(1, min(127, vel))}
|
||||
|
||||
|
||||
def dembow_kick(bars, vel_mult=1.0):
|
||||
"""REAL dembow: 0.0, 2.0, 3.25"""
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
notes.append(_n(o, 0.25, CH_KICK, int(120 * vel_mult)))
|
||||
notes.append(_n(o + 2.0, 0.25, CH_KICK, int(110 * vel_mult)))
|
||||
notes.append(_n(o + 3.25, 0.15, CH_KICK, int(90 * vel_mult)))
|
||||
return {CH_KICK: notes}
|
||||
|
||||
|
||||
def perreador_kick(bars, vel_mult=1.0):
|
||||
"""Perreador: every beat + offbeat ghosts."""
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
for beat in range(4):
|
||||
notes.append(_n(o + beat, 0.25, CH_KICK, int(115 * vel_mult)))
|
||||
notes.append(_n(o + beat + 0.5, 0.15, CH_KICK, int(80 * vel_mult)))
|
||||
return {CH_KICK: notes}
|
||||
|
||||
|
||||
def sparse_kick(bars, vel_mult=1.0):
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
notes.append(_n(b * 4.0, 0.25, CH_KICK, int(100 * vel_mult)))
|
||||
return {CH_KICK: notes}
|
||||
|
||||
|
||||
def snare_standard(bars, vel_mult=1.0):
|
||||
"""Snare: beats 2, 3-and (positions 1.25, 3.0)."""
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
notes.append(_n(o + 1.25, 0.15, CH_SNARE, int(105 * vel_mult)))
|
||||
notes.append(_n(o + 3.0, 0.15, CH_SNARE, int(100 * vel_mult)))
|
||||
return {CH_SNARE: notes}
|
||||
|
||||
|
||||
def snare_intense(bars, vel_mult=1.0):
|
||||
"""Intense snare with ghost hits."""
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
notes.append(_n(o + 1.25, 0.15, CH_SNARE, int(110 * vel_mult)))
|
||||
notes.append(_n(o + 1.75, 0.10, CH_SNARE, int(70 * vel_mult)))
|
||||
notes.append(_n(o + 3.0, 0.15, CH_SNARE, int(105 * vel_mult)))
|
||||
notes.append(_n(o + 3.5, 0.10, CH_SNARE, int(65 * vel_mult)))
|
||||
return {CH_SNARE: notes}
|
||||
|
||||
|
||||
def hihat_offbeat(bars, vel_mult=1.0):
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
for i in range(4):
|
||||
notes.append(_n(o + i + 0.5, 0.1, CH_HH, int(55 * vel_mult)))
|
||||
return {CH_HH: notes}
|
||||
|
||||
|
||||
def hihat_8th(bars, vel_mult=1.0):
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
for i in range(8):
|
||||
v = 70 if i % 2 == 0 else 50
|
||||
notes.append(_n(o + i * 0.5, 0.1, CH_HH, int(v * vel_mult)))
|
||||
return {CH_HH: notes}
|
||||
|
||||
|
||||
def hihat_16th(bars, vel_mult=1.0):
|
||||
"""Full 16ths with accents and open hats."""
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
for i in range(16):
|
||||
p = i * 0.25
|
||||
if p % 1.0 == 0.0:
|
||||
v, l = 90, 0.1
|
||||
elif p % 0.5 == 0.0:
|
||||
v, l = 65, 0.1
|
||||
else:
|
||||
v, l = 40, 0.08
|
||||
if i in [5, 10]:
|
||||
l = 0.2; v = int(v * 1.2)
|
||||
notes.append(_n(o + p, l, CH_HH, int(v * vel_mult)))
|
||||
return {CH_HH: notes}
|
||||
|
||||
|
||||
def clap_standard(bars, vel_mult=1.0):
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
notes.append(_n(o + 1.0, 0.15, CH_CLAP, int(120 * vel_mult)))
|
||||
notes.append(_n(o + 3.0, 0.15, CH_CLAP, int(115 * vel_mult)))
|
||||
return {CH_CLAP: notes}
|
||||
|
||||
|
||||
def clap_soft(bars, vel_mult=1.0):
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
notes.append(_n(o + 1.0, 0.15, CH_CLAP, int(80 * vel_mult)))
|
||||
notes.append(_n(o + 3.0, 0.15, CH_CLAP, int(75 * vel_mult)))
|
||||
return {CH_CLAP: notes}
|
||||
|
||||
|
||||
def perc_offbeat(bars, vel_mult=1.0):
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
notes.append(_n(o + 0.75, 0.1, CH_PERC, int(85 * vel_mult)))
|
||||
notes.append(_n(o + 2.75, 0.1, CH_PERC, int(80 * vel_mult)))
|
||||
return {CH_PERC: notes}
|
||||
|
||||
|
||||
def rim_build(bars, vel_mult=1.0):
|
||||
"""Rim roll building intensity."""
|
||||
PATTERNS = [[0,2,8,14], [0,2,4,8,10,14], [0,2,4,6,8,10,12,14], list(range(16))]
|
||||
VELS = [50, 65, 80, 100]
|
||||
notes = []
|
||||
for b in range(bars):
|
||||
o = b * 4.0
|
||||
v = int(VELS[b % 4] * vel_mult)
|
||||
for idx in PATTERNS[b % 4]:
|
||||
notes.append(_n(o + idx * 0.25, 0.1, CH_RIM, v))
|
||||
return {CH_RIM: notes}
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# MELODIC GENERATORS
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
def _mn(pos, length, key, vel):
|
||||
"""Melodic note — pitch matters."""
|
||||
return {"pos": pos, "len": length, "key": key, "vel": max(1, min(127, vel))}
|
||||
|
||||
|
||||
def bass_808_full(bars, vel_mult=1.0):
|
||||
"""808 bass with chord-root movement + fifth variation."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
base = ci * BEATS_PER_CHORD
|
||||
r = ch["bass"]
|
||||
f = r + 7
|
||||
v = vel_mult
|
||||
notes.append(_mn(base + 0.0, 2.5, r, int(110*v)))
|
||||
notes.append(_mn(base + 2.5, 0.5, f, int(80*v)))
|
||||
notes.append(_mn(base + 3.0, 2.0, r, int(105*v)))
|
||||
notes.append(_mn(base + 5.0, 1.0, r, int(90*v)))
|
||||
notes.append(_mn(base + 6.0, 0.5, f, int(75*v)))
|
||||
notes.append(_mn(base + 6.5, 1.5, r, int(100*v)))
|
||||
return {CH_808: notes}
|
||||
|
||||
|
||||
def bass_808_sparse(bars, vel_mult=1.0):
|
||||
"""Sparse 808 for intro — just root, long sustain."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
notes.append(_mn(ci * BEATS_PER_CHORD, 7.5, ch["bass"], int(60 * vel_mult)))
|
||||
return {CH_808: notes}
|
||||
|
||||
|
||||
def bell_chords(bars, vel_mult=1.0):
|
||||
"""Bell playing offbeat chord stabs — 4-note voicings."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
stabs = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
base = ci * BEATS_PER_CHORD
|
||||
for sp in stabs:
|
||||
v = int((85 + (hash((ci, sp)) % 10)) * vel_mult)
|
||||
for pitch in ch["triad"]:
|
||||
notes.append(_mn(base + sp, 0.12, pitch, v))
|
||||
return {CH_BELL: notes}
|
||||
|
||||
|
||||
def bell_sparse(bars, vel_mult=1.0):
|
||||
"""Sparse bell for intro — 4-note voicings, beats 2.5 and 6.5."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
base = ci * BEATS_PER_CHORD
|
||||
for sp in [2.5, 6.5]:
|
||||
v = int(60 * vel_mult)
|
||||
for pitch in ch["chord"]:
|
||||
notes.append(_mn(base + sp, 0.15, pitch, v))
|
||||
return {CH_BELL: notes}
|
||||
|
||||
|
||||
def lead_hook(bars, vel_mult=1.0):
|
||||
"""Lead melody — arch contour, chord tones on strong beats."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
base = ci * BEATS_PER_CHORD
|
||||
lr = ch["root"]
|
||||
c = ch["triad"]
|
||||
v = vel_mult
|
||||
notes.append(_mn(base + 0.0, 1.0, c[0], int(95*v)))
|
||||
notes.append(_mn(base + 1.0, 0.5, c[1], int(85*v)))
|
||||
notes.append(_mn(base + 1.5, 0.5, c[2], int(100*v)))
|
||||
notes.append(_mn(base + 2.0, 1.5, lr, int(105*v)))
|
||||
notes.append(_mn(base + 3.5, 0.5, c[2], int(90*v)))
|
||||
notes.append(_mn(base + 4.0, 0.5, c[1], int(80*v)))
|
||||
notes.append(_mn(base + 4.5, 1.5, c[0], int(95*v)))
|
||||
notes.append(_mn(base + 6.0, 0.5, lr-2, int(75*v)))
|
||||
notes.append(_mn(base + 6.5, 1.5, c[0], int(90*v)))
|
||||
return {CH_LEAD: notes}
|
||||
|
||||
|
||||
def pad_sustained(bars, vel_mult=1.0):
|
||||
"""Sustained pad — 4-note voicings."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
base = ci * BEATS_PER_CHORD
|
||||
for pitch in ch["chord"]:
|
||||
notes.append(_mn(base, 7.5, pitch, int(60 * vel_mult)))
|
||||
return {CH_PAD: notes}
|
||||
|
||||
|
||||
def pad_swell(bars, vel_mult=1.0):
|
||||
"""Pad swell for pre-chorus — crescendo within chord."""
|
||||
notes = []
|
||||
total = bars * 4
|
||||
chords = total // BEATS_PER_CHORD
|
||||
for ci in range(chords):
|
||||
ch = PROGRESSION[ci % 4]
|
||||
base = ci * BEATS_PER_CHORD
|
||||
for pitch in ch["chord"]:
|
||||
notes.append(_mn(base, 4.0, pitch, int(45 * vel_mult)))
|
||||
notes.append(_mn(base + 4, 3.5, pitch, int(70 * vel_mult)))
|
||||
return {CH_PAD: notes}
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# PATTERN DEFINITIONS — 20 patterns
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
# All generators return {ch_idx: [notes]}
|
||||
ALL_GENERATORS = {
|
||||
"dembow_kick": dembow_kick,
|
||||
"perreador_kick": perreador_kick,
|
||||
"sparse_kick": sparse_kick,
|
||||
"snare_std": snare_standard,
|
||||
"snare_intense": snare_intense,
|
||||
"hh_offbeat": hihat_offbeat,
|
||||
"hh_8th": hihat_8th,
|
||||
"hh_16th": hihat_16th,
|
||||
"clap_std": clap_standard,
|
||||
"clap_soft": clap_soft,
|
||||
"perc_offbeat": perc_offbeat,
|
||||
"rim_build": rim_build,
|
||||
"bass_full": bass_808_full,
|
||||
"bass_sparse": bass_808_sparse,
|
||||
"bell_chords": bell_chords,
|
||||
"bell_sparse": bell_sparse,
|
||||
"lead_hook": lead_hook,
|
||||
"pad_sustained": pad_sustained,
|
||||
"pad_swell": pad_swell,
|
||||
}
|
||||
|
||||
PATTERNS = [
|
||||
{"id": 1, "name": "Kick Dembow", "gen": "dembow_kick", "bars": 8},
|
||||
{"id": 2, "name": "Kick Perreador", "gen": "perreador_kick","bars": 8},
|
||||
{"id": 3, "name": "Kick Sparse", "gen": "sparse_kick", "bars": 8},
|
||||
{"id": 4, "name": "Snare Standard", "gen": "snare_std", "bars": 8},
|
||||
{"id": 5, "name": "Snare Intense", "gen": "snare_intense", "bars": 8},
|
||||
{"id": 6, "name": "HH Offbeat", "gen": "hh_offbeat", "bars": 8},
|
||||
{"id": 7, "name": "HH 8th", "gen": "hh_8th", "bars": 8},
|
||||
{"id": 8, "name": "HH 16th Full", "gen": "hh_16th", "bars": 8},
|
||||
{"id": 9, "name": "Clap Standard", "gen": "clap_std", "bars": 8},
|
||||
{"id": 10, "name": "Perc Offbeat", "gen": "perc_offbeat", "bars": 8},
|
||||
{"id": 11, "name": "Rim Build", "gen": "rim_build", "bars": 4},
|
||||
{"id": 12, "name": "808 Bass Full", "gen": "bass_full", "bars": 8},
|
||||
{"id": 13, "name": "808 Bass Sparse", "gen": "bass_sparse", "bars": 8},
|
||||
{"id": 14, "name": "Bell Chords", "gen": "bell_chords", "bars": 8},
|
||||
{"id": 15, "name": "Bell Sparse", "gen": "bell_sparse", "bars": 8},
|
||||
{"id": 16, "name": "Lead Hook", "gen": "lead_hook", "bars": 8},
|
||||
{"id": 17, "name": "Pad Sustained", "gen": "pad_sustained", "bars": 8},
|
||||
{"id": 18, "name": "Pad Swell", "gen": "pad_swell", "bars": 8},
|
||||
]
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# ARRANGEMENT — 48 bars, 7 sections
|
||||
# 10 tracks (one per sampler channel Ch10-19)
|
||||
# Track index in arrangement: 0=kick, 1=snare, 2=hh, 3=808, 4=bell,
|
||||
# 5=lead, 6=pad, 7=clap, 8=perc, 9=rim
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
ARRANGEMENT_ITEMS = [
|
||||
# INTRO (0-4): ghostly, sparse
|
||||
{"pattern": 3, "bar": 0, "bars": 4, "track": 0}, # sparse kick
|
||||
{"pattern": 6, "bar": 0, "bars": 4, "track": 2}, # offbeat HH
|
||||
{"pattern": 13, "bar": 0, "bars": 4, "track": 3}, # sparse 808
|
||||
{"pattern": 15, "bar": 0, "bars": 4, "track": 4}, # sparse bell
|
||||
{"pattern": 17, "bar": 0, "bars": 4, "track": 6}, # pad sustained
|
||||
|
||||
# VERSE 1 (4-12): warming up
|
||||
{"pattern": 1, "bar": 4, "bars": 8, "track": 0}, # dembow kick
|
||||
{"pattern": 4, "bar": 4, "bars": 8, "track": 1}, # snare std
|
||||
{"pattern": 7, "bar": 4, "bars": 8, "track": 2}, # HH 8th
|
||||
{"pattern": 12, "bar": 4, "bars": 8, "track": 3}, # 808 full
|
||||
{"pattern": 15, "bar": 4, "bars": 8, "track": 4}, # sparse bell
|
||||
{"pattern": 17, "bar": 4, "bars": 8, "track": 6}, # pad
|
||||
|
||||
# PRE-CHORUS (12-16): building tension
|
||||
{"pattern": 1, "bar": 12, "bars": 4, "track": 0}, # dembow kick
|
||||
{"pattern": 5, "bar": 12, "bars": 4, "track": 1}, # snare intense
|
||||
{"pattern": 11, "bar": 12, "bars": 4, "track": 9}, # rim build
|
||||
{"pattern": 7, "bar": 12, "bars": 4, "track": 2}, # HH 8th
|
||||
{"pattern": 12, "bar": 12, "bars": 4, "track": 3}, # 808 full
|
||||
{"pattern": 14, "bar": 12, "bars": 4, "track": 4}, # bell chords
|
||||
{"pattern": 18, "bar": 12, "bars": 4, "track": 6}, # pad swell
|
||||
|
||||
# CHORUS (16-24): FULL ENERGY
|
||||
{"pattern": 2, "bar": 16, "bars": 8, "track": 0}, # perreador kick!
|
||||
{"pattern": 5, "bar": 16, "bars": 8, "track": 1}, # snare intense
|
||||
{"pattern": 8, "bar": 16, "bars": 8, "track": 2}, # HH 16th
|
||||
{"pattern": 9, "bar": 16, "bars": 8, "track": 7}, # clap
|
||||
{"pattern": 10, "bar": 16, "bars": 8, "track": 8}, # perc offbeat
|
||||
{"pattern": 12, "bar": 16, "bars": 8, "track": 3}, # 808 full
|
||||
{"pattern": 14, "bar": 16, "bars": 8, "track": 4}, # bell chords
|
||||
{"pattern": 16, "bar": 16, "bars": 8, "track": 5}, # lead hook
|
||||
{"pattern": 17, "bar": 16, "bars": 8, "track": 6}, # pad
|
||||
|
||||
# VERSE 2 (24-32): energy maintained, no lead
|
||||
{"pattern": 1, "bar": 24, "bars": 8, "track": 0}, # dembow kick
|
||||
{"pattern": 4, "bar": 24, "bars": 8, "track": 1}, # snare std
|
||||
{"pattern": 7, "bar": 24, "bars": 8, "track": 2}, # HH 8th
|
||||
{"pattern": 9, "bar": 24, "bars": 8, "track": 7}, # clap
|
||||
{"pattern": 12, "bar": 24, "bars": 8, "track": 3}, # 808 full
|
||||
{"pattern": 14, "bar": 24, "bars": 8, "track": 4}, # bell chords
|
||||
{"pattern": 17, "bar": 24, "bars": 8, "track": 6}, # pad
|
||||
|
||||
# BREAKDOWN (32-36): stripped
|
||||
{"pattern": 3, "bar": 32, "bars": 4, "track": 0}, # sparse kick
|
||||
{"pattern": 6, "bar": 32, "bars": 4, "track": 2}, # offbeat HH
|
||||
{"pattern": 13, "bar": 32, "bars": 4, "track": 3}, # sparse 808
|
||||
{"pattern": 15, "bar": 32, "bars": 4, "track": 4}, # sparse bell
|
||||
{"pattern": 17, "bar": 32, "bars": 4, "track": 6}, # pad
|
||||
|
||||
# OUTRO (36-48): fading
|
||||
{"pattern": 1, "bar": 36, "bars": 12, "track": 0}, # dembow kick
|
||||
{"pattern": 4, "bar": 36, "bars": 12, "track": 1}, # snare std
|
||||
{"pattern": 7, "bar": 36, "bars": 12, "track": 2}, # HH 8th
|
||||
{"pattern": 17, "bar": 36, "bars": 12, "track": 6}, # pad
|
||||
]
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# HEADER BUILDER
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
def _read_ev(data, pos):
|
||||
s = pos
|
||||
ib = data[pos]; pos += 1
|
||||
if ib < 64: return pos + 1, s, ib, data[s + 1], "byte"
|
||||
elif ib < 128: return pos + 2, s, ib, struct.unpack("<H", data[pos:pos + 2])[0], "word"
|
||||
elif ib < 192: return pos + 4, s, ib, struct.unpack("<I", data[pos:pos + 4])[0], "dword"
|
||||
else:
|
||||
sz = 0; sh = 0
|
||||
while True:
|
||||
b = data[pos]; pos += 1
|
||||
sz |= (b & 0x7F) << sh; sh += 7
|
||||
if not (b & 0x80): break
|
||||
return pos + sz, s, ib, data[pos:pos + sz], "data"
|
||||
|
||||
|
||||
def build_header(ref_bytes):
|
||||
pos = 22
|
||||
first_pat = None
|
||||
while pos < len(ref_bytes):
|
||||
np, st, ib, val, vt = _read_ev(ref_bytes, pos)
|
||||
if ib == EventID.PatNew:
|
||||
first_pat = st
|
||||
break
|
||||
pos = np
|
||||
if first_pat is None:
|
||||
raise ValueError("No PatNew found")
|
||||
header = bytearray(ref_bytes[22:first_pat])
|
||||
p = 0
|
||||
while p < len(header):
|
||||
np, _, ib, val, vt = _read_ev(bytes(header), p)
|
||||
if ib == EventID.Tempo:
|
||||
struct.pack_into("<I", header, p + 1, BPM * 1000)
|
||||
break
|
||||
p = np
|
||||
return bytes(header)
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# PATTERN BUILDER
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
def _conv(notes):
|
||||
return [{"position": n["pos"], "length": n["len"], "key": n["key"], "velocity": n["vel"]} for n in notes]
|
||||
|
||||
|
||||
def build_all_patterns():
|
||||
buf = bytearray()
|
||||
for pat_def in PATTERNS:
|
||||
buf += encode_word_event(EventID.PatNew, pat_def["id"] - 1)
|
||||
buf += encode_text_event(EventID.PatName, pat_def["name"])
|
||||
notes_by_ch = ALL_GENERATORS[pat_def["gen"]](pat_def["bars"])
|
||||
for ch_idx, raw_notes in notes_by_ch.items():
|
||||
if not raw_notes:
|
||||
continue
|
||||
buf += encode_data_event(EventID.PatNotes, encode_notes_block(ch_idx, _conv(raw_notes), PPQ))
|
||||
return bytes(buf)
|
||||
|
||||
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
# MAIN BUILD
|
||||
# ══════════════════════════════════════════════════════════════════════════════
|
||||
|
||||
def build_fuego():
|
||||
print("=" * 60)
|
||||
print("FUEGO reggaeton — REAL SAMPLES from library")
|
||||
print("=" * 60)
|
||||
print(f"Progression: Am -> Dm -> F -> E")
|
||||
print(f"Samples from: libreria/reggaeton/")
|
||||
print(f"Channels: Ch10-19 (all sampler)")
|
||||
print(f"Arrangement: 48 bars, 7 sections")
|
||||
print("=" * 60)
|
||||
|
||||
assert os.path.isfile(REF_FLP), f"MISSING: {REF_FLP}"
|
||||
ref_bytes = open(REF_FLP, "rb").read()
|
||||
num_channels = struct.unpack("<H", ref_bytes[10:12])[0]
|
||||
print(f"\nReference: {len(ref_bytes):,} bytes, {num_channels} channels")
|
||||
|
||||
# 1. Load channels — ALL 10 samplers get real samples from fuego_samples/
|
||||
print("\n[1/4] Loading channels with real samples...")
|
||||
loader = ChannelSkeletonLoader(REF_FLP, CH11_TMPL, SAMPLES_DIR)
|
||||
|
||||
# All channels use samples from fuego_samples/
|
||||
channel_bytes = loader.load(melodic_map=SAMPLE_ASSIGNMENT)
|
||||
print(f" Channels: {len(channel_bytes):,} bytes")
|
||||
for ch_idx in sorted(SAMPLE_ASSIGNMENT.keys()):
|
||||
_, w = SAMPLE_ASSIGNMENT[ch_idx]
|
||||
print(f" Ch{ch_idx}: {w}")
|
||||
|
||||
# 2. Build header + patterns
|
||||
print("\n[2/4] Building header + patterns...")
|
||||
header_bytes = build_header(ref_bytes)
|
||||
pattern_bytes = build_all_patterns()
|
||||
print(f" Header: {len(header_bytes):,} bytes")
|
||||
print(f" Patterns: {len(pattern_bytes):,} bytes ({len(PATTERNS)} patterns)")
|
||||
|
||||
# 3. Build arrangement
|
||||
print("\n[3/4] Building arrangement...")
|
||||
track_data_template = build_track_data_template(ref_bytes)
|
||||
items = [
|
||||
ArrangementItem(
|
||||
pattern_id=it["pattern"], bar=it["bar"],
|
||||
num_bars=it["bars"], track_index=it["track"],
|
||||
)
|
||||
for it in ARRANGEMENT_ITEMS
|
||||
]
|
||||
arrangement_bytes = build_arrangement_section(items, track_data_template, ppq=PPQ)
|
||||
print(f" Arrangement: {len(arrangement_bytes):,} bytes ({len(items)} items)")
|
||||
|
||||
# 4. Assemble
|
||||
print("\n[4/4] Assembling FLP...")
|
||||
body = header_bytes + pattern_bytes + channel_bytes + arrangement_bytes
|
||||
flp = (
|
||||
struct.pack("<4sIhHH", b"FLhd", 6, 0, num_channels, PPQ)
|
||||
+ b"FLdt" + struct.pack("<I", len(body))
|
||||
+ body
|
||||
)
|
||||
|
||||
with open(FLP_OUT, "wb") as f:
|
||||
f.write(flp)
|
||||
|
||||
duration = (48 * 4 / BPM) * 60
|
||||
print(f"\n{'=' * 60}")
|
||||
print(f" Output: {FLP_OUT}")
|
||||
print(f" Size: {len(flp):,} bytes")
|
||||
print(f" Duration: ~{duration:.0f}s (48 bars @ {BPM} BPM)")
|
||||
print(f" Channels: {num_channels} (Ch0-9 plugin, Ch10-19 sampler)")
|
||||
print(f" Patterns: {len(PATTERNS)}")
|
||||
print(f" Sections: INTRO -> VERSE1 -> PRE-CHORUS -> CHORUS -> VERSE2 -> BREAKDOWN -> OUTRO")
|
||||
print(f"{'=' * 60}")
|
||||
|
||||
return flp
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
build_fuego()
|
||||
Reference in New Issue
Block a user