rvlib-shipkit 2.3.0 → 2.4.0

package/src/trailer/score/gm.ts

@@ -0,0 +1,90 @@
+// the General MIDI instruments a score track plays through the soundfont: the 128 programs and the drum keys by name,
+// and `gm()`, the instrument data a `gm:<name>` track or a code block names. Pure: FluidSynth renders them (gm-render.ts)
+import type { InstrumentDef } from './pattern.ts'
+
+/** the 128 programs in order, each a short kebab name */
+export const GM_PROGRAMS = [
+    'acoustic-grand', 'bright-acoustic', 'electric-grand', 'honky-tonk', 'electric-piano-1', 'electric-piano-2', 'harpsichord', 'clavinet',
+    'celesta', 'glockenspiel', 'music-box', 'vibraphone', 'marimba', 'xylophone', 'tubular-bells', 'dulcimer',
+    'drawbar-organ', 'percussive-organ', 'rock-organ', 'church-organ', 'reed-organ', 'accordion', 'harmonica', 'tango-accordion',
+    'nylon-guitar', 'steel-guitar', 'jazz-guitar', 'clean-guitar', 'muted-guitar', 'overdrive-guitar', 'distortion-guitar', 'guitar-harmonics',
+    'acoustic-bass', 'finger-bass', 'pick-bass', 'fretless-bass', 'slap-bass-1', 'slap-bass-2', 'synth-bass-1', 'synth-bass-2',
+    'violin', 'viola', 'cello', 'contrabass', 'tremolo-strings', 'pizzicato-strings', 'harp', 'timpani',
+    'strings', 'slow-strings', 'synth-strings-1', 'synth-strings-2', 'choir-aahs', 'voice-oohs', 'synth-choir', 'orchestra-hit',
+    'trumpet', 'trombone', 'tuba', 'muted-trumpet', 'french-horn', 'brass-section', 'synth-brass-1', 'synth-brass-2',
+    'soprano-sax', 'alto-sax', 'tenor-sax', 'baritone-sax', 'oboe', 'english-horn', 'bassoon', 'clarinet',
+    'piccolo', 'flute', 'recorder', 'pan-flute', 'blown-bottle', 'shakuhachi', 'whistle', 'ocarina',
+    'square-lead', 'saw-lead', 'calliope-lead', 'chiff-lead', 'charang-lead', 'voice-lead', 'fifths-lead', 'bass-lead',
+    'new-age-pad', 'warm-pad', 'polysynth-pad', 'choir-pad', 'bowed-pad', 'metallic-pad', 'halo-pad', 'sweep-pad',
+    'rain-fx', 'soundtrack-fx', 'crystal-fx', 'atmosphere-fx', 'brightness-fx', 'goblins-fx', 'echoes-fx', 'sci-fi-fx',
+    'sitar', 'banjo', 'shamisen', 'koto', 'kalimba', 'bagpipe', 'fiddle', 'shanai',
+    'tinkle-bell', 'agogo', 'steel-drums', 'woodblock', 'taiko-drum', 'melodic-tom', 'synth-drum', 'reverse-cymbal',
+    'guitar-fret-noise', 'breath-noise', 'seashore', 'bird-tweet', 'telephone-ring', 'helicopter', 'applause', 'gunshot',
+] as const
+
+/** the drum keys of channel 10 (35 to 81), by name */
+export const GM_DRUMS: Readonly<Record<string, number>> = {
+    'kick-2': 35, kick: 36, 'side-stick': 37, snare: 38, clap: 39, 'electric-snare': 40, 'low-floor-tom': 41, 'closed-hat': 42,
+    'high-floor-tom': 43, 'pedal-hat': 44, 'low-tom': 45, 'open-hat': 46, 'low-mid-tom': 47, 'high-mid-tom': 48, crash: 49, 'high-tom': 50,
+    ride: 51, china: 52, 'ride-bell': 53, tambourine: 54, splash: 55, cowbell: 56, 'crash-2': 57, vibraslap: 58,
+    'ride-2': 59, 'high-bongo': 60, 'low-bongo': 61, 'mute-high-conga': 62, 'open-high-conga': 63, 'low-conga': 64, 'high-timbale': 65, 'low-timbale': 66,
+    'high-agogo': 67, 'low-agogo': 68, cabasa: 69, maracas: 70, 'short-whistle': 71, 'long-whistle': 72, 'short-guiro': 73, 'long-guiro': 74,
+    claves: 75, 'high-woodblock': 76, 'low-woodblock': 77, 'mute-cuica': 78, 'open-cuica': 79, 'mute-triangle': 80, 'open-triangle': 81,
+}
+
+/** the drum kits of bank 128 by program: standard 0, room 8, power 16, electronic 24, 808 25, jazz 32, brush 40, orchestra 48 */
+export const GM_KITS = { standard: 0, room: 8, power: 16, electronic: 24, tr808: 25, jazz: 32, brush: 40, orchestra: 48 } as const
+
+/** a GM program or a drum of a kit */
+export interface GmVoice {
+    program: number
+    /** a drum: its key on channel 10, `program` its kit */
+    drum?: number
+}
+
+export interface GmOptions {
+    /** 0..1, default 0.8 */
+    vol?: number
+    pan?: number
+    reverb?: number
+    /** a drum's kit: a number or a name of GM_KITS */
+    kit?: number | keyof typeof GM_KITS
+}
+
+/** a program or a drum by name or number: `acoustic-grand`, 48, `kick`; null when no such name */
+export function gmVoice(name: string | number, kit: GmOptions['kit'] = 0): GmVoice | null {
+    const k = typeof kit === 'number' ? kit : GM_KITS[kit]
+    if (typeof name === 'number' || /^\d+$/.test(name)) {
+        const n = Number(name)
+        return Number.isInteger(n) && n >= 0 && n < 128 ? { program: n } : null
+    }
+    const p = (GM_PROGRAMS as readonly string[]).indexOf(name)
+    if (p >= 0) return { program: p }
+    const d = GM_DRUMS[name]
+    return d === undefined || k === undefined ? null : { program: k, drum: d }
+}
+
+/** the instrument a track plays through the soundfont: `gm('strings', { vol: 0.7, pan: -0.3 })`, `gm(48)`, `gm('kick', { kit: 'brush' })` */
+export function gm(name: string | number, o: GmOptions = {}): InstrumentDef {
+    const v = gmVoice(name, o.kit)
+    if (!v) throw new Error(`gm ${name}: no General MIDI program or drum of that name (sk sound gm lists them)`)
+    return {
+        osc: 'gm',
+        gm: v,
+        vol: o.vol ?? 0.8,
+        env: { a: 0, d: 0, s: 1, r: 0 },
+        ...(o.pan !== undefined ? { pan: o.pan } : {}),
+        ...(o.reverb !== undefined ? { reverb: o.reverb } : {}),
+    }
+}
+
+/** the GM name an instrument name `gm:<name>` holds, else null */
+export const gmName = (instrument: string): string | null => (instrument.startsWith('gm:') ? instrument.slice(3) : null)
+
+/** the programs and drums as lines: what `sk sound gm` prints */
+export function gmTable(): string[] {
+    const rows = GM_PROGRAMS.map((n, i) => `${String(i).padStart(3)} ${n}`)
+    const drums = Object.entries(GM_DRUMS).map(([n, k]) => `${String(k).padStart(3)} ${n}`)
+    const kits = Object.entries(GM_KITS).map(([n, k]) => `${String(k).padStart(3)} ${n}`)
+    return ['programs (track x gm:<name>, gm(<name or number>)):', ...rows, '', 'drums (drums k=gm:<name>, gm(<name>, { kit })):', ...drums, '', 'kits (gm(<drum>, { kit: <name or number> })):', ...kits]
+}

package/src/trailer/score/midi.ts

@@ -0,0 +1,143 @@
+// the score as a Standard MIDI File: `scoreMidi` writes the whole score for a DAW (a track per score track, the
+// sections' tempos and meters), `stemMidi` one GM instrument's notes at a fixed clock for FluidSynth to render.
+// Pure: bytes out, no file here
+import type { ScheduledNote, CompiledScore } from './score.ts'
+import type { InstrumentDef } from './pattern.ts'
+import { SCORE_LEAD } from '../grammar.ts'
+
+interface Ev {
+    tick: number
+    /** a sort key inside one tick: note offs first, then meta and program changes, then note ons */
+    order: number
+    data: number[]
+}
+
+const vlq = (n: number): number[] => {
+    const out = [n & 0x7f]
+    for (let v = n >> 7; v > 0; v >>= 7) out.unshift((v & 0x7f) | 0x80)
+    return out
+}
+
+const u32 = (n: number): number[] => [(n >>> 24) & 0xff, (n >>> 16) & 0xff, (n >>> 8) & 0xff, n & 0xff]
+
+function chunk(type: string, body: number[]): number[] {
+    return [...Buffer.from(type, 'latin1'), ...u32(body.length), ...body]
+}
+
+function trackChunk(events: Ev[], name: string | null, end: number): number[] {
+    const sorted = [...events].sort((a, b) => a.tick - b.tick || a.order - b.order)
+    const body: number[] = []
+    let at = 0
+    if (name !== null) {
+        const bytes = [...Buffer.from(name, 'utf8')]
+        body.push(0, 0xff, 0x03, ...vlq(bytes.length), ...bytes)
+    }
+    for (const e of sorted) {
+        body.push(...vlq(Math.max(0, e.tick - at)), ...e.data)
+        at = Math.max(at, e.tick)
+    }
+    body.push(...vlq(Math.max(0, end - at)), 0xff, 0x2f, 0x00)
+    return chunk('MTrk', body)
+}
+
+/** a type 1 file: the conductor track, then each track */
+function smf(ppq: number, conductor: Ev[], tracks: { name: string; events: Ev[] }[], end: number): Uint8Array {
+    const head = chunk('MThd', [0, 1, 0, tracks.length + 1, (ppq >> 8) & 0xff, ppq & 0xff])
+    return new Uint8Array([...head, ...trackChunk(conductor, null, end), ...tracks.flatMap((t) => trackChunk(t.events, t.name, end))])
+}
+
+const velocity = (vol: number): number => Math.max(1, Math.min(127, Math.round(127 * vol)))
+
+/** what a synth instrument of the default palette is written as: its nearest GM program, a drum's key */
+const NEAREST: Readonly<Record<string, number>> = {
+    lead: 80, lead25: 80, flute: 73, ocarina: 79, reed: 71, keys: 4, glock: 9, cello: 42, bell: 14, pluck: 45, arp: 81, harmony: 81,
+    pad: 89, strings: 48, brass: 61, bass: 33, bassPulse: 38, bassSaw: 39, sub: 38,
+}
+const NEAREST_DRUM: Readonly<Record<string, number>> = { kick: 36, snare: 38, clap: 39, hat: 42, openhat: 46, crash: 49, tom: 45, shaker: 70 }
+
+/** a note as the file writes it: a drum on channel 10 at its key, else a program */
+function gmOf(name: string, inst: InstrumentDef | undefined, drum: boolean): { drum: true; key: number; kit: number } | { drum: false; program: number } {
+    if (inst?.gm) return inst.gm.drum !== undefined ? { drum: true, key: inst.gm.drum, kit: inst.gm.program } : { drum: false, program: inst.gm.program }
+    if (drum || inst?.osc === 'noise') return { drum: true, key: inst?.midi ?? NEAREST_DRUM[name] ?? 38, kit: 0 }
+    return { drum: false, program: inst?.midi ?? NEAREST[name] ?? 80 }
+}
+
+const PPQ = 480
+
+/** the whole score as a .mid: each score track a MIDI track, the sections' tempos and meters on the conductor track,
+ *  the score's time from its first section on; a note past the stop is cut there */
+export function scoreMidi(score: CompiledScore): Uint8Array {
+    const secs = score.sections
+    // each section's first tick, the score clock starting at the first section
+    const starts: { at: number; tick: number; bpm: number }[] = []
+    let tick = 0
+    for (const s of secs) {
+        starts.push({ at: s.at, tick, bpm: s.bpm })
+        tick += Math.round((s.seconds * s.bpm * PPQ) / 60)
+    }
+    const tickOf = (time: number): number => {
+        let k = 0
+        while (k + 1 < starts.length && starts[k + 1]!.at <= time + 1e-9) k++
+        const s = starts[k] ?? { at: SCORE_LEAD, tick: 0, bpm: 120 }
+        return Math.max(0, s.tick + Math.round(((time - s.at) * s.bpm * PPQ) / 60))
+    }
+    const stop = score.stop ?? Number.POSITIVE_INFINITY
+    const end = Math.min(tick, tickOf(stop))
+    const conductor: Ev[] = []
+    let meter = 0
+    let bpm = 0
+    for (const [i, s] of secs.entries()) {
+        const t = starts[i]!.tick
+        if (s.bpm !== bpm) conductor.push({ tick: t, order: 1, data: [0xff, 0x51, 0x03, ...u32(Math.round(60_000_000 / s.bpm)).slice(1)] })
+        if (s.meter !== meter) conductor.push({ tick: t, order: 1, data: [0xff, 0x58, 0x04, s.meter, 2, 24, 8] })
+        bpm = s.bpm
+        meter = s.meter
+    }
+    const byTrack = new Map<string, ScheduledNote[]>()
+    for (const n of score.notes) {
+        if (n.time >= stop) continue
+        byTrack.set(n.track, [...(byTrack.get(n.track) ?? []), n])
+    }
+    let next = 0
+    const tracks = [...byTrack.entries()].map(([name, notes]) => {
+        const channel = next === 9 ? ++next : next
+        next = Math.min(15, channel + 1)
+        const events: Ev[] = []
+        const program = new Map<number, number>()
+        for (const n of notes) {
+            const inst = score.instruments[n.instrument]
+            const g = gmOf(n.instrument, inst, n.midi === null)
+            const ch = g.drum ? 9 : channel
+            const want = g.drum ? g.kit : g.program
+            const a = tickOf(n.time)
+            if (program.get(ch) !== want && !(g.drum && want === 0 && !program.has(ch))) events.push({ tick: a, order: 1, data: [0xc0 | ch, want] })
+            program.set(ch, want)
+            const key = g.drum ? g.key : n.midi!
+            const b = Math.max(a + 1, Math.min(end, tickOf(Math.min(stop, n.time + n.dur))))
+            events.push({ tick: a, order: 2, data: [0x90 | ch, key, velocity(n.vol)] })
+            events.push({ tick: b, order: 0, data: [0x80 | ch, key, 0] })
+        }
+        return { name, events }
+    })
+    return smf(PPQ, conductor, tracks, end)
+}
+
+/** the clock a stem is written at: 120 bpm, so a tick is 1/1920 s */
+const STEM_PPQ = 960
+const STEM_TPS = (120 * STEM_PPQ) / 60
+
+/** one GM instrument's notes as a .mid at a fixed clock, its time the render's (lead counted), cut at `end` seconds */
+export function stemMidi(notes: readonly ScheduledNote[], v: { program: number; drum?: number }, end: number): Uint8Array {
+    const ch = v.drum !== undefined ? 9 : 0
+    const t = (s: number): number => Math.round(Math.min(s, end) * STEM_TPS)
+    const events: Ev[] = [{ tick: 0, order: 1, data: [0xc0 | ch, v.program] }]
+    for (const n of notes) {
+        if (n.time >= end) continue
+        const key = v.drum ?? n.midi ?? 60
+        const a = t(n.time)
+        events.push({ tick: a, order: 2, data: [0x90 | ch, key, velocity(n.vol)] })
+        events.push({ tick: Math.max(a + 1, t(n.time + n.dur)), order: 0, data: [0x80 | ch, key, 0] })
+    }
+    const conductor: Ev[] = [{ tick: 0, order: 1, data: [0xff, 0x51, 0x03, ...u32(500_000).slice(1)] }]
+    return smf(STEM_PPQ, conductor, [{ name: 'stem', events }], t(end))
+}

package/src/trailer/score/pattern.ts

@@ -1,8 +1,9 @@
 // the score's note grammar and its instruments: one token a grid row, an instrument as plain data the synth plays.
 // Pure: no audio here (synth.ts renders)
 
-/** oscillator families: chiptune roots (pulse, wave, noise) plus the smoother modern ones */
-export type Osc = 'pulse' | 'saw' | 'triangle' | 'sine' | 'wave' | 'noise'
+/** oscillator families: chiptune roots (pulse, wave, noise) plus the smoother modern ones; `gm` a General MIDI
+ *  program the soundfont plays (gm.ts) */
+export type Osc = 'pulse' | 'saw' | 'triangle' | 'sine' | 'wave' | 'noise' | 'gm'
 
 export interface InstrumentDef {
     osc: Osc
@@ -34,14 +35,19 @@ export interface InstrumentDef {
     sweep?: { semis: number; time: number }
     /** the midi note a drum letter plays this instrument at, default 60 */
     pitch?: number
+    /** gm only: the program, or a drum key of a kit, the soundfont plays */
+    gm?: { program: number; drum?: number }
+    /** what the score's .mid writes it as: a GM program, a drum's key for a drum instrument */
+    midi?: number
 }
 
 // one token a row, whitespace separated, '|' ignored:
 //   C4 C#4 Db4    note (octave 0..8)       .    hold the previous note
 //   -             silence                  k    drum letter (from `drums`)
+//   D4+F4+A4      a chord: its notes start and hold together
 // zero length modifiers glued before a row token: `@lead:C4` switches instrument, `v8:C4` sets the volume 0..15
 // (15 = the instrument's vol) from that note on
-type Row = { kind: 'note'; midi: number } | { kind: 'hold' } | { kind: 'off' } | { kind: 'drum'; letter: string }
+type Row = { kind: 'note'; midi: number; chord?: number[] } | { kind: 'hold' } | { kind: 'off' } | { kind: 'drum'; letter: string }
 
 export interface RowEvent {
     row: Row
@@ -81,9 +87,10 @@ export function parsePattern(text: string, drums: Record<string, string> = {}):
         else if (body === '-') ev.row = { kind: 'off' }
         else if (drums[body] !== undefined) ev.row = { kind: 'drum', letter: body }
         else {
-            const midi = noteToMidi(body)
-            if (midi === null) throw new Error(`pattern token "${raw}": not a note, a drum letter, '.' or '-'`)
-            ev.row = { kind: 'note', midi }
+            const ms = body.split('+').map(noteToMidi)
+            if (ms.some((m) => m === null)) throw new Error(`pattern token "${raw}": not a note, a chord (D4+F4+A4), a drum letter, '.' or '-'`)
+            const [midi, ...more] = ms as number[]
+            ev.row = more.length > 0 ? { kind: 'note', midi: midi!, chord: more } : { kind: 'note', midi: midi! }
         }
         out.push(ev)
     }

package/src/trailer/score/score.ts

@@ -4,6 +4,7 @@
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { type Score, SCORE_LEAD, type Section, type TrailerError } from '../grammar.ts'
+import { gm, gmName } from './gm.ts'
 import { INST } from './palette.ts'
 import { type InstrumentDef, parsePattern, type RowEvent } from './pattern.ts'
 
@@ -34,14 +35,15 @@ export interface CompiledScore {
     /** where it cuts dead, its lead counted; null: it rings out */
     stop: number | null
     /** each section's span in the render, its lead counted */
-    sections: { name: string; at: number; seconds: number; notes: number }[]
+    sections: { name: string; at: number; seconds: number; notes: number; bpm: number; meter: number }[]
 }
 
 const here = import.meta.dir
 // the helpers every `code` block and `play` line reads without importing them
 const PRELUDE = [
-    `import { arp, bass, chart, mel, midiToNote, parseChord, rep, seq, transpose, voice } from ${JSON.stringify(join(here, 'compose.ts'))}`,
+    `import { arp, bass, chart, chords, mel, midiToNote, parseChord, rep, seq, transpose, voice } from ${JSON.stringify(join(here, 'compose.ts'))}`,
     `import { additive, INST, KIT } from ${JSON.stringify(join(here, 'palette.ts'))}`,
+    `import { gm } from ${JSON.stringify(join(here, 'gm.ts'))}`,
     "const rest = (n: number): string => Array.from({ length: n }, () => '-').join(' ')",
     'export const __plays: (() => unknown)[] = []',
     'const __play = (i: number, f: () => unknown): void => void (__plays[i] = f)',
@@ -107,23 +109,34 @@ export function compileScore(s: Score, sections: readonly Section[], dir: string
     const instruments = mod.instruments ?? INST
     if (typeof instruments !== 'object' || instruments === null)
         return { score: null, errors: [{ line: s.code?.line ?? s.line, message: 'the code block\'s instruments is no record: export const instruments = { … }' }] }
-    const inst = instruments as Record<string, InstrumentDef>
-    const names = (): string => Object.keys(inst).join(', ')
+    const inst: Record<string, InstrumentDef> = { ...(instruments as Record<string, InstrumentDef>) }
+    const names = (): string => `${Object.keys(inst).filter((k) => !gmName(k)).join(', ')}, or gm:<name> (sk sound gm)`
+    // a `gm:<name>` track or drum is the General MIDI instrument of that name
+    for (const name of [...s.tracks.map((tr) => tr.instrument), ...Object.values(s.drums), ...sections.flatMap((sec) => Object.values(sec.drums))]) {
+        const g = gmName(name)
+        if (g === null || inst[name]) continue
+        try {
+            inst[name] = gm(g)
+        } catch {
+            // an unknown name stays missing: the checks below name it at its line
+        }
+    }
     const values = new Map(plays.map((pl, i) => [pl, mod.__plays[i]]))
 
     const tracks = s.tracks
     for (const tr of tracks) if (!inst[tr.instrument]) errors.push({ line: tr.line, message: `track ${tr.name}: no instrument ${tr.instrument} (${names()})` })
     for (const [letter, name] of Object.entries(s.drums)) if (!inst[name]) errors.push({ line: s.line, message: `drums ${letter}=${name}: no instrument ${name} (${names()})` })
 
-    const state = new Map(tracks.map((tr) => [tr.name, { instrument: tr.instrument, vol: 15, open: null as ScheduledNote | null, prev: null as number | null }]))
+    const state = new Map(tracks.map((tr) => [tr.name, { instrument: tr.instrument, vol: 15, open: [] as ScheduledNote[], prev: null as number | null }]))
     const notes: ScheduledNote[] = []
     const spans: CompiledScore['sections'] = []
     let row0 = 0
-    const close = (st: { open: ScheduledNote | null }, time: number, row: number): void => {
-        if (!st.open) return
-        st.open.dur = time - st.open.time
-        st.open.rows = row - st.open.row
-        st.open = null
+    const close = (st: { open: ScheduledNote[] }, time: number, row: number): void => {
+        for (const n of st.open) {
+            n.dur = time - n.time
+            n.rows = row - n.row
+        }
+        st.open = []
     }
     for (const sec of sections) {
         const { bpm, grid, meter } = sec.clock ?? s.clock
@@ -132,7 +145,7 @@ export function compileScore(s: Score, sections: readonly Section[], dir: string
         const spr = 60 / bpm / grid
         const bars = (n: number): string => `${+(n / grid / meter).toFixed(3)} bars`
         const before = notes.length
-        spans.push({ name: sec.name, at: SCORE_LEAD + sec.at, seconds: sec.seconds, notes: 0 })
+        spans.push({ name: sec.name, at: SCORE_LEAD + sec.at, seconds: sec.seconds, notes: 0, bpm, meter })
         if (Math.abs(rowsExact - rows) > 1e-6) {
             errors.push({ line: sec.line, message: `section ${sec.name}: ${+sec.seconds.toFixed(4)} s is ${+rowsExact.toFixed(3)} rows of its grid (${grid} a beat), never a whole number` })
             continue
@@ -192,12 +205,13 @@ export function compileScore(s: Score, sections: readonly Section[], dir: string
                 close(st, time, row0 + r)
                 if (k.kind === 'off') return
                 const vol = (st.vol / 15) * tr.volume
-                if (k.kind === 'drum') st.open = { track: tr.name, row: row0 + r, rows: 1, midi: null, instrument: drums[k.letter] ?? st.instrument, vol, from: null, time, dur: spr }
+                if (k.kind === 'drum') st.open = [{ track: tr.name, row: row0 + r, rows: 1, midi: null, instrument: drums[k.letter] ?? st.instrument, vol, from: null, time, dur: spr }]
                 else {
-                    st.open = { track: tr.name, row: row0 + r, rows: 1, midi: k.midi, instrument: st.instrument, vol, from: st.prev, time, dur: spr }
+                    const one = (midi: number, from: number | null): ScheduledNote => ({ track: tr.name, row: row0 + r, rows: 1, midi, instrument: st.instrument, vol, from, time, dur: spr })
+                    st.open = [one(k.midi, st.prev), ...(k.chord ?? []).map((m) => one(m, null))]
                     st.prev = k.midi
                 }
-                notes.push(st.open)
+                notes.push(...st.open)
             })
         }
         spans.at(-1)!.notes = notes.length - before

package/src/trailer/score/sound.ts

@@ -2,11 +2,18 @@
 // like as numbers: each section's loudness and peak, since nobody hears a build. Silence under notes refuses
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { fluidIdentity } from '../sound/fluid.ts'
+import { gmInstruments, gmStems } from './gm-render.ts'
 import type { CompiledScore } from './score.ts'
 import { HOT, RATE, type Rendered, renderScore } from './synth.ts'
 
 /** the synth's sources: an edit to any renders every score again */
 const SYNTH = ['synth.ts', 'dsp.ts', 'pattern.ts'].map((f) => join(import.meta.dir, f))
+/** what renders a GM track besides: read only by a score that has one */
+const GM = ['gm-render.ts', 'midi.ts', '../sound/fluid.ts'].map((f) => join(import.meta.dir, f))
+
+/** where the render stops playing notes: its length, or the stop before it */
+const endOf = (score: CompiledScore, seconds: number): number => Math.min(Math.ceil(seconds), score.stop ?? Number.POSITIVE_INFINITY)
 
 export interface Level {
     name: string
@@ -92,6 +99,10 @@ export function wavOf(r: Rendered): Buffer {
 export function scoreWavFile(score: CompiledScore, seconds: number, dir: string): string {
     const h = new Bun.CryptoHasher('sha1').update(JSON.stringify([score.instruments, score.reverb ?? null, score.notes, score.stop, score.sections, Math.ceil(seconds), RATE]))
     for (const f of SYNTH) h.update(readFileSync(f))
+    if (gmInstruments(score, endOf(score, seconds)).length > 0) {
+        h.update(fluidIdentity())
+        for (const f of GM) h.update(readFileSync(f))
+    }
     return join(dir, `score-${h.digest('hex').slice(0, 16)}.wav`)
 }
 
@@ -102,7 +113,7 @@ export function scoreWav(score: CompiledScore, seconds: number, dir: string): {
     const meta = `${file}.levels.json`
     if (existsSync(file) && existsSync(meta)) return { file, made: false, levels: JSON.parse(readFileSync(meta, 'utf8')) as Level[], ms: 0 }
     const t0 = performance.now()
-    const r = renderScore(score, s)
+    const r = renderScore(score, s, RATE, gmStems(score, endOf(score, s), RATE))
     const lv = levels(r, score.sections)
     mkdirSync(dir, { recursive: true })
     writeFileSync(`${file}.part`, wavOf(r))

package/src/trailer/score/synth.ts

@@ -4,6 +4,7 @@
 // score sounds alike in either. No browser, no audio device
 import { applyEnvelope, biquad, compress, convolveInto, envPoints, softClip } from './dsp.ts'
 import { type InstrumentDef, midiToHz } from './pattern.ts'
+import type { Stem } from './gm-render.ts'
 import type { CompiledScore, ScheduledNote } from './score.ts'
 
 export const RATE = 48000
@@ -308,6 +309,26 @@ function mixRun(buf: Float32Array, n: number, at: number, l: Float32Array, r: Fl
     }
 }
 
+/** a GM stem into the bus at its instrument's volume and pan, and its share into the room */
+function mixStem(bus: Bus, st: Stem, inst: InstrumentDef | undefined): void {
+    if (!inst) return
+    const n = Math.min(bus.l.length, st.left.length)
+    const pan = inst.pan !== undefined && inst.pan !== 0 ? (Math.max(-1, Math.min(1, inst.pan)) + 1) / 2 : null
+    const gl = inst.vol * (pan === null ? 1 : Math.SQRT2 * Math.cos((pan * Math.PI) / 2))
+    const gr = inst.vol * (pan === null ? 1 : Math.SQRT2 * Math.sin((pan * Math.PI) / 2))
+    const send = bus.sendL && inst.reverb && inst.reverb > 0 ? inst.reverb : 0
+    for (let i = 0; i < n; i++) {
+        const l = st.left[i]! * gl
+        const r = st.right[i]! * gr
+        bus.l[i] = bus.l[i]! + l
+        bus.r[i] = bus.r[i]! + r
+        if (send > 0) {
+            bus.sendL![i] = bus.sendL![i]! + l * send
+            bus.sendR![i] = bus.sendR![i]! + r * send
+        }
+    }
+}
+
 /** the gain over the render: whole, then a dead stop or the closing fade at the end */
 function closeRun(l: Float32Array, r: Float32Array, rate: number, end: number, fade: number): void {
     const a = Math.max(0, Math.floor(end * rate))
@@ -321,7 +342,7 @@ function closeRun(l: Float32Array, r: Float32Array, rate: number, end: number, f
 
 /** `seconds` of the score from its start, rendered with a tail of TAIL_S: the notes starting before its end (and before
  *  its stop, if any) played, closed with a fade at the end, or cut dead at its stop */
-export function renderScore(score: CompiledScore, seconds: number, rate = RATE): Rendered {
+export function renderScore(score: CompiledScore, seconds: number, rate = RATE, stems: readonly Stem[] = []): Rendered {
     const n = Math.ceil(rate * (seconds + TAIL_S))
     const room = score.reverb && score.reverb.mix > 0 ? score.reverb : null
     const bus: Bus = { l: new Float32Array(n), r: new Float32Array(n), sendL: room ? new Float32Array(n) : null, sendR: room ? new Float32Array(n) : null }
@@ -330,8 +351,9 @@ export function renderScore(score: CompiledScore, seconds: number, rate = RATE):
     for (const note of score.notes) {
         if (note.time >= end) break
         const inst = score.instruments[note.instrument]
-        if (inst) playNote(bus, waves, inst, note)
+        if (inst && inst.osc !== 'gm') playNote(bus, waves, inst, note)
     }
+    for (const st of stems) mixStem(bus, st, score.instruments[st.instrument])
     if (room) {
         const ir = impulse(room.seconds, rate)
         convolveInto(bus.sendL!, bus.sendR!, ir[0], ir[1], bus.l, bus.r, impulseScale(ir, rate) * Math.min(1, room.mix * 1.6))

package/src/trailer/sound/audio.ts

@@ -0,0 +1,148 @@
+// what a made sound is, as numbers and one picture, since nobody hears a build: its length, peak, loudness, onsets
+// and its waveform png; and the trims a generator applies (the silence before, the tail, the first hit). ffmpeg does
+// the reading and the writing (trailer/ffmpeg.ts)
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { ffmpeg, loudness } from '../ffmpeg.ts'
+
+export const SOUND_RATE = 48000
+/** the envelope's window */
+const WIN_S = 0.01
+
+/** the file's samples, both channels, at SOUND_RATE */
+export async function decode(file: string): Promise<{ left: Float32Array; right: Float32Array }> {
+    const dir = mkdtempSync(join(tmpdir(), 'sk-sound-'))
+    try {
+        const raw = join(dir, 'pcm.f32')
+        await ffmpeg(['-y', '-v', 'error', '-i', file, '-ac', '2', '-ar', String(SOUND_RATE), '-f', 'f32le', raw])
+        const b = readFileSync(raw)
+        const all = new Float32Array(b.buffer, b.byteOffset, Math.floor(b.byteLength / 4))
+        const n = all.length >> 1
+        const left = new Float32Array(n)
+        const right = new Float32Array(n)
+        for (let i = 0; i < n; i++) {
+            left[i] = all[i * 2]!
+            right[i] = all[i * 2 + 1]!
+        }
+        return { left, right }
+    } finally {
+        rmSync(dir, { recursive: true, force: true })
+    }
+}
+
+const db = (x: number): number => (x > 1e-9 ? 20 * Math.log10(x) : -180)
+
+/** each window's RMS in dBFS, the louder channel */
+export function envelope(s: { left: Float32Array; right: Float32Array }): number[] {
+    const w = Math.round(WIN_S * SOUND_RATE)
+    const out: number[] = []
+    for (let a = 0; a < s.left.length; a += w) {
+        let l = 0
+        let r = 0
+        const b = Math.min(s.left.length, a + w)
+        for (let i = a; i < b; i++) {
+            l += s.left[i]! ** 2
+            r += s.right[i]! ** 2
+        }
+        out.push(db(Math.sqrt(Math.max(l, r) / Math.max(1, b - a))))
+    }
+    return out
+}
+
+/** the sample peak in dBFS */
+export function peakOf(s: { left: Float32Array; right: Float32Array }): number {
+    let p = 0
+    for (let i = 0; i < s.left.length; i++) p = Math.max(p, Math.abs(s.left[i]!), Math.abs(s.right[i]!))
+    return db(p)
+}
+
+/** the windows a new sound starts on: a rise of 9 dB over the 50 ms before, within 35 dB of the loudest window, 80 ms
+ *  after the last onset at least */
+export function onsets(env: readonly number[]): number[] {
+    const top = Math.max(...env)
+    const out: number[] = []
+    for (let i = 0; i < env.length; i++) {
+        if (env[i]! < top - 35) continue
+        const before = i === 0 ? -180 : Math.min(...env.slice(Math.max(0, i - 5), i))
+        if (env[i]! - before < 9) continue
+        if (out.length > 0 && i - out.at(-1)! < 8) continue
+        out.push(i)
+    }
+    return out
+}
+
+export interface Trim {
+    start: number
+    end: number
+    /** seconds of fade at the end */
+    fade: number
+}
+
+/** where a made sound starts and ends: the silence before cut (40 dB under its loudest window), the tail cut where it
+ *  stays `tailDb` under it; `hit`: only its first hit, also cut just before the next onset, its fade a share of it */
+export function trimOf(env: readonly number[], o: { tailDb: number; hit?: boolean }): Trim {
+    const top = Math.max(...env)
+    const first = Math.max(0, env.findIndex((x) => x >= top - 40) - 1)
+    let last = env.length - 1
+    while (last > first && env[last]! < top - o.tailDb) last--
+    if (!o.hit) return { start: first * WIN_S, end: (last + 1) * WIN_S, fade: 0.03 }
+    const next = onsets(env).find((i) => i > first + 2)
+    if (next !== undefined) last = Math.min(last, next - 2)
+    // the quiet floor between the hit and the next one is tail too
+    while (last > first && env[last]! < top - o.tailDb) last--
+    const len = (last + 1 - first) * WIN_S
+    return { start: first * WIN_S, end: (last + 1) * WIN_S, fade: Math.min(0.12, Math.max(0.02, len * 0.15)) }
+}
+
+/** the trimmed sound written as a 48 kHz 16 bit stereo wav */
+export async function writeTrimmed(src: string, out: string, t: Trim): Promise<void> {
+    const len = Math.max(0.02, t.end - t.start)
+    const fade = Math.min(t.fade, len / 2)
+    const af = [`atrim=${t.start.toFixed(3)}:${t.end.toFixed(3)}`, 'asetpts=PTS-STARTPTS', `afade=t=out:st=${(len - fade).toFixed(3)}:d=${fade.toFixed(3)}`].join(',')
+    await ffmpeg(['-y', '-v', 'error', '-i', src, '-af', af, '-ac', '2', '-ar', String(SOUND_RATE), '-c:a', 'pcm_s16le', out])
+}
+
+/** the true peak no made sound passes */
+const CEILING_DBTP = -1.5
+
+/** the trimmed sound written at its level: `lufs` its integrated loudness (a sound too short to measure, under 0.4 s,
+ *  set by its peak at -3 dBFS), `peak` its sample peak; never past -1.5 dBTP. A measured static gain, so a short line
+ *  lands where a long one does */
+export async function finish(src: string, out: string, t: Trim, level: { lufs: number } | { peak: number }): Promise<void> {
+    const trimmed = `${out}.trim.wav`
+    try {
+        await writeTrimmed(src, trimmed, t)
+        const peak = peakOf(await decode(trimmed))
+        const m = await loudness(trimmed)
+        const gain = 'peak' in level ? Math.min(level.peak - peak, CEILING_DBTP - m.truePeak) : m.lufs > -70 && t.end - t.start >= 0.4 ? Math.min(level.lufs - m.lufs, CEILING_DBTP - m.truePeak) : -3 - peak
+        await ffmpeg(['-y', '-v', 'error', '-i', trimmed, '-af', `volume=${gain.toFixed(2)}dB`, '-c:a', 'pcm_s16le', out])
+    } finally {
+        rmSync(trimmed, { force: true })
+    }
+}
+
+export interface Measures {
+    seconds: number
+    peak: number
+    lufs: number
+    /** seconds of each onset */
+    onsets: number[]
+}
+
+/** a sound as numbers */
+export async function measure(file: string): Promise<Measures> {
+    const s = await decode(file)
+    const env = envelope(s)
+    const { lufs } = await loudness(file)
+    return { seconds: +(s.left.length / SOUND_RATE).toFixed(3), peak: +peakOf(s).toFixed(1), lufs: +lufs.toFixed(1), onsets: onsets(env).map((i) => +(i * WIN_S).toFixed(2)) }
+}
+
+/** the measures as one line */
+export const measureLine = (m: Measures): string =>
+    `${m.seconds.toFixed(2)} s, peak ${m.peak.toFixed(1)} dBFS, ${Number.isFinite(m.lufs) ? m.lufs.toFixed(1) : '-inf'} LUFS, ${m.onsets.length} onset${m.onsets.length === 1 ? '' : 's'}${m.onsets.length ? ` at ${m.onsets.slice(0, 8).join(', ')}${m.onsets.length > 8 ? ' …' : ''} s` : ''}`
+
+/** the waveform as a png, 1200 by 240 */
+export async function waveformPng(file: string, png: string): Promise<void> {
+    await ffmpeg(['-y', '-v', 'error', '-i', file, '-filter_complex', 'showwavespic=s=1200x240:split_channels=1:colors=#f0c674|#81a2be', '-frames:v', '1', png])
+}