@datamoc/mw_games 0.18.0 → 0.20.0

package/dist/audio/SoundFont.d.ts

@@ -1,15 +1,4 @@
-/**
- * A SoundFont 2 reader: presets to instruments to sample zones, enough to play
- * General MIDI music with real samples. Supported: key and velocity ranges, root key
- * and tuning, sample loop modes, the volume envelope (attack, hold, decay, sustain,
- * release), pan and attenuation, with the global-zone and preset-plus-instrument
- * layering rules. Not supported: modulators, filters and LFOs, 24-bit samples, or
- * stereo-linked sample pairs beyond playing each side as its own mono voice.
- *
- * A SoundFont file is only data (recorded samples plus preset tables), so reading one
- * is ordinary format engineering; the licence that matters is the font's own, checked
- * before it ships, never here.
- */
+import { type MidiFile } from './Midi.ts';
 /** one mono sample: raw frames plus its loop region in frames and native rate */
 export interface SoundFontSample {
     data: Float32Array;
@@ -45,6 +34,11 @@ export interface SoundFont {
     hasPreset(bank: number, program: number): boolean;
     readonly presetCount: number;
 }
+/** one used program: the voice a game's MIDI files actually request */
+export interface SoundFontProgram {
+    bank: number;
+    program: number;
+}
 /**
  * Reads SoundFont 2 bytes into layered preset voices.
  *
@@ -61,4 +55,44 @@ export interface SoundFont {
  * ```
  */
 export declare function parseSoundFont(data: ArrayBuffer | ArrayBufferView): SoundFont;
+/**
+ * Every sampled voice the given MIDI files can request, as (bank, program) pairs:
+ * the channel voice in effect at each scheduled note, with drums mapped to bank 128
+ * the same way the renderer maps them. A game's compile step feeds this straight
+ * into `subsetSoundFont` so the shipped font carries only these programs.
+ *
+ * @example
+ * ```ts
+ * import { parseMidi, collectSoundFontUsage } from '@datamoc/mw_games/audio';
+ *
+ * declare const midiBytes: ArrayBuffer;
+ *
+ * const usage = collectSoundFontUsage([parseMidi(midiBytes)]);
+ * console.log(usage.length);
+ * ```
+ */
+export declare function collectSoundFontUsage(files: readonly MidiFile[]): SoundFontProgram[];
+/**
+ * Writes a smaller, valid SoundFont 2 file carrying only the used programs: their
+ * presets (names kept), instruments and samples, with zones, ranges, tuning,
+ * envelopes and sample loops copied verbatim and every index remapped. Zones that
+ * reference samples missing from the file (ROM samples) are dropped, matching what
+ * the reader voices for the full font; the library, genre and morphology metadata
+ * is zeroed and the INFO list, when present, rides along untouched. Modulator lists
+ * are emptied and 24-bit upper bits are dropped: the reader voices neither, so what
+ * it plays is unchanged, while a third-party player would miss those.
+ *
+ * @example
+ * ```ts
+ * import { parseMidi, collectSoundFontUsage, subsetSoundFont } from '@datamoc/mw_games/audio';
+ *
+ * declare const midiBytes: ArrayBuffer;
+ * declare const soundfontBytes: ArrayBuffer;
+ *
+ * const usage = collectSoundFontUsage([parseMidi(midiBytes)]);
+ * const pruned = subsetSoundFont(soundfontBytes, usage);
+ * console.log(usage.length, pruned.byteLength);
+ * ```
+ */
+export declare function subsetSoundFont(data: ArrayBuffer | ArrayBufferView, usage: readonly SoundFontProgram[]): ArrayBuffer;
 //# sourceMappingURL=SoundFont.d.ts.map

package/dist/audio/SoundFont.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoundFont.d.ts","sourceRoot":"","sources":["../../src/audio/SoundFont.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAoBH,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CAChB;AAQD,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;IACvF,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;AAmBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,eAAe,GAAG,SAAS,CA6L7E"}
+{"version":3,"file":"SoundFont.d.ts","sourceRoot":"","sources":["../../src/audio/SoundFont.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAC;AAwCxD,iFAAiF;AACjF,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,wDAAwD;AACxD,MAAM,WAAW,cAAc;IAC9B,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACzB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,EAAE,CAAC;IACvF,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAClD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC7B;AAED,uEAAuE;AACvE,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAyMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,eAAe,GAAG,SAAS,CAkG7E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,gBAAgB,EAAE,CAcpF;AA6CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,eAAe,EAAE,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAAG,WAAW,CAiOpH"}

package/dist/audio/SoundFont.js

@@ -1,3 +1,4 @@
+import { scheduleMidi } from './Midi.js';
 /**
  * A SoundFont 2 reader: presets to instruments to sample zones, enough to play
  * General MIDI music with real samples. Supported: key and velocity ranges, root key
@@ -9,6 +10,13 @@
  * A SoundFont file is only data (recorded samples plus preset tables), so reading one
  * is ordinary format engineering; the licence that matters is the font's own, checked
  * before it ships, never here.
+ *
+ * `subsetSoundFont` answers the shipping side: a game that plays five instruments
+ * should not carry all 128. It takes the programs the game's MIDI files actually use
+ * (see `collectSoundFontUsage`) and writes a smaller, valid SoundFont 2 file with the
+ * same voices for those programs: zones, ranges, tuning, envelopes and sample loops
+ * survive byte-identical, while unused presets, instruments and samples are gone and
+ * the library, genre and morphology metadata is zeroed.
  */
 const GENERATORS = {
     keyRange: 43,
@@ -31,37 +39,37 @@ const GENERATORS = {
 function timecents(value) {
     return 2 ** (value / 1200);
 }
-/**
- * Reads SoundFont 2 bytes into layered preset voices.
- *
- * @example
- * ```ts
- * import { parseSoundFont, parseMidi, renderMidiToBuffer } from '@datamoc/mw_games/audio';
- *
- * declare const soundfontBytes: ArrayBuffer;
- * declare const midiBytes: ArrayBuffer;
- *
- * const font = parseSoundFont(soundfontBytes);
- * const rendered = renderMidiToBuffer(parseMidi(midiBytes), { soundfont: font });
- * console.log(font.presetCount, rendered.duration);
- * ```
- */
-export function parseSoundFont(data) {
-    const bytes = data instanceof ArrayBuffer
+function toBytes(data) {
+    return data instanceof ArrayBuffer
         ? new Uint8Array(data)
         : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+function decodeName(bytes, at) {
+    let name = '';
+    for (let i = 0; i < 20; i++) {
+        const code = bytes[at + i];
+        if (code === 0)
+            break;
+        name += String.fromCharCode(code);
+    }
+    return name;
+}
+function readTables(bytes) {
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     const fourcc = (at) => String.fromCharCode(bytes[at], bytes[at + 1], bytes[at + 2], bytes[at + 3]);
     if (fourcc(0) !== 'RIFF' || fourcc(8) !== 'sfbk')
         throw new Error('not a SoundFont 2 file');
     const chunks = new Map();
+    const lists = new Map();
     const walk = (start, end) => {
         let at = start;
         while (at + 8 <= end) {
             const id = fourcc(at);
             const size = view.getUint32(at + 4, true);
-            if (id === 'LIST')
+            if (id === 'LIST') {
+                lists.set(fourcc(at + 8), { at, size });
                 walk(at + 12, at + 8 + size);
+            }
             else
                 chunks.set(id, { at: at + 8, size });
             at += 8 + size + (size & 1);
@@ -86,13 +94,18 @@ export function parseSoundFont(data) {
         amount: view.getInt16(at + 2, true),
     }));
     const bags = (name) => records(name, 4, (at) => view.getUint16(at, true));
-    const presetHeaders = records('phdr', 38, (at) => ({
+    const presets = records('phdr', 38, (at) => ({
+        name: decodeName(bytes, at),
         preset: view.getUint16(at + 20, true),
         bank: view.getUint16(at + 22, true),
         bag: view.getUint16(at + 24, true),
     }));
-    const instrumentHeaders = records('inst', 22, (at) => ({ bag: view.getUint16(at + 20, true) }));
-    const sampleHeaders = records('shdr', 46, (at) => ({
+    const instruments = records('inst', 22, (at) => ({
+        name: decodeName(bytes, at),
+        bag: view.getUint16(at + 20, true),
+    }));
+    const samples = records('shdr', 46, (at) => ({
+        name: decodeName(bytes, at),
         start: view.getUint32(at + 20, true),
         end: view.getUint32(at + 24, true),
         loopStart: view.getUint32(at + 28, true),
@@ -100,70 +113,109 @@ export function parseSoundFont(data) {
         rate: view.getUint32(at + 36, true),
         rootKey: bytes[at + 40],
         correction: view.getInt8(at + 41),
+        link: view.getUint16(at + 42, true),
         type: view.getUint16(at + 44, true),
     }));
-    const presetBags = bags('pbag');
-    const instrumentBags = bags('ibag');
-    const presetGens = generators('pgen');
-    const instrumentGens = generators('igen');
-    //Zones of one header entry; a first zone lacking the terminal generator is global.
-    const zonesOf = (headers, bagList, gens, index, terminal) => {
-        const first = headers[index].bag;
-        const last = headers[index + 1]?.bag ?? bagList.length - 1;
-        const zones = [];
-        let global = null;
-        for (let bag = first; bag < last; bag++) {
-            const map = new Map();
-            for (let g = bagList[bag]; g < (bagList[bag + 1] ?? gens.length); g++) {
-                map.set(gens[g].oper, gens[g]);
-            }
-            if (!map.has(terminal)) {
-                if (bag === first)
-                    global = map;
-                continue;
-            }
-            zones.push({ gens: map, global });
-        }
-        return zones;
-    };
-    const generatorOf = (zone, oper) => zone.gens.get(oper) ?? zone.global?.get(oper) ?? null;
     const smplChunk = chunks.get('smpl');
     const smpl = new Int16Array(bytes.buffer.slice(bytes.byteOffset + smplChunk.at, bytes.byteOffset + smplChunk.at + smplChunk.size - (smplChunk.size & 1)));
+    const info = lists.get('INFO') ?? null;
+    return {
+        bytes,
+        presets,
+        presetBags: bags('pbag'),
+        presetGens: generators('pgen'),
+        instruments,
+        instBags: bags('ibag'),
+        instGens: generators('igen'),
+        samples,
+        smpl,
+        info: info ? bytes.slice(info.at, info.at + 8 + info.size + (info.size & 1)) : null,
+    };
+}
+/** the generators of one bag, in file order */
+function bagGens(bagList, gens, bag) {
+    return gens.slice(bagList[bag], bagList[bag + 1] ?? gens.length);
+}
+//Zones of one header entry: [{ gens: Map(oper -> generator) }...]; a first zone lacking the terminal generator is global.
+function zonesOf(headers, bagList, gens, index, terminal) {
+    const first = headers[index].bag;
+    const last = headers[index + 1]?.bag ?? bagList.length - 1;
+    const zones = [];
+    let global = null;
+    for (let bag = first; bag < last; bag++) {
+        const slice = bagGens(bagList, gens, bag);
+        const map = new Map();
+        for (const generator of slice)
+            map.set(generator.oper, generator);
+        if (!map.has(terminal)) {
+            if (bag === first)
+                global = map;
+            continue;
+        }
+        zones.push({ gens: map, global });
+    }
+    return zones;
+}
+function generatorOf(zone, oper) {
+    return zone.gens.get(oper) ?? zone.global?.get(oper) ?? null;
+}
+function presetIndexOf(presets, bank, program) {
+    return (presets.get(`${bank}:${program}`) ??
+        presets.get(`0:${program}`) ??
+        (bank === 128 ? presets.get('128:0') : undefined) ??
+        presets.get('0:0'));
+}
+/**
+ * Reads SoundFont 2 bytes into layered preset voices.
+ *
+ * @example
+ * ```ts
+ * import { parseSoundFont, parseMidi, renderMidiToBuffer } from '@datamoc/mw_games/audio';
+ *
+ * declare const soundfontBytes: ArrayBuffer;
+ * declare const midiBytes: ArrayBuffer;
+ *
+ * const font = parseSoundFont(soundfontBytes);
+ * const rendered = renderMidiToBuffer(parseMidi(midiBytes), { soundfont: font });
+ * console.log(font.presetCount, rendered.duration);
+ * ```
+ */
+export function parseSoundFont(data) {
+    const tables = readTables(toBytes(data));
     const sampleCache = new Map();
+    const tuning = new Map();
     const sampleOf = (id) => {
         if (sampleCache.has(id))
             return sampleCache.get(id);
-        const header = sampleHeaders[id];
-        //ROM samples live outside the file and cannot play
+        const header = tables.samples[id];
         if (!header || header.end <= header.start || header.type & 0x8000) {
-            sampleCache.set(id, null);
+            sampleCache.set(id, null); //ROM samples live outside the file and cannot play
             return null;
         }
-        const data = new Float32Array(header.end - header.start);
-        for (let index = 0; index < data.length; index++) {
-            data[index] = smpl[header.start + index] / 32768;
+        const frames = new Float32Array(header.end - header.start);
+        for (let index = 0; index < frames.length; index++) {
+            frames[index] = tables.smpl[header.start + index] / 32768;
         }
         const sample = {
-            data,
+            data: frames,
             rate: header.rate || 22050,
             loopStart: header.loopStart - header.start,
             loopEnd: header.loopEnd - header.start,
-            rootKey: header.rootKey === 255 ? 60 : header.rootKey,
-            correction: header.correction,
         };
         sampleCache.set(id, sample);
+        tuning.set(id, {
+            rootKey: header.rootKey === 255 ? 60 : header.rootKey,
+            correction: header.correction,
+        });
         return sample;
     };
     const presets = new Map();
-    for (let index = 0; index < presetHeaders.length - 1; index++) {
-        presets.set(`${presetHeaders[index].bank}:${presetHeaders[index].preset}`, index);
+    for (let index = 0; index < tables.presets.length - 1; index++) {
+        presets.set(`${tables.presets[index].bank}:${tables.presets[index].preset}`, index);
     }
-    //Zones that sound for (bank, program, key, velocity), each with its playback recipe.
+    //Zones that sound for (bank, program, key, velocity), each with the resolved playback recipe.
     function voices(bank, program, key, velocity) {
-        const presetIndex = presets.get(`${bank}:${program}`) ??
-            presets.get(`0:${program}`) ??
-            (bank === 128 ? presets.get('128:0') : undefined) ??
-            presets.get('0:0');
+        const presetIndex = presetIndexOf(presets, bank, program);
         if (presetIndex === undefined)
             return [];
         const out = [];
@@ -171,32 +223,29 @@ export function parseSoundFont(data) {
             const generator = generatorOf(zone, oper);
             return !generator || (value >= generator.lo && value <= generator.hi);
         };
-        for (const presetZone of zonesOf(presetHeaders, presetBags, presetGens, presetIndex, GENERATORS.instrument)) {
+        for (const presetZone of zonesOf(tables.presets, tables.presetBags, tables.presetGens, presetIndex, GENERATORS.instrument)) {
             if (!within(presetZone, GENERATORS.keyRange, key) || !within(presetZone, GENERATORS.velRange, velocity)) {
                 continue;
             }
             const instrument = generatorOf(presetZone, GENERATORS.instrument).amount;
-            if (!instrumentHeaders[instrument + 1])
+            if (!tables.instruments[instrument + 1])
                 continue;
-            for (const zone of zonesOf(instrumentHeaders, instrumentBags, instrumentGens, instrument, GENERATORS.sampleId)) {
+            for (const zone of zonesOf(tables.instruments, tables.instBags, tables.instGens, instrument, GENERATORS.sampleId)) {
                 if (!within(zone, GENERATORS.keyRange, key) || !within(zone, GENERATORS.velRange, velocity)) {
                     continue;
                 }
-                const sample = sampleOf(generatorOf(zone, GENERATORS.sampleId).amount);
+                const sampleId = generatorOf(zone, GENERATORS.sampleId).amount;
+                const sample = sampleOf(sampleId);
                 if (!sample)
                     continue;
                 const both = (oper, fallback = 0) => (generatorOf(zone, oper)?.amount ?? fallback) + (generatorOf(presetZone, oper)?.amount ?? 0);
                 const root = generatorOf(zone, GENERATORS.rootKey)?.amount;
                 const modes = generatorOf(zone, GENERATORS.sampleModes)?.amount ?? 0;
+                const native = tuning.get(sampleId);
                 out.push({
-                    sample: {
-                        data: sample.data,
-                        rate: sample.rate,
-                        loopStart: sample.loopStart,
-                        loopEnd: sample.loopEnd,
-                    },
-                    rootKey: root !== undefined && root >= 0 ? root : sample.rootKey,
-                    cents: both(GENERATORS.coarseTune) * 100 + both(GENERATORS.fineTune) + sample.correction,
+                    sample,
+                    rootKey: root !== undefined && root >= 0 ? root : native.rootKey,
+                    cents: both(GENERATORS.coarseTune) * 100 + both(GENERATORS.fineTune) + native.correction,
                     loop: (modes & 3) === 1 || (modes & 3) === 3,
                     gain: 10 ** (-Math.max(0, both(GENERATORS.attenuation)) / 200),
                     pan: Math.max(-1, Math.min(1, both(GENERATORS.pan) / 500)),
@@ -216,4 +265,314 @@ export function parseSoundFont(data) {
         presetCount: presets.size,
     };
 }
+/**
+ * Every sampled voice the given MIDI files can request, as (bank, program) pairs:
+ * the channel voice in effect at each scheduled note, with drums mapped to bank 128
+ * the same way the renderer maps them. A game's compile step feeds this straight
+ * into `subsetSoundFont` so the shipped font carries only these programs.
+ *
+ * @example
+ * ```ts
+ * import { parseMidi, collectSoundFontUsage } from '@datamoc/mw_games/audio';
+ *
+ * declare const midiBytes: ArrayBuffer;
+ *
+ * const usage = collectSoundFontUsage([parseMidi(midiBytes)]);
+ * console.log(usage.length);
+ * ```
+ */
+export function collectSoundFontUsage(files) {
+    const seen = new Set();
+    const out = [];
+    for (const file of files) {
+        for (const note of scheduleMidi(file)) {
+            const bank = note.channel === 9 ? 128 : note.bank;
+            const key = `${bank}:${note.program}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                out.push({ bank, program: note.program });
+            }
+        }
+    }
+    return out;
+}
+function u16le(value) {
+    return [value & 0xff, (value >> 8) & 0xff];
+}
+function u32le(value) {
+    return [value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff];
+}
+function encodeName(name) {
+    const codes = [...name].map((char) => char.charCodeAt(0) & 0xff).slice(0, 20);
+    return [...codes, ...new Array(20 - codes.length).fill(0)];
+}
+function asciiBytes(text) {
+    return [...text].map((char) => char.charCodeAt(0));
+}
+/** one chunk as bytes: kept samples run to megabytes, so this allocates instead of spreading */
+function chunkBytes(id, payload) {
+    const out = new Uint8Array(8 + payload.length + (payload.length & 1));
+    out.set(asciiBytes(id), 0);
+    new DataView(out.buffer).setUint32(4, payload.length, true);
+    out.set(payload, 8);
+    return out;
+}
+function concat(parts) {
+    let length = 0;
+    for (const part of parts)
+        length += part.length;
+    const out = new Uint8Array(length);
+    let at = 0;
+    for (const part of parts) {
+        out.set(part, at);
+        at += part.length;
+    }
+    return out;
+}
+function listBytes(type, subs) {
+    const body = concat([new Uint8Array(asciiBytes(type)), ...subs]);
+    return concat([new Uint8Array(asciiBytes('LIST')), new Uint8Array(u32le(body.length)), body]);
+}
+/**
+ * Writes a smaller, valid SoundFont 2 file carrying only the used programs: their
+ * presets (names kept), instruments and samples, with zones, ranges, tuning,
+ * envelopes and sample loops copied verbatim and every index remapped. Zones that
+ * reference samples missing from the file (ROM samples) are dropped, matching what
+ * the reader voices for the full font; the library, genre and morphology metadata
+ * is zeroed and the INFO list, when present, rides along untouched. Modulator lists
+ * are emptied and 24-bit upper bits are dropped: the reader voices neither, so what
+ * it plays is unchanged, while a third-party player would miss those.
+ *
+ * @example
+ * ```ts
+ * import { parseMidi, collectSoundFontUsage, subsetSoundFont } from '@datamoc/mw_games/audio';
+ *
+ * declare const midiBytes: ArrayBuffer;
+ * declare const soundfontBytes: ArrayBuffer;
+ *
+ * const usage = collectSoundFontUsage([parseMidi(midiBytes)]);
+ * const pruned = subsetSoundFont(soundfontBytes, usage);
+ * console.log(usage.length, pruned.byteLength);
+ * ```
+ */
+export function subsetSoundFont(data, usage) {
+    const tables = readTables(toBytes(data));
+    const presetIndex = new Map();
+    for (let index = 0; index < tables.presets.length - 1; index++) {
+        presetIndex.set(`${tables.presets[index].bank}:${tables.presets[index].preset}`, index);
+    }
+    //Used presets in file order, resolved through the same fallback the reader voices.
+    const seenPresets = new Set();
+    const usedPresets = [];
+    for (const { bank, program } of usage) {
+        const index = presetIndexOf(presetIndex, bank, program);
+        if (index !== undefined && !seenPresets.has(index)) {
+            seenPresets.add(index);
+            usedPresets.push(index);
+        }
+    }
+    usedPresets.sort((a, b) => a - b);
+    const usableSample = (id) => {
+        const header = tables.samples[id];
+        return !!header && header.end > header.start && !(header.type & 0x8000);
+    };
+    //A bag's generators verbatim, except instrument and sample ids are remapped.
+    const remapIds = (gens, oper, ids) => gens.map((generator) => generator.oper === oper
+        ? {
+            oper,
+            lo: ids.get(generator.amount) & 0xff,
+            hi: (ids.get(generator.amount) >> 8) & 0xff,
+            amount: ids.get(generator.amount),
+        }
+        : generator);
+    //Instruments in first-use order, with zones that lost their sample dropped.
+    const instrumentOrder = [];
+    const instrumentZones = new Map();
+    {
+        const seen = new Set();
+        for (const preset of usedPresets) {
+            const first = tables.presets[preset].bag;
+            const last = tables.presets[preset + 1]?.bag ?? tables.presetBags.length - 1;
+            for (let bag = first; bag < last; bag++) {
+                const gens = bagGens(tables.presetBags, tables.presetGens, bag);
+                if (!gens.some((generator) => generator.oper === GENERATORS.instrument))
+                    continue;
+                const instrument = gens.find((generator) => generator.oper === GENERATORS.instrument).amount;
+                if (!tables.instruments[instrument + 1])
+                    continue; // same guard the reader voices with
+                if (!seen.has(instrument)) {
+                    seen.add(instrument);
+                    instrumentOrder.push(instrument);
+                }
+            }
+        }
+    }
+    const instrumentNew = new Map(instrumentOrder.map((old, index) => [old, index]));
+    for (const instrument of instrumentOrder) {
+        const first = tables.instruments[instrument].bag;
+        const last = tables.instruments[instrument + 1]?.bag ?? tables.instBags.length - 1;
+        const zones = [];
+        for (let bag = first; bag < last; bag++) {
+            const gens = bagGens(tables.instBags, tables.instGens, bag);
+            if (!gens.some((generator) => generator.oper === GENERATORS.sampleId))
+                continue;
+            const sample = gens.find((generator) => generator.oper === GENERATORS.sampleId).amount;
+            if (!usableSample(sample))
+                continue;
+            zones.push(gens);
+        }
+        instrumentZones.set(instrument, zones);
+    }
+    //Samples in first-use order, chasing stereo links one hop so none dangles.
+    const sampleOrder = [];
+    {
+        const seen = new Set();
+        const keep = (id) => {
+            if (seen.has(id) || !usableSample(id))
+                return;
+            seen.add(id);
+            sampleOrder.push(id);
+            const link = tables.samples[id].link;
+            if (link !== id)
+                keep(link);
+        };
+        for (const instrument of instrumentOrder) {
+            for (const zone of instrumentZones.get(instrument)) {
+                keep(zone.find((generator) => generator.oper === GENERATORS.sampleId).amount);
+            }
+        }
+    }
+    const sampleNew = new Map(sampleOrder.map((old, index) => [old, index]));
+    const genRecord = (generator) => [...u16le(generator.oper), generator.lo, generator.hi];
+    const bagRecord = (genIndex) => [...u16le(genIndex), ...u16le(0)];
+    //Presets: global zone first when the source has one, then its instrument zones.
+    const newPresetBags = [];
+    const newPresetGens = [];
+    const newPresets = [];
+    for (const preset of usedPresets) {
+        const source = tables.presets[preset];
+        const bagStart = newPresetBags.length;
+        const first = source.bag;
+        const last = tables.presets[preset + 1]?.bag ?? tables.presetBags.length - 1;
+        for (let bag = first; bag < last; bag++) {
+            const gens = bagGens(tables.presetBags, tables.presetGens, bag);
+            const isGlobal = bag === first && !gens.some((generator) => generator.oper === GENERATORS.instrument);
+            if (!isGlobal && !gens.some((generator) => generator.oper === GENERATORS.instrument))
+                continue;
+            newPresetBags.push(newPresetGens.length);
+            newPresetGens.push(...remapIds(gens, GENERATORS.instrument, instrumentNew));
+        }
+        newPresets.push({ name: source.name, preset: source.preset, bank: source.bank, bag: bagStart });
+    }
+    newPresetBags.push(newPresetGens.length);
+    //Instruments: same shape, sample ids remapped, sample zones already pruned above.
+    const newInstBags = [];
+    const newInstGens = [];
+    const newInstruments = [];
+    for (const instrument of instrumentOrder) {
+        const bagStart = newInstBags.length;
+        const zones = instrumentZones.get(instrument);
+        //An instrument whose zones all lost their samples keeps its header with no
+        //bags: it voices nothing, exactly like the full font did.
+        //A global zone (first bag without a sample id) rides along when present.
+        const first = tables.instruments[instrument].bag;
+        const last = tables.instruments[instrument + 1]?.bag ?? tables.instBags.length - 1;
+        for (let bag = first; bag < last; bag++) {
+            const gens = bagGens(tables.instBags, tables.instGens, bag);
+            if (bag === first && !gens.some((generator) => generator.oper === GENERATORS.sampleId)) {
+                newInstBags.push(newInstGens.length);
+                newInstGens.push(...gens);
+            }
+        }
+        for (const zone of zones) {
+            newInstBags.push(newInstGens.length);
+            newInstGens.push(...remapIds(zone, GENERATORS.sampleId, sampleNew));
+        }
+        newInstruments.push({ name: tables.instruments[instrument].name, bag: bagStart });
+    }
+    newInstBags.push(newInstGens.length);
+    //Samples: data concatenated, offsets and links remapped, headers otherwise intact.
+    const newSamples = [];
+    const sampleData = [];
+    for (const old of sampleOrder) {
+        const header = tables.samples[old];
+        const start = sampleData.length / 2;
+        for (let index = header.start; index < header.end; index++) {
+            const word = tables.smpl[index];
+            sampleData.push(word & 0xff, (word >> 8) & 0xff);
+        }
+        const self = sampleNew.get(old);
+        newSamples.push({
+            ...header,
+            start,
+            end: start + (header.end - header.start),
+            loopStart: start + (header.loopStart - header.start),
+            loopEnd: start + (header.loopEnd - header.start),
+            link: sampleNew.get(header.link) ?? self,
+        });
+    }
+    const presetRecords = (entry) => [
+        ...encodeName(entry.name),
+        ...u16le(entry.preset),
+        ...u16le(entry.bank),
+        ...u16le(entry.bag),
+        ...new Array(12).fill(0),
+    ];
+    const terminalPreset = tables.presets[tables.presets.length - 1];
+    const phdr = chunkBytes('phdr', [
+        ...newPresets.flatMap(presetRecords),
+        ...presetRecords({
+            name: terminalPreset?.name ?? 'EOS',
+            preset: 0,
+            bank: 0,
+            bag: newPresetBags.length - 1,
+        }),
+    ]);
+    const pbag = chunkBytes('pbag', newPresetBags.flatMap(bagRecord));
+    const pgen = chunkBytes('pgen', newPresetGens.flatMap(genRecord));
+    const pmod = chunkBytes('pmod', new Array(10).fill(0));
+    const instRecords = (entry) => [
+        ...encodeName(entry.name),
+        ...u16le(entry.bag),
+    ];
+    const terminalInst = tables.instruments[tables.instruments.length - 1];
+    const inst = chunkBytes('inst', [
+        ...newInstruments.flatMap(instRecords),
+        ...instRecords({ name: terminalInst?.name ?? 'EOS', bag: newInstBags.length - 1 }),
+    ]);
+    const ibag = chunkBytes('ibag', newInstBags.flatMap(bagRecord));
+    const igen = chunkBytes('igen', newInstGens.flatMap(genRecord));
+    const imod = chunkBytes('imod', new Array(10).fill(0));
+    const sampleRecords = (header) => [
+        ...encodeName(header.name),
+        ...u32le(header.start),
+        ...u32le(header.end),
+        ...u32le(header.loopStart),
+        ...u32le(header.loopEnd),
+        ...u32le(header.rate),
+        header.rootKey,
+        header.correction & 0xff,
+        ...u16le(header.link),
+        ...u16le(header.type),
+    ];
+    const terminalSample = {
+        name: '',
+        start: 0,
+        end: 0,
+        loopStart: 0,
+        loopEnd: 0,
+        rate: 0,
+        rootKey: 0,
+        correction: 0,
+        link: 0,
+        type: 0,
+    };
+    const shdr = chunkBytes('shdr', [...newSamples.flatMap(sampleRecords), ...sampleRecords(terminalSample)]);
+    const smpl = chunkBytes('smpl', sampleData);
+    const sdta = listBytes('sdta', [smpl]);
+    const pdta = listBytes('pdta', [phdr, pbag, pmod, pgen, inst, ibag, imod, igen, shdr]);
+    const body = concat([new Uint8Array(asciiBytes('sfbk')), ...(tables.info ? [tables.info] : []), sdta, pdta]);
+    const bytes = concat([new Uint8Array(asciiBytes('RIFF')), new Uint8Array(u32le(body.length)), body]);
+    return bytes.buffer;
+}
 //# sourceMappingURL=SoundFont.js.map