@sudobility/music_player 0.1.0 → 0.1.2

package/dist/web/audio/offline-synth.js

@@ -0,0 +1,92 @@
+/**
+ * A long-lived synth for offline rendering, loaded once per page.
+ *
+ * Export cannot share playback's synth: Web Audio nodes belong to the context
+ * that created them, playback runs on a realtime `AudioContext`, and rendering
+ * faster than realtime needs an `OfflineAudioContext`. Nothing bridges the two.
+ * Worse, an `OfflineAudioContext` renders exactly once, so the previous design
+ * built a fresh worklet and reloaded the 23MB soundfont on *every export* —
+ * about five seconds each time, with libfluidsynth's build-stub notices along
+ * for the ride.
+ *
+ * `Synthesizer.render()` avoids all of it by needing no audio context at all:
+ * it fills buffers straight from the WASM synth. So one synth is built, the
+ * font is loaded into it once, and every export after the first is immediate.
+ *
+ * This one runs on the main thread rather than in a worklet, which is fine
+ * precisely because it is offline — there is no audio callback to starve.
+ */
+import { CHANNELS_PER_INSTANCE } from '../playback/channel-allocator.js';
+import { seedMainThreadQuietModule } from '../playback/quiet-stub-notices.js';
+/** Matches playback's ceiling, so an export sounds like what was heard. */
+const OFFLINE_POLYPHONY = 2048;
+/** Resolves once `libfluidsynth-*.js` has been loaded and its WASM is ready. */
+let fluidsynthReady = null;
+/** The loaded synth, keyed so a changed font or rate rebuilds rather than lying. */
+let cached = null;
+/**
+ * Loads libfluidsynth into the *main thread*.
+ *
+ * A script tag rather than `addModule`: the non-worklet synth reads the module
+ * from the global scope, where `addModule` would put it inside the worklet
+ * instead. Memoised, since loading it twice would replace the global mid-flight.
+ */
+async function ensureFluidsynth(moduleUrl) {
+    fluidsynthReady ??= (async () => {
+        if (typeof document === 'undefined') {
+            throw new Error('Offline rendering needs a document to load libfluidsynth');
+        }
+        // Before the script runs: emscripten reads the global Module on load.
+        seedMainThreadQuietModule();
+        await new Promise((resolve, reject) => {
+            const script = document.createElement('script');
+            script.src = moduleUrl;
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error(`Failed to load ${moduleUrl}`));
+            document.head.appendChild(script);
+        });
+        const jsSynth = await import('js-synthesizer');
+        await jsSynth.waitForReady();
+    })();
+    return fluidsynthReady;
+}
+/** The shared offline synth, building it on first use. */
+export async function getOfflineSynth(request) {
+    const key = `${request.fluidsynthModuleUrl}|${request.fontUrl}|${request.sampleRate}`;
+    if (cached?.key === key)
+        return await cached.synth;
+    const building = (async () => {
+        let synth;
+        if (request.createSynth) {
+            synth = request.createSynth();
+        }
+        else {
+            await ensureFluidsynth(request.fluidsynthModuleUrl);
+            const jsSynth = await import('js-synthesizer');
+            synth = new jsSynth.Synthesizer();
+        }
+        // The same channel count playback uses, because both share
+        // `allocateChannels`: on a 16-channel synth an export would address
+        // channels that do not exist and silently lose every track past the
+        // sixteenth. Polyphony matches too, so an export sounds like what was heard.
+        synth.init(request.sampleRate, {
+            midiChannelCount: CHANNELS_PER_INSTANCE,
+            polyphony: OFFLINE_POLYPHONY,
+        });
+        const sfontId = await synth.loadSFont(await request.loadFont(request.fontUrl));
+        return { synth, sfontId, sampleRate: request.sampleRate };
+    })();
+    cached = { key, synth: building };
+    try {
+        return await building;
+    }
+    catch (error) {
+        cached = null; // a failed build must not be handed to the next caller
+        throw error;
+    }
+}
+/** Drops the shared synth. Exposed for tests and teardown, not used in normal flow. */
+export function releaseOfflineSynth() {
+    cached = null;
+}
+//# sourceMappingURL=offline-synth.js.map

package/dist/web/audio/offline-synth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"offline-synth.js","sourceRoot":"","sources":["../../../src/web/audio/offline-synth.ts"],"names":[],"mappings":"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"}

package/dist/web/audio/soundfont-render.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Offline audio rendering through the shared soundfont synth.
+ *
+ * Export and playback use the same soundfont, the same channel allocation and
+ * the same percussion rules, so a rendered file matches what was heard. They
+ * cannot share the *synth itself* — playback's lives in an `AudioWorklet` bound
+ * to a realtime context, and Web Audio nodes do not cross contexts — so this
+ * holds its own, built once per page by `offline-synth.ts`.
+ *
+ * Timing comes from the render loop rather than from an audio context: the
+ * synth is asked for one small block at a time, and events falling inside that
+ * block are dispatched just before it. Block size sets the timing resolution;
+ * at 128 frames and 44.1kHz that is under three milliseconds, well below what
+ * anyone hears as misplacement.
+ *
+ * The earlier version used `OfflineAudioContext.suspend()`, which worked but
+ * needed a fresh context — and therefore a fresh worklet and a fresh 23MB font
+ * load — for every single export.
+ */
+import type { DecodedAudio, RenderPlan } from '@sudobility/music_types';
+import type { LoadedOfflineSynth } from './offline-synth.js';
+export type { RenderEvent, RenderPlan, RenderTrack } from '@sudobility/music_types';
+export type SoundfontRendererAssets = {
+    fluidsynthModuleUrl: string;
+    fontUrl: string;
+    loadFont: (url: string) => Promise<ArrayBuffer>;
+    /** Overridable so tests can supply a stub synth instead of loading WASM. */
+    acquireSynth?: (sampleRate: number) => Promise<LoadedOfflineSynth>;
+};
+export declare function createSoundfontRenderer(assets: SoundfontRendererAssets): (plan: RenderPlan) => Promise<DecodedAudio>;
+//# sourceMappingURL=soundfont-render.d.ts.map

package/dist/web/audio/soundfont-render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soundfont-render.d.ts","sourceRoot":"","sources":["../../../src/web/audio/soundfont-render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAKxE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEpF,MAAM,MAAM,uBAAuB,GAAG;IACpC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;IAChD,4EAA4E;IAC5E,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACpE,CAAC;AAiBF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,uBAAuB,GAC9B,CAAC,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,YAAY,CAAC,CAyH7C"}

package/dist/web/audio/soundfont-render.js

@@ -0,0 +1,130 @@
+import { allocateChannels } from '../playback/channel-allocator.js';
+import { headroomTrimFor, limitPeaks } from '../../shared/mix.js';
+import { getOfflineSynth } from './offline-synth.js';
+const SAMPLE_RATE = 44100;
+/** Release tail, so the last note is not cut off mid-decay. */
+const TAIL_SECONDS = 1;
+/** Timing resolution of the render: 128 frames is ~2.9ms at 44.1kHz. */
+const BLOCK_FRAMES = 128;
+const CC_VOLUME = 7;
+const CC_PAN = 10;
+const MAX_CC = 127;
+/** Where General MIDI keeps its drum kits; channel 9 is already there. */
+const DRUM_BANK = 128;
+/** The kit channel 9 defaults to, so a switched channel matches it. */
+const STANDARD_KIT = 0;
+export function createSoundfontRenderer(assets) {
+    const acquire = assets.acquireSynth ??
+        ((sampleRate) => getOfflineSynth({
+            fluidsynthModuleUrl: assets.fluidsynthModuleUrl,
+            fontUrl: assets.fontUrl,
+            loadFont: assets.loadFont,
+            sampleRate,
+        }));
+    return async function render(plan) {
+        const { synth, sfontId, sampleRate } = await acquire(SAMPLE_RATE);
+        const totalFrames = Math.ceil(Math.max(0.1, plan.durationSec + TAIL_SECONDS) * sampleRate);
+        const { assignments, instanceCount } = allocateChannels(plan.tracks.map((t) => ({ id: t.id, isPercussion: t.isPercussion })));
+        // The same trim `SynthHost` puts on the live master bus, for the same
+        // reason: every channel is scheduled at its own MIDI volume with nothing
+        // reconciling them, so the sum grows with the part count. Without it the
+        // export was `sqrt(n)` louder than what was heard and the encoders — which
+        // hard-clamp — turned that into clipping across most of a large score.
+        // Sized by how many tracks *exist*, matching `setTrackCount(tracks.length)`.
+        const headroom = headroomTrimFor(plan.tracks.length);
+        const samples = new Float32Array(totalFrames);
+        // One synth, so an allocation that spans several of them is rendered as
+        // several passes summed into the same buffer. Ignoring the instance and
+        // keying on the channel alone put two tracks on one channel: the second
+        // overwrote the first's program, so past sixteen parts the export came out
+        // with the wrong instruments — while playback, which does open the extra
+        // synths, did not. Passes cost render time, and only a score too big for
+        // one synth pays it.
+        for (let instance = 0; instance < instanceCount; instance += 1) {
+            renderPass(plan.tracks.filter((t) => assignments.get(t.id)?.instance === instance));
+        }
+        synth.midiAllSoundsOff();
+        // Last in the chain, exactly as the limiter sits after the master gain on
+        // the live bus. The trim sizes the mix for its average level; this catches
+        // the phase-aligned moments it cannot predict, which would otherwise reach
+        // the encoders and be clamped.
+        limitPeaks(samples, sampleRate);
+        return { samples, sampleRate };
+        /** Configures this instance's channels, then sums its audio into `samples`. */
+        function renderPass(tracks) {
+            const channelFor = new Map();
+            // The synth is shared across exports, so it starts dirty; and whatever a
+            // previous pass left ringing is not part of this one either.
+            synth.midiAllSoundsOff();
+            for (const track of tracks) {
+                const assignment = assignments.get(track.id);
+                if (!assignment)
+                    continue;
+                channelFor.set(track.id, assignment);
+                const { channel } = assignment;
+                if (track.isPercussion || assignment.needsDrumTypeSwitch) {
+                    // Channel 9 is percussion already; anything else must be told — and
+                    // told twice. Switching the type only routes *later* program changes
+                    // to the drum bank; the channel keeps the preset it had, which is a
+                    // piano, so a second drum track rendered its congas as piano notes.
+                    // Never select a melodic program on either: on channel 9 that
+                    // silences it.
+                    if (channel !== 9)
+                        synth.midiSetChannelType(channel, true);
+                    // Standard first so a kit the font lacks falls back to drums rather
+                    // than to the piano a switched channel starts on. General MIDI
+                    // selects the kit with a program change on the drum channel, so the
+                    // track's program is its kit.
+                    synth.midiProgramSelect(channel, sfontId, DRUM_BANK, STANDARD_KIT);
+                    if (track.midiProgram !== STANDARD_KIT) {
+                        synth.midiProgramSelect(channel, sfontId, DRUM_BANK, track.midiProgram);
+                    }
+                }
+                else {
+                    synth.midiSetChannelType(channel, false);
+                    synth.midiProgramSelect(channel, sfontId, 0, track.midiProgram);
+                }
+                synth.midiControl(channel, CC_VOLUME, Math.round(track.volume * MAX_CC));
+                synth.midiControl(channel, CC_PAN, panToCc(track.pan));
+            }
+            // Every note-on and note-off placed on the frame it falls due.
+            const timeline = [];
+            for (const event of plan.events) {
+                const assignment = channelFor.get(event.trackId);
+                if (!assignment)
+                    continue; // a track this pass does not own, or one the plan never listed
+                const { channel } = assignment;
+                const velocity = Math.max(1, Math.min(MAX_CC, Math.round(event.velocity * MAX_CC)));
+                timeline.push({
+                    atFrame: Math.round(event.startSec * sampleRate),
+                    run: () => synth.midiNoteOn(channel, event.midi, velocity),
+                });
+                timeline.push({
+                    atFrame: Math.round((event.startSec + event.durationSec) * sampleRate),
+                    run: () => synth.midiNoteOff(channel, event.midi),
+                });
+            }
+            timeline.sort((a, b) => a.atFrame - b.atFrame);
+            const left = new Float32Array(BLOCK_FRAMES);
+            const right = new Float32Array(BLOCK_FRAMES);
+            let next = 0;
+            for (let frame = 0; frame < totalFrames; frame += BLOCK_FRAMES) {
+                const blockEnd = frame + BLOCK_FRAMES;
+                while (next < timeline.length && timeline[next].atFrame < blockEnd)
+                    timeline[next++].run();
+                synth.render([left, right]);
+                // Mono mixdown, not just the left channel: a hard-panned track would
+                // otherwise vanish from the export while being audible in playback.
+                // Summed rather than assigned, so a second pass adds to the first.
+                const count = Math.min(BLOCK_FRAMES, totalFrames - frame);
+                for (let i = 0; i < count; i += 1) {
+                    samples[frame + i] += (left[i] + right[i]) * 0.5 * headroom;
+                }
+            }
+        }
+    };
+}
+function panToCc(pan) {
+    return Math.round(((Math.min(1, Math.max(-1, pan)) + 1) / 2) * MAX_CC);
+}
+//# sourceMappingURL=soundfont-render.js.map

package/dist/web/audio/soundfont-render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"soundfont-render.js","sourceRoot":"","sources":["../../../src/web/audio/soundfont-render.ts"],"names":[],"mappings":"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"}

package/dist/web/audio/synth-types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The slice of `js-synthesizer`'s non-worklet `Synthesizer` offline rendering
+ * uses, declared here so the renderer can be tested against a stub.
+ *
+ * Signatures follow the library's own `ISynthesizer`. Note `midiSetChannelType`
+ * takes a **boolean**, not a numeric channel-type constant — a mismatch that
+ * happens to work by truthiness and is therefore worth stating plainly.
+ */
+export type SynthesizerLike = {
+    init(sampleRate: number, settings?: {
+        midiChannelCount?: number;
+        polyphony?: number;
+    }): void;
+    loadSFont(bin: ArrayBuffer): Promise<number>;
+    render(outBuffer: Float32Array[]): void;
+    midiNoteOn(chan: number, key: number, vel: number): void;
+    midiNoteOff(chan: number, key: number): void;
+    midiControl(chan: number, ctrl: number, val: number): void;
+    midiProgramSelect(chan: number, sfontId: number, bank: number, presetNum: number): void;
+    midiSetChannelType(chan: number, isDrum: boolean): void;
+    midiAllSoundsOff(chan?: number): void;
+    close(): void;
+};
+//# sourceMappingURL=synth-types.d.ts.map

package/dist/web/audio/synth-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth-types.d.ts","sourceRoot":"","sources":["../../../src/web/audio/synth-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC7F,SAAS,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IACxC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACzD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3D,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACxF,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC;IACxD,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,KAAK,IAAI,IAAI,CAAC;CACf,CAAC"}

package/dist/web/audio/synth-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=synth-types.js.map

package/dist/web/audio/synth-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synth-types.js","sourceRoot":"","sources":["../../../src/web/audio/synth-types.ts"],"names":[],"mappings":""}

package/dist/web/index.d.ts

@@ -0,0 +1,40 @@
+import { MusicPlayer } from '../player.js';
+export * from '../types.js';
+export * from '../singleton.js';
+export { MusicPlayer };
+export { renderEvents } from '../shared/render-events.js';
+export { playbackPlan, playbackTracks, resolveVoice } from '../shared/plan.js';
+/**
+ * Where the soundfont engine's assets are served from.
+ *
+ * Passed in rather than resolved here: this is a library and cannot assume how
+ * a consuming app serves files out of `node_modules`. The worklet modules in
+ * particular must be reachable as URLs, because `addModule` takes a URL.
+ *
+ * Required, not optional: the soundfont synth is the only engine. There is no
+ * silent fallback to be had, and an app that has not hosted the assets should
+ * fail loudly at wiring time rather than mysteriously play nothing.
+ */
+export type SoundfontAssets = {
+    /** The `-with-libsndfile` build. The plain one cannot read SF3. */
+    fluidsynthModuleUrl: string;
+    workletModuleUrl: string;
+    fontUrl: string;
+};
+/** The web player, built fresh. Hand it to `initializeMusicPlayer`. */
+export declare function createMusicPlayer({ soundfont, }: {
+    soundfont: SoundfontAssets;
+}): MusicPlayer;
+/**
+ * Renders a plan to PCM, faster than realtime.
+ *
+ * Through the same soundfont as playback, so a file is a recording of what was
+ * heard — two voicing paths drift apart the first time one is tuned. The synth
+ * *plumbing* differs because it must: playback runs on a realtime
+ * `AudioContext` and rendering needs no context at all, and nothing bridges the
+ * two. What is shared is the voicing, which is the part that matters.
+ *
+ * The caller encodes and saves; this package does not touch files.
+ */
+export declare function renderSamples(soundfont: SoundfontAssets): (plan: import("@sudobility/music_types").RenderPlan) => Promise<import("@sudobility/music_types").DecodedAudio>;
+//# sourceMappingURL=index.d.ts.map

package/dist/web/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAgB/E;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,mEAAmE;IACnE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,EAChC,SAAS,GACV,EAAE;IACD,SAAS,EAAE,eAAe,CAAC;CAC5B,GAAG,WAAW,CAWd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,eAAe,mHAOvD"}

package/dist/web/index.js

@@ -0,0 +1,59 @@
+/**
+ * The web player: libfluidsynth (WebAssembly) inside an `AudioWorklet`.
+ *
+ * Resolved by any bundler that is not Metro, through the `default` branch of
+ * this package's export condition.
+ */
+import { SoundfontPlaybackEngine } from './playback/soundfont-engine.js';
+import { SynthHost } from './playback/synth-host.js';
+import { loadSoundfont, openSoundfontCache, } from './playback/soundfont-loader.js';
+import { createSoundfontRenderer } from './audio/soundfont-render.js';
+import { MusicPlayer } from '../player.js';
+export * from '../types.js';
+export * from '../singleton.js';
+export { MusicPlayer };
+export { renderEvents } from '../shared/render-events.js';
+export { playbackPlan, playbackTracks, resolveVoice } from '../shared/plan.js';
+/**
+ * Builds one real `AudioWorkletNodeSynthesizer`.
+ *
+ * The only place `js-synthesizer` is constructed, and the import is lazy so an
+ * app that never plays anything does not pull it in. Async by design: a
+ * synchronous factory would need the module loaded first, and a caller
+ * forgetting that step would fail at init with no sound and no obvious cause —
+ * the failure shape this engine exists to remove.
+ */
+async function createWorkletSynth() {
+    const { AudioWorkletNodeSynthesizer } = await import('js-synthesizer');
+    return new AudioWorkletNodeSynthesizer();
+}
+/** The web player, built fresh. Hand it to `initializeMusicPlayer`. */
+export function createMusicPlayer({ soundfont, }) {
+    return new MusicPlayer(new SoundfontPlaybackEngine({
+        host: new SynthHost({ createSynth: createWorkletSynth }),
+        moduleUrls: {
+            fluidsynth: soundfont.fluidsynthModuleUrl,
+            worklet: soundfont.workletModuleUrl,
+        },
+        fontUrl: soundfont.fontUrl,
+    }));
+}
+/**
+ * Renders a plan to PCM, faster than realtime.
+ *
+ * Through the same soundfont as playback, so a file is a recording of what was
+ * heard — two voicing paths drift apart the first time one is tuned. The synth
+ * *plumbing* differs because it must: playback runs on a realtime
+ * `AudioContext` and rendering needs no context at all, and nothing bridges the
+ * two. What is shared is the voicing, which is the part that matters.
+ *
+ * The caller encodes and saves; this package does not touch files.
+ */
+export function renderSamples(soundfont) {
+    return createSoundfontRenderer({
+        fluidsynthModuleUrl: soundfont.fluidsynthModuleUrl,
+        fontUrl: soundfont.fontUrl,
+        loadFont: async (url) => loadSoundfont(url, { cache: await openSoundfontCache() }),
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/web/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/web/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAErD,OAAO,EACL,aAAa,EACb,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE/E;;;;;;;;GAQG;AACH,KAAK,UAAU,kBAAkB;IAC/B,MAAM,EAAE,2BAA2B,EAAE,GAAG,MAAM,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACvE,OAAO,IAAI,2BAA2B,EAA8B,CAAC;AACvE,CAAC;AAoBD,uEAAuE;AACvE,MAAM,UAAU,iBAAiB,CAAC,EAChC,SAAS,GAGV;IACC,OAAO,IAAI,WAAW,CACpB,IAAI,uBAAuB,CAAC;QAC1B,IAAI,EAAE,IAAI,SAAS,CAAC,EAAE,WAAW,EAAE,kBAAkB,EAAE,CAAC;QACxD,UAAU,EAAE;YACV,UAAU,EAAE,SAAS,CAAC,mBAAmB;YACzC,OAAO,EAAE,SAAS,CAAC,gBAAgB;SACpC;QACD,OAAO,EAAE,SAAS,CAAC,OAAO;KAC3B,CAAC,CACH,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,SAA0B;IACtD,OAAO,uBAAuB,CAAC;QAC7B,mBAAmB,EAAE,SAAS,CAAC,mBAAmB;QAClD,OAAO,EAAE,SAAS,CAAC,OAAO;QAC1B,QAAQ,EAAE,KAAK,EAAC,GAAG,EAAC,EAAE,CACpB,aAAa,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,MAAM,kBAAkB,EAAE,EAAE,CAAC;KAC5D,CAAC,CAAC;AACL,CAAC"}

package/dist/web/playback/channel-allocator.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Which synth instance and MIDI channel each track plays on.
+ *
+ * General MIDI addresses 16 channels, but fluidsynth does not: its
+ * `midi-channels` setting takes 16-256 in multiples of 16, and one instance at
+ * 256 covers every realistic score with a single copy of the soundfont in WASM
+ * memory. This used to assume 16, which opened another instance — and another
+ * 23MB font copy — every sixteen tracks.
+ *
+ * Three rules shape the allocation, all of them facts about fluidsynth rather
+ * than preferences:
+ *
+ * - **Channel 9 is percussion and cannot be anything else.** The spike found
+ *   that a drum track sounds there only if left completely alone: selecting a
+ *   program on it silences the channel. So percussion prefers channel 9, and a
+ *   pitched track may never take it.
+ * - **Whether channels 25, 41, ... are also percussion is undocumented.**
+ *   General MIDI's drum channel is the tenth of each block of sixteen, and
+ *   whether fluidsynth extends that convention past its first block cannot be
+ *   determined without a real synth. Every `c % 16 === 9` is therefore kept
+ *   away from pitched tracks: correct under either behaviour, and it costs
+ *   sixteen channels out of 256.
+ * - **Any channel can be made percussion** with `midiSetChannelType`. That is
+ *   what lets a seventeenth drum track share an instance instead of costing a
+ *   whole new synth just to reach another drum-capable channel.
+ *
+ * Instances are therefore opened only when channels genuinely run out, which
+ * now means past 240 pitched tracks rather than past 15.
+ */
+export type ChannelAssignment = {
+    instance: number;
+    channel: number;
+    /**
+     * True when the channel is percussion but is not channel 9, so the engine
+     * must call `midiSetChannelType` on it. Channel 9 needs nothing.
+     */
+    needsDrumTypeSwitch: boolean;
+};
+export type AllocatorTrack = {
+    id: string;
+    isPercussion: boolean;
+};
+/**
+ * Channels one fluidsynth instance addresses.
+ *
+ * `midiChannelCount` accepts 16-256 in multiples of 16, so a single synth
+ * covers every realistic score with one copy of the soundfont in WASM memory.
+ */
+export declare const CHANNELS_PER_INSTANCE = 256;
+export declare function allocateChannels(tracks: readonly AllocatorTrack[]): {
+    assignments: Map<string, ChannelAssignment>;
+    instanceCount: number;
+};
+//# sourceMappingURL=channel-allocator.d.ts.map

package/dist/web/playback/channel-allocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-allocator.d.ts","sourceRoot":"","sources":["../../../src/web/playback/channel-allocator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAAC;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAUzC,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG;IACnE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC5C,aAAa,EAAE,MAAM,CAAC;CACvB,CA4DA"}

package/dist/web/playback/channel-allocator.js

@@ -0,0 +1,72 @@
+/**
+ * Channels one fluidsynth instance addresses.
+ *
+ * `midiChannelCount` accepts 16-256 in multiples of 16, so a single synth
+ * covers every realistic score with one copy of the soundfont in WASM memory.
+ */
+export const CHANNELS_PER_INSTANCE = 256;
+/** The one channel fluidsynth already types as drums, so it needs no switch. */
+const DEFAULT_PERCUSSION_CHANNEL = 9;
+/** Channels reserved for percussion; see this module's doc for why it is not just 9. */
+function isDrumCapable(channel) {
+    return channel % 16 === 9;
+}
+export function allocateChannels(tracks) {
+    const assignments = new Map();
+    /** Taken channels per instance; the array length is the instance count. */
+    const taken = [new Set()];
+    const freeChannel = (instance, wantDrum) => {
+        for (let channel = 0; channel < CHANNELS_PER_INSTANCE; channel += 1) {
+            if (isDrumCapable(channel) !== wantDrum)
+                continue;
+            if (!taken[instance].has(channel))
+                return channel;
+        }
+        return null;
+    };
+    const claim = (id, instance, channel, isPercussion) => {
+        taken[instance].add(channel);
+        assignments.set(id, {
+            instance,
+            channel,
+            // False for every pitched track. `soundfont-render.ts` branches on
+            // `track.isPercussion || assignment.needsDrumTypeSwitch`, so a pitched
+            // track carrying this flag would be sent a drum-bank program select and
+            // export as percussion.
+            //
+            // Among percussion, only instance 0's channel 9 is fluidsynth's own drum
+            // channel; every other drum slot has to be told what it is.
+            needsDrumTypeSwitch: isPercussion && !(instance === 0 && channel === DEFAULT_PERCUSSION_CHANNEL),
+        });
+    };
+    /** Places `id` on the first instance with a free channel of the wanted kind, opening one if none has. */
+    const place = (id, wantDrum, isPercussion) => {
+        for (let instance = 0; instance < taken.length; instance += 1) {
+            const channel = freeChannel(instance, wantDrum);
+            if (channel !== null) {
+                claim(id, instance, channel, isPercussion);
+                return;
+            }
+        }
+        taken.push(new Set());
+        // A fresh instance always has a free channel of either kind.
+        claim(id, taken.length - 1, freeChannel(taken.length - 1, wantDrum), isPercussion);
+    };
+    // Percussion first, so the drum-capable channels reach the tracks that need
+    // them before a pitched track can push one onto a second instance.
+    for (const track of tracks) {
+        if (!track.isPercussion)
+            continue;
+        // Prefer a drum-capable channel; fall back to an ordinary one, switched
+        // explicitly, rather than opening an instance for the sake of one channel.
+        const hasDrumSlot = taken.some((_, instance) => freeChannel(instance, true) !== null);
+        place(track.id, hasDrumSlot, true);
+    }
+    for (const track of tracks) {
+        if (track.isPercussion)
+            continue;
+        place(track.id, false, false);
+    }
+    return { assignments, instanceCount: taken.length };
+}
+//# sourceMappingURL=channel-allocator.js.map

package/dist/web/playback/channel-allocator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel-allocator.js","sourceRoot":"","sources":["../../../src/web/playback/channel-allocator.ts"],"names":[],"mappings":"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"}

package/dist/web/playback/click.d.ts

@@ -0,0 +1,9 @@
+/** A click already on the audio graph, and the two things a caller can do with it. */
+export type ScheduledClick = {
+    /** When it has finished sounding, so a caller knows when to forget it. */
+    readonly endsAt: number;
+    /** Silences it from `atSeconds`, whether or not it has begun. */
+    cancel(atSeconds: number): void;
+};
+export declare function scheduleClick(context: BaseAudioContext, destination: AudioNode, atSeconds: number, accent: boolean): ScheduledClick;
+//# sourceMappingURL=click.d.ts.map

package/dist/web/playback/click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"click.d.ts","sourceRoot":"","sources":["../../../src/web/playback/click.ts"],"names":[],"mappings":"AAyBA,sFAAsF;AACtF,MAAM,MAAM,cAAc,GAAG;IAC3B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,iEAAiE;IACjE,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CAAC;AAEF,wBAAgB,aAAa,CAC3B,OAAO,EAAE,gBAAgB,EACzB,WAAW,EAAE,SAAS,EACtB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,GACd,cAAc,CAqChB"}

package/dist/web/playback/click.js

@@ -0,0 +1,61 @@
+/**
+ * The metronome click, in plain Web Audio.
+ *
+ * Not routed through the synth, and not through the mixer. A click is a
+ * monitoring aid rather than part of the music, so the master headroom trim and
+ * the per-track balance have no business changing how loud it is — and it
+ * should not consume one of the sixteen MIDI channels a score might need.
+ *
+ * Unlike notes, clicks are scheduled *ahead* at an exact time: an oscillator
+ * started with `start(at)` sounds at that sample whatever the main thread is
+ * doing. So the click stays steady even when the pump runs late, which makes it
+ * a usable reference rather than a second thing to distrust.
+ *
+ * Which is also why scheduling one hands back a way to take it back. The
+ * engine keeps a whole horizon of them queued, and `allSoundOff` does not
+ * reach any of it — that speaks to the synth, and a click deliberately does
+ * not go through the synth. So pausing left the room ticking for as long as
+ * the horizon was deep.
+ */
+const ACCENT_HZ = 1500;
+const BEAT_HZ = 1000;
+const CLICK_SECONDS = 0.03;
+/** Quiet enough to sit under the music, loud enough to hear over it. */
+const CLICK_PEAK = 0.25;
+export function scheduleClick(context, destination, atSeconds, accent) {
+    const oscillator = context.createOscillator();
+    const gain = context.createGain();
+    oscillator.frequency.value = accent ? ACCENT_HZ : BEAT_HZ;
+    oscillator.connect(gain);
+    gain.connect(destination);
+    // A short decay rather than a hard stop: a square-edged gate on a sine is an
+    // audible tick of its own.
+    const end = atSeconds + CLICK_SECONDS;
+    gain.gain.setValueAtTime(CLICK_PEAK, atSeconds);
+    gain.gain.exponentialRampToValueAtTime(0.0001, end);
+    oscillator.start(atSeconds);
+    oscillator.stop(end);
+    let released = false;
+    oscillator.onended = () => {
+        released = true;
+        oscillator.disconnect();
+        gain.disconnect();
+    };
+    return {
+        endsAt: end,
+        cancel(from) {
+            // Nothing to take back once it has run its course. `onended` is the
+            // reliable signal but it arrives on a later task, so the time is checked
+            // too — a click that finished microseconds ago is still finished.
+            if (released || from >= end)
+                return;
+            // Drops the peak scheduled above when `from` precedes it, so a click
+            // cancelled before it begins never gets a level at all.
+            gain.gain.cancelScheduledValues(from);
+            gain.gain.setValueAtTime(0, from);
+            // A stop at or before the start means it simply never plays.
+            oscillator.stop(from);
+        },
+    };
+}
+//# sourceMappingURL=click.js.map