@marmooo/soundfont-split 0.0.1

package/script/src/split.js

@@ -0,0 +1,302 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPreset = extractPreset;
+exports.splitSoundFont = splitSoundFont;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const soundfont_1 = require("@marmooo/soundfont");
+const encoder_1 = require("@marmooo/sf3-codec/encoder");
+const decoder_1 = require("@marmooo/sf3-codec/decoder");
+function cloneGenerator(g) {
+    if (g.value instanceof soundfont_1.RangeValue) {
+        return new soundfont_1.GeneratorList(g.code, new soundfont_1.RangeValue(g.value.lo, g.value.hi));
+    }
+    return new soundfont_1.GeneratorList(g.code, g.value);
+}
+function cloneModulator(m) {
+    return new soundfont_1.ModulatorList(m.sourceOper, m.destinationOper, m.amount, m.amountSourceOper, m.transOper);
+}
+function isTerminalMod(m) {
+    return (m.destinationOper === 0 &&
+        m.amount === 0 &&
+        m.transOper === 0 &&
+        m.sourceOper.toValue() === 0 &&
+        m.amountSourceOper.toValue() === 0);
+}
+function defaultConcurrency() {
+    const nav = dntShim.dntGlobalThis.navigator;
+    return nav?.hardwareConcurrency ?? 4;
+}
+// Extract a single preset (by index into soundFont.presetHeaders) into a
+// minimal SoundFont that contains only the instruments and samples that
+// preset depends on. Indices are remapped so the result is a valid
+// standalone SF2/SF3.
+function extractPreset(soundFont, presetHeaderIndex) {
+    const headers = soundFont.presetHeaders;
+    if (presetHeaderIndex < 0 ||
+        presetHeaderIndex >= headers.length ||
+        headers[presetHeaderIndex].isEnd) {
+        throw new Error(`invalid presetHeaderIndex: ${presetHeaderIndex}`);
+    }
+    const ph = headers[presetHeaderIndex];
+    const nextPh = headers[presetHeaderIndex + 1];
+    // Zones for this preset: bags [ph.presetBagIndex, nextBagIndex)
+    // The terminal bag that bounds the last zone is not a zone itself.
+    const bagFrom = ph.presetBagIndex;
+    const bagTo = nextPh
+        ? nextPh.presetBagIndex
+        : soundFont.presetZone.length - 1;
+    const instrumentIdSet = new Set();
+    const presetZoneSlice = [];
+    const presetGenSlice = [];
+    const presetModSlice = [];
+    let genCursor = 0;
+    let modCursor = 0;
+    for (let zi = bagFrom; zi < bagTo; zi++) {
+        const bag = soundFont.presetZone[zi];
+        const nextBag = soundFont.presetZone[zi + 1];
+        if (!nextBag)
+            break;
+        const gens = soundFont.presetGenerators
+            .slice(bag.generatorIndex, nextBag.generatorIndex)
+            .map(cloneGenerator);
+        const mods = soundFont.presetModulators
+            .slice(bag.modulatorIndex, nextBag.modulatorIndex)
+            .map(cloneModulator);
+        for (const g of gens) {
+            if (g.type === "instrument" && typeof g.value === "number") {
+                instrumentIdSet.add(g.value);
+            }
+        }
+        presetZoneSlice.push(new soundfont_1.Bag(genCursor, modCursor));
+        presetGenSlice.push(...gens);
+        presetModSlice.push(...mods);
+        genCursor += gens.length;
+        modCursor += mods.length;
+    }
+    // Terminal bag for preset zones
+    presetZoneSlice.push(new soundfont_1.Bag(genCursor, modCursor));
+    if (presetModSlice.length === 0 ||
+        !isTerminalMod(presetModSlice[presetModSlice.length - 1])) {
+        presetModSlice.push(soundfont_1.ModulatorList.end());
+    }
+    if (presetGenSlice.length === 0 ||
+        !presetGenSlice[presetGenSlice.length - 1].isEnd) {
+        presetGenSlice.push(soundfont_1.GeneratorList.end());
+    }
+    const instrumentIds = [...instrumentIdSet].sort((a, b) => a - b);
+    const instMap = new Map();
+    instrumentIds.forEach((id, i) => instMap.set(id, i));
+    for (const g of presetGenSlice) {
+        if (g.type === "instrument" && typeof g.value === "number") {
+            const mapped = instMap.get(g.value);
+            if (mapped === undefined) {
+                throw new Error(`instrument ${g.value} not collected`);
+            }
+            g.value = mapped;
+        }
+    }
+    const sampleIdSet = new Set();
+    const instruments = [];
+    const instrumentZone = [];
+    const instrumentGenerators = [];
+    const instrumentModulators = [];
+    let iGenCursor = 0;
+    let iModCursor = 0;
+    for (const oldInstId of instrumentIds) {
+        const inst = soundFont.instruments[oldInstId];
+        const nextInst = soundFont.instruments[oldInstId + 1];
+        const iBagFrom = inst.instrumentBagIndex;
+        const iBagTo = nextInst
+            ? nextInst.instrumentBagIndex
+            : soundFont.instrumentZone.length - 1;
+        const newInst = new soundfont_1.Instrument();
+        newInst.instrumentName = inst.instrumentName;
+        newInst.instrumentBagIndex = instrumentZone.length;
+        instruments.push(newInst);
+        for (let zi = iBagFrom; zi < iBagTo; zi++) {
+            const bag = soundFont.instrumentZone[zi];
+            const nextBag = soundFont.instrumentZone[zi + 1];
+            if (!nextBag)
+                break;
+            const gens = soundFont.instrumentGenerators
+                .slice(bag.generatorIndex, nextBag.generatorIndex)
+                .map(cloneGenerator);
+            const mods = soundFont.instrumentModulators
+                .slice(bag.modulatorIndex, nextBag.modulatorIndex)
+                .map(cloneModulator);
+            for (const g of gens) {
+                if (g.type === "sampleID" && typeof g.value === "number") {
+                    sampleIdSet.add(g.value);
+                    const sh = soundFont.sampleHeaders[g.value];
+                    if (sh && sh.sampleLink !== 0 && !sh.isEnd) {
+                        sampleIdSet.add(sh.sampleLink);
+                    }
+                }
+            }
+            instrumentZone.push(new soundfont_1.Bag(iGenCursor, iModCursor));
+            instrumentGenerators.push(...gens);
+            instrumentModulators.push(...mods);
+            iGenCursor += gens.length;
+            iModCursor += mods.length;
+        }
+    }
+    instrumentZone.push(new soundfont_1.Bag(iGenCursor, iModCursor));
+    if (instrumentModulators.length === 0 ||
+        !isTerminalMod(instrumentModulators[instrumentModulators.length - 1])) {
+        instrumentModulators.push(soundfont_1.ModulatorList.end());
+    }
+    if (instrumentGenerators.length === 0 ||
+        !instrumentGenerators[instrumentGenerators.length - 1].isEnd) {
+        instrumentGenerators.push(soundfont_1.GeneratorList.end());
+    }
+    const sampleIds = [...sampleIdSet].sort((a, b) => a - b);
+    const sampleMap = new Map();
+    sampleIds.forEach((id, i) => sampleMap.set(id, i));
+    for (const g of instrumentGenerators) {
+        if (g.type === "sampleID" && typeof g.value === "number") {
+            const mapped = sampleMap.get(g.value);
+            if (mapped === undefined) {
+                throw new Error(`sample ${g.value} not collected`);
+            }
+            g.value = mapped;
+        }
+    }
+    const sampleHeaders = [];
+    const samples = [];
+    for (const oldId of sampleIds) {
+        const sh = soundFont.sampleHeaders[oldId];
+        const sample = soundFont.samples[oldId];
+        const newLink = sh.sampleLink !== 0 && sampleMap.has(sh.sampleLink)
+            ? sampleMap.get(sh.sampleLink)
+            : 0;
+        sampleHeaders.push(new soundfont_1.SampleHeader(sh.sampleName, sh.start, sh.end, sh.loopStart, sh.loopEnd, sh.sampleRate, sh.originalPitch, sh.pitchCorrection, newLink, sh.sampleType));
+        samples.push(sample);
+    }
+    const newPh = new soundfont_1.PresetHeader(ph.presetName, ph.preset, ph.bank, 0, ph.library, ph.genre, ph.morphology);
+    return new soundfont_1.SoundFont({
+        presetHeaders: [newPh],
+        presetZone: presetZoneSlice,
+        presetModulators: presetModSlice,
+        presetGenerators: presetGenSlice,
+        instruments,
+        instrumentZone,
+        instrumentModulators,
+        instrumentGenerators,
+        sampleHeaders,
+        samples,
+        samplingData: soundFont.samplingData,
+        info: soundFont.info,
+    });
+}
+// Split every preset in the soundfont into its own file under outDir:
+//   outDir/{bank:03d}/{preset:03d}.sf3
+//
+// Presets are processed in parallel. Sample encodes share a single encoder
+// pool sized by `options.concurrency` (so the budget is global, not
+// per-preset).
+async function splitSoundFont(input, outDir, options = {}) {
+    const bytes = typeof input === "string" ? dntShim.Deno.readFileSync(input) : input;
+    const soundFont = (0, soundfont_1.parse)(bytes);
+    const toSf3 = options.toSf3 !== false;
+    const concurrency = Math.max(1, options.concurrency ?? defaultConcurrency());
+    await dntShim.Deno.mkdir(outDir, { recursive: true });
+    // Shared encoder pool for the whole job. Callers that supply their own
+    // encode via sf2ToSf3 are not used here - we own the pool so we can dispose
+    // it and let the process exit (workers otherwise keep the event loop alive).
+    let encode;
+    let decode;
+    if (toSf3) {
+        encode = (0, encoder_1.createDefaultEncoder)({
+            quality: options.quality,
+            poolSize: concurrency,
+        });
+        if (options.recompress) {
+            decode = (0, decoder_1.createDefaultDecoder)({ poolSize: concurrency });
+        }
+    }
+    try {
+        const headers = soundFont.presetHeaders;
+        const jobs = [];
+        for (let i = 0; i < headers.length; i++) {
+            if (!headers[i].isEnd)
+                jobs.push({ index: i, ph: headers[i] });
+        }
+        // Cap how many presets we assemble at once (encode pool is the real
+        // limiter; this just bounds peak memory from parallel write()s).
+        const presetParallel = concurrency;
+        const results = new Array(jobs.length);
+        let nextJob = 0;
+        const runWorker = async () => {
+            while (true) {
+                const jobIndex = nextJob++;
+                if (jobIndex >= jobs.length)
+                    return;
+                const { index, ph } = jobs[jobIndex];
+                const extracted = extractPreset(soundFont, index);
+                const bankDir = `${outDir}/${String(ph.bank).padStart(3, "0")}`;
+                await dntShim.Deno.mkdir(bankDir, { recursive: true });
+                const ext = toSf3 ? "sf3" : "sf2";
+                const fileName = `${String(ph.preset).padStart(3, "0")}.${ext}`;
+                const path = `${bankDir}/${fileName}`;
+                const outBytes = toSf3
+                    ? await (0, soundfont_1.write)(extracted, {
+                        // write() may schedule many encodes; the pool caps actual work.
+                        encode: encode,
+                        decode,
+                        concurrency,
+                    })
+                    : await (0, soundfont_1.write)(extracted);
+                dntShim.Deno.writeFileSync(path, outBytes);
+                const presetName = ph.presetName.replace(/\0+$/, "").trim();
+                results[jobIndex] = {
+                    bank: ph.bank,
+                    preset: ph.preset,
+                    presetName,
+                    path,
+                    byteLength: outBytes.byteLength,
+                };
+                console.log(`wrote ${path} (${outBytes.byteLength} bytes) - ${presetName}`);
+            }
+        };
+        const workers = Array.from({ length: Math.min(presetParallel, jobs.length) }, () => runWorker());
+        await Promise.all(workers);
+        return results;
+    }
+    finally {
+        encode?.dispose?.();
+        decode?.dispose?.();
+    }
+}