@marmooo/soundfont-split 0.0.1

package/esm/src/split.js

@@ -0,0 +1,265 @@
+import * as dntShim from "../_dnt.shims.js";
+import { Bag, GeneratorList, Instrument, ModulatorList, parse, PresetHeader, RangeValue, SampleHeader, SoundFont, write, } from "@marmooo/soundfont";
+import { createDefaultEncoder } from "@marmooo/sf3-codec/encoder";
+import { createDefaultDecoder } from "@marmooo/sf3-codec/decoder";
+function cloneGenerator(g) {
+    if (g.value instanceof RangeValue) {
+        return new GeneratorList(g.code, new RangeValue(g.value.lo, g.value.hi));
+    }
+    return new GeneratorList(g.code, g.value);
+}
+function cloneModulator(m) {
+    return new 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.
+export 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 Bag(genCursor, modCursor));
+        presetGenSlice.push(...gens);
+        presetModSlice.push(...mods);
+        genCursor += gens.length;
+        modCursor += mods.length;
+    }
+    // Terminal bag for preset zones
+    presetZoneSlice.push(new Bag(genCursor, modCursor));
+    if (presetModSlice.length === 0 ||
+        !isTerminalMod(presetModSlice[presetModSlice.length - 1])) {
+        presetModSlice.push(ModulatorList.end());
+    }
+    if (presetGenSlice.length === 0 ||
+        !presetGenSlice[presetGenSlice.length - 1].isEnd) {
+        presetGenSlice.push(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 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 Bag(iGenCursor, iModCursor));
+            instrumentGenerators.push(...gens);
+            instrumentModulators.push(...mods);
+            iGenCursor += gens.length;
+            iModCursor += mods.length;
+        }
+    }
+    instrumentZone.push(new Bag(iGenCursor, iModCursor));
+    if (instrumentModulators.length === 0 ||
+        !isTerminalMod(instrumentModulators[instrumentModulators.length - 1])) {
+        instrumentModulators.push(ModulatorList.end());
+    }
+    if (instrumentGenerators.length === 0 ||
+        !instrumentGenerators[instrumentGenerators.length - 1].isEnd) {
+        instrumentGenerators.push(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 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 PresetHeader(ph.presetName, ph.preset, ph.bank, 0, ph.library, ph.genre, ph.morphology);
+    return new 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).
+export async function splitSoundFont(input, outDir, options = {}) {
+    const bytes = typeof input === "string" ? dntShim.Deno.readFileSync(input) : input;
+    const soundFont = 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 = createDefaultEncoder({
+            quality: options.quality,
+            poolSize: concurrency,
+        });
+        if (options.recompress) {
+            decode = 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 write(extracted, {
+                        // write() may schedule many encodes; the pool caps actual work.
+                        encode: encode,
+                        decode,
+                        concurrency,
+                    })
+                    : await 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?.();
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@marmooo/soundfont-split",
+  "version": "0.0.1",
+  "description": "Split a SoundFont (SF2 / SF3) into per-preset SF3 files.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marmooo/soundfont-split.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/marmooo/soundfont-split/issues"
+  },
+  "main": "./script/src/mod.js",
+  "module": "./esm/src/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/src/mod.js",
+      "require": "./script/src/mod.js"
+    }
+  },
+  "scripts": {
+    "test": "node test_runner.cjs"
+  },
+  "bin": {
+    "soundfont-split": "./esm/cli.js"
+  },
+  "dependencies": {
+    "@marmooo/sf3-codec": "^0.0.2",
+    "@marmooo/soundfont": "^0.3.2",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0"
+  },
+  "_generatedBy": "dnt@0.43.2"
+}

package/script/_dnt.polyfills.d.ts

@@ -0,0 +1,11 @@
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};

package/script/_dnt.polyfills.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/src/mod.d.ts

@@ -0,0 +1,3 @@
+import "../_dnt.polyfills.js";
+export { extractPreset, splitSoundFont } from "./split.js";
+export type { SplitOptions, SplitResult } from "./split.js";

package/script/src/mod.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSoundFont = exports.extractPreset = void 0;
+require("../_dnt.polyfills.js");
+var split_js_1 = require("./split.js");
+Object.defineProperty(exports, "extractPreset", { enumerable: true, get: function () { return split_js_1.extractPreset; } });
+Object.defineProperty(exports, "splitSoundFont", { enumerable: true, get: function () { return split_js_1.splitSoundFont; } });

package/script/src/split.d.ts

@@ -0,0 +1,16 @@
+import { SoundFont } from "@marmooo/soundfont";
+export interface SplitOptions {
+    quality?: number;
+    concurrency?: number;
+    toSf3?: boolean;
+    recompress?: boolean;
+}
+export interface SplitResult {
+    bank: number;
+    preset: number;
+    presetName: string;
+    path: string;
+    byteLength: number;
+}
+export declare function extractPreset(soundFont: SoundFont, presetHeaderIndex: number): SoundFont;
+export declare function splitSoundFont(input: Uint8Array | string, outDir: string, options?: SplitOptions): Promise<SplitResult[]>;