@modernized/osmd-audio-player 1.0.1

package/dist/internals/EventEmitter.js

@@ -0,0 +1,17 @@
+export class EventEmitter {
+    constructor() {
+        this.subscribers = new Map();
+    }
+    on(event, callback) {
+        if (!this.subscribers.get(event)) {
+            this.subscribers.set(event, []);
+        }
+        this.subscribers.get(event).push(callback);
+    }
+    emit(event, ...args) {
+        const subscribers = this.subscribers.get(event) || [];
+        for (const sub of subscribers) {
+            sub(...args);
+        }
+    }
+}

package/dist/internals/StepQueue.d.ts

@@ -0,0 +1,16 @@
+import { Note } from "opensheetmusicdisplay";
+type ScheduledNotes = {
+    tick: number;
+    notes: Note[];
+};
+export default class StepQueue {
+    steps: ScheduledNotes[];
+    constructor();
+    [Symbol.iterator](): ArrayIterator<ScheduledNotes>;
+    createStep(tick: number): ScheduledNotes;
+    addNote(tick: number, note: Note): void;
+    delete(value: ScheduledNotes): void;
+    sort(): StepQueue;
+    getFirstEmptyTick(): number;
+}
+export {};

package/dist/internals/StepQueue.js

@@ -0,0 +1,32 @@
+export default class StepQueue {
+    constructor() {
+        this.steps = [];
+    }
+    [Symbol.iterator]() {
+        return this.steps.values();
+    }
+    createStep(tick) {
+        let step = this.steps.find((s) => s.tick === tick);
+        if (!step) {
+            step = { tick, notes: [] };
+            this.steps.push(step);
+        }
+        return step;
+    }
+    addNote(tick, note) {
+        const step = this.steps.find((s) => s.tick === tick) ?? this.createStep(tick);
+        step.notes.push(note);
+    }
+    delete(value) {
+        const index = this.steps.findIndex((v) => v.tick === value.tick);
+        if (index != null)
+            this.steps.splice(index, 1);
+    }
+    sort() {
+        this.steps.sort((a, b) => a.tick - b.tick);
+        return this;
+    }
+    getFirstEmptyTick() {
+        return this.sort().steps.filter((s) => !s.notes.length)[0].tick;
+    }
+}

package/dist/internals/noteHelpers.d.ts

@@ -0,0 +1,5 @@
+import { Note } from "opensheetmusicdisplay";
+import { ArticulationStyle } from "../players/NotePlaybackOptions";
+export declare function getNoteArticulationStyle(note: Note): ArticulationStyle;
+export declare function getNoteDuration(note: Note, wholeNoteLength: any): number;
+export declare function getNoteVolume(note: Note): number;

package/dist/internals/noteHelpers.js

@@ -0,0 +1,24 @@
+import { ArticulationStyle } from "../players/NotePlaybackOptions";
+export function getNoteArticulationStyle(note) {
+    if (note.ParentVoiceEntry.isStaccato()) {
+        return ArticulationStyle.Staccato;
+    }
+    else {
+        return ArticulationStyle.None;
+    }
+}
+export function getNoteDuration(note, wholeNoteLength) {
+    let duration = note.Length.RealValue * wholeNoteLength;
+    if (note.NoteTie) {
+        if (Object.is(note.NoteTie.StartNote, note) && note.NoteTie.Notes[1]) {
+            duration += note.NoteTie.Notes[1].Length.RealValue * wholeNoteLength;
+        }
+        else {
+            duration = 0;
+        }
+    }
+    return duration;
+}
+export function getNoteVolume(note) {
+    return note.ParentVoiceEntry.ParentVoice.Volume;
+}

package/dist/midi/midiInstruments.d.ts

@@ -0,0 +1 @@
+export declare const midiInstruments: [number, string][];

package/dist/midi/midiInstruments.js

@@ -0,0 +1,130 @@
+export const midiInstruments = [
+    [0, "Acoustic Grand Piano"],
+    [1, "Bright Acoustic Piano"],
+    [2, "Electric Grand Piano"],
+    [3, "Honky-tonk Piano"],
+    [4, "Electric Piano 1"],
+    [5, "Electric Piano 2"],
+    [6, "Harpsichord"],
+    [7, "Clavi"],
+    [8, "Celesta"],
+    [9, "Glockenspiel"],
+    [10, "Music Box"],
+    [11, "Vibraphone"],
+    [12, "Marimba"],
+    [13, "Xylophone"],
+    [14, "Tubular Bells"],
+    [15, "Dulcimer"],
+    [16, "Drawbar Organ"],
+    [17, "Percussive Organ"],
+    [18, "Rock Organ"],
+    [19, "Church Organ"],
+    [20, "Reed Organ"],
+    [21, "Accordion"],
+    [22, "Harmonica"],
+    [23, "Tango Accordion"],
+    [24, "Acoustic Guitar (nylon)"],
+    [25, "Acoustic Guitar (steel)"],
+    [26, "Electric Guitar (jazz)"],
+    [27, "Electric Guitar (clean)"],
+    [28, "Electric Guitar (muted)"],
+    [29, "Overdriven Guitar"],
+    [30, "Distortion Guitar"],
+    [31, "Guitar harmonics"],
+    [32, "Acoustic Bass"],
+    [33, "Electric Bass (finger)"],
+    [34, "Electric Bass (pick)"],
+    [35, "Fretless Bass"],
+    [36, "Slap Bass 1"],
+    [37, "Slap Bass 2"],
+    [38, "Synth Bass 1"],
+    [39, "Synth Bass 2"],
+    [40, "Violin"],
+    [41, "Viola"],
+    [42, "Cello"],
+    [43, "Contrabass"],
+    [44, "Tremolo Strings"],
+    [45, "Pizzicato Strings"],
+    [46, "Orchestral Harp"],
+    [47, "Timpani"],
+    [48, "String Ensemble 1"],
+    [49, "String Ensemble 2"],
+    [50, "SynthStrings 1"],
+    [51, "SynthStrings 2"],
+    [52, "Choir Aahs"],
+    [53, "Voice Oohs"],
+    [54, "Synth Choir"],
+    [55, "Orchestra Hit"],
+    [56, "Trumpet"],
+    [57, "Trombone"],
+    [58, "Tuba"],
+    [59, "Muted Trumpet"],
+    [60, "French Horn"],
+    [61, "Brass Section"],
+    [62, "SynthBrass 1"],
+    [63, "SynthBrass 2"],
+    [64, "Soprano Sax"],
+    [65, "Alto Sax"],
+    [66, "Tenor Sax"],
+    [67, "Baritone Sax"],
+    [68, "Oboe"],
+    [69, "English Horn"],
+    [70, "Bassoon"],
+    [71, "Clarinet"],
+    [72, "Piccolo"],
+    [73, "Flute"],
+    [74, "Recorder"],
+    [75, "Pan Flute"],
+    [76, "Blown Bottle"],
+    [77, "Shakuhachi"],
+    [78, "Whistle"],
+    [79, "Ocarina"],
+    [80, "Lead 1 (square)"],
+    [81, "Lead 2 (sawtooth)"],
+    [82, "Lead 3 (calliope)"],
+    [83, "Lead 4 (chiff)"],
+    [84, "Lead 5 (charang)"],
+    [85, "Lead 6 (voice)"],
+    [86, "Lead 7 (fifths)"],
+    [87, "Lead 8 (bass + lead)"],
+    [88, "Pad 1 (new age)"],
+    [89, "Pad 2 (warm)"],
+    [90, "Pad 3 (polysynth)"],
+    [91, "Pad 4 (choir)"],
+    [92, "Pad 5 (bowed)"],
+    [93, "Pad 6 (metallic)"],
+    [94, "Pad 7 (halo)"],
+    [95, "Pad 8 (sweep)"],
+    [96, "FX 1 (rain)"],
+    [97, "FX 2 (soundtrack)"],
+    [98, "FX 3 (crystal)"],
+    [99, "FX 4 (atmosphere)"],
+    [100, "FX 5 (brightness)"],
+    [101, "FX 6 (goblins)"],
+    [102, "FX 7 (echoes)"],
+    [103, "FX 8 (sci-fi)"],
+    [104, "Sitar"],
+    [105, "Banjo"],
+    [106, "Shamisen"],
+    [107, "Koto"],
+    [108, "Kalimba"],
+    [109, "Bag pipe"],
+    [110, "Fiddle"],
+    [111, "Shanai"],
+    [112, "Tinkle Bell"],
+    [113, "Agogo"],
+    [114, "Steel Drums"],
+    [115, "Woodblock"],
+    [116, "Taiko Drum"],
+    [117, "Melodic Tom"],
+    [118, "Synth Drum"],
+    [119, "Reverse Cymbal"],
+    [120, "Guitar Fret Noise"],
+    [121, "Breath Noise"],
+    [122, "Seashore"],
+    [123, "Bird Tweet"],
+    [124, "Telephone Ring"],
+    [125, "Helicopter"],
+    [126, "Applause"],
+    [127, "Gunshot"],
+];

package/dist/players/InstrumentPlayer.d.ts

@@ -0,0 +1,15 @@
+import { NotePlaybackInstruction } from "./NotePlaybackOptions";
+import { IAudioContext } from "standardized-audio-context";
+export interface PlaybackInstrument {
+    midiId: number;
+    name: string;
+    loaded: boolean;
+}
+export interface InstrumentPlayer {
+    instruments: PlaybackInstrument[];
+    init: (audioContext: IAudioContext) => void;
+    load: (midiId: number) => Promise<void>;
+    schedule: (midiId: number, time: number, notes: NotePlaybackInstruction[]) => void;
+    play: (midiId: number, options: NotePlaybackInstruction) => void;
+    stop: (midiId: number) => void;
+}

package/dist/players/InstrumentPlayer.js

@@ -0,0 +1 @@
+export {};

package/dist/players/NotePlaybackOptions.d.ts

@@ -0,0 +1,13 @@
+export declare enum ArticulationStyle {
+    None = 0,
+    Staccato = 1,
+    Legato = 2
+}
+export interface NotePlaybackStyle {
+    articulation: ArticulationStyle;
+}
+export interface NotePlaybackInstruction extends NotePlaybackStyle {
+    note: number;
+    gain: number;
+    duration: number;
+}

package/dist/players/NotePlaybackOptions.js

@@ -0,0 +1,6 @@
+export var ArticulationStyle;
+(function (ArticulationStyle) {
+    ArticulationStyle[ArticulationStyle["None"] = 0] = "None";
+    ArticulationStyle[ArticulationStyle["Staccato"] = 1] = "Staccato";
+    ArticulationStyle[ArticulationStyle["Legato"] = 2] = "Legato";
+})(ArticulationStyle || (ArticulationStyle = {}));

package/dist/players/SoundfontPlayer.d.ts

@@ -0,0 +1,17 @@
+import { InstrumentPlayer, PlaybackInstrument } from "./InstrumentPlayer";
+import { NotePlaybackStyle, NotePlaybackInstruction } from "./NotePlaybackOptions";
+import { IAudioContext } from "standardized-audio-context";
+export declare class SoundfontPlayer implements InstrumentPlayer {
+    instruments: PlaybackInstrument[];
+    private players;
+    private audioContext;
+    constructor();
+    init(audioContext: IAudioContext): void;
+    load(midiId: number): Promise<void>;
+    play: (midiId: string | number, options: NotePlaybackStyle) => void;
+    stop(midiId: number): void;
+    schedule(midiId: number, time: number, notes: NotePlaybackInstruction[]): void;
+    private applyDynamics;
+    private verifyPlayerLoaded;
+    private getSoundfontInstrumentName;
+}

package/dist/players/SoundfontPlayer.js

@@ -0,0 +1,54 @@
+import { ArticulationStyle, } from "./NotePlaybackOptions";
+import { midiInstruments } from "../midi/midiInstruments";
+import supportedSoundfontInstruments from "./musyngkiteInstruments";
+import * as Soundfont from "soundfont-player";
+export class SoundfontPlayer {
+    constructor() {
+        this.players = new Map();
+        this.instruments = midiInstruments
+            .filter((i) => supportedSoundfontInstruments.includes(this.getSoundfontInstrumentName(i[1])))
+            .map((i) => ({
+            midiId: i[0],
+            name: i[1],
+            loaded: false,
+        }));
+    }
+    init(audioContext) {
+        this.audioContext = audioContext;
+    }
+    async load(midiId) {
+        const instrument = this.instruments.find((i) => i.midiId === midiId);
+        if (!instrument) {
+            throw new Error("SoundfontPlayer does not support midi instrument ID " + midiId);
+        }
+        if (this.players.has(midiId))
+            return;
+        const player = await Soundfont.instrument(this.audioContext, this.getSoundfontInstrumentName(instrument.name));
+        this.players.set(midiId, player);
+    }
+    stop(midiId) {
+        if (!this.players.has(midiId))
+            return;
+        this.players.get(midiId).stop();
+    }
+    schedule(midiId, time, notes) {
+        this.verifyPlayerLoaded(midiId);
+        this.applyDynamics(notes);
+        this.players.get(midiId).schedule(time, notes);
+    }
+    applyDynamics(notes) {
+        for (const note of notes) {
+            if (note.articulation === ArticulationStyle.Staccato) {
+                note.gain = Math.max(note.gain + 0.3, note.gain * 1.3);
+                note.duration = Math.min(note.duration * 0.4, 0.4);
+            }
+        }
+    }
+    verifyPlayerLoaded(midiId) {
+        if (!this.players.has(midiId))
+            throw new Error("No soundfont player loaded for midi instrument " + midiId);
+    }
+    getSoundfontInstrumentName(midiName) {
+        return midiName.toLowerCase().replace(/\s+/g, "_");
+    }
+}

package/dist/players/musyngkiteInstruments.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/players/musyngkiteInstruments.js

@@ -0,0 +1,130 @@
+export default [
+    "accordion",
+    "acoustic_bass",
+    "acoustic_grand_piano",
+    "acoustic_guitar_nylon",
+    "acoustic_guitar_steel",
+    "agogo",
+    "alto_sax",
+    "applause",
+    "bagpipe",
+    "banjo",
+    "baritone_sax",
+    "bassoon",
+    "bird_tweet",
+    "blown_bottle",
+    "brass_section",
+    "breath_noise",
+    "bright_acoustic_piano",
+    "celesta",
+    "cello",
+    "choir_aahs",
+    "church_organ",
+    "clarinet",
+    "clavinet",
+    "contrabass",
+    "distortion_guitar",
+    "drawbar_organ",
+    "dulcimer",
+    "electric_bass_finger",
+    "electric_bass_pick",
+    "electric_grand_piano",
+    "electric_guitar_clean",
+    "electric_guitar_jazz",
+    "electric_guitar_muted",
+    "electric_piano_1",
+    "electric_piano_2",
+    "english_horn",
+    "fiddle",
+    "flute",
+    "french_horn",
+    "fretless_bass",
+    "fx_1_rain",
+    "fx_2_soundtrack",
+    "fx_3_crystal",
+    "fx_4_atmosphere",
+    "fx_5_brightness",
+    "fx_6_goblins",
+    "fx_7_echoes",
+    "fx_8_scifi",
+    "glockenspiel",
+    "guitar_fret_noise",
+    "guitar_harmonics",
+    "gunshot",
+    "harmonica",
+    "harpsichord",
+    "helicopter",
+    "honkytonk_piano",
+    "kalimba",
+    "koto",
+    "lead_1_square",
+    "lead_2_sawtooth",
+    "lead_3_calliope",
+    "lead_4_chiff",
+    "lead_5_charang",
+    "lead_6_voice",
+    "lead_7_fifths",
+    "lead_8_bass__lead",
+    "marimba",
+    "melodic_tom",
+    "music_box",
+    "muted_trumpet",
+    "oboe",
+    "ocarina",
+    "orchestra_hit",
+    "orchestral_harp",
+    "overdriven_guitar",
+    "pad_1_new_age",
+    "pad_2_warm",
+    "pad_3_polysynth",
+    "pad_4_choir",
+    "pad_5_bowed",
+    "pad_6_metallic",
+    "pad_7_halo",
+    "pad_8_sweep",
+    "pan_flute",
+    "percussive_organ",
+    "piccolo",
+    "pizzicato_strings",
+    "recorder",
+    "reed_organ",
+    "reverse_cymbal",
+    "rock_organ",
+    "seashore",
+    "shakuhachi",
+    "shamisen",
+    "shanai",
+    "sitar",
+    "slap_bass_1",
+    "slap_bass_2",
+    "soprano_sax",
+    "steel_drums",
+    "string_ensemble_1",
+    "string_ensemble_2",
+    "synth_bass_1",
+    "synth_bass_2",
+    "synth_brass_1",
+    "synth_brass_2",
+    "synth_choir",
+    "synth_drum",
+    "synth_strings_1",
+    "synth_strings_2",
+    "taiko_drum",
+    "tango_accordion",
+    "telephone_ring",
+    "tenor_sax",
+    "timpani",
+    "tinkle_bell",
+    "tremolo_strings",
+    "trombone",
+    "trumpet",
+    "tuba",
+    "tubular_bells",
+    "vibraphone",
+    "viola",
+    "violin",
+    "voice_oohs",
+    "whistle",
+    "woodblock",
+    "xylophone",
+];

package/eslint.config.js

@@ -0,0 +1,12 @@
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+import prettier from "eslint-config-prettier";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  prettier,
+  {
+    ignores: ["dist/", "umd/", "demos/", "rollup.umd.config.js"],
+  },
+);

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@modernized/osmd-audio-player",
+  "version": "1.0.1",
+  "description": "OSMD audio player (fork of osmd-audio-player with modernized build system)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "dev": "tsc -w",
+    "test": "vitest run",
+    "prepare": "yarn build",
+    "build": "tsc -p tsconfig.build.json",
+    "build-umd": "rollup -c rollup.umd.config.js",
+    "install-demo:vue": "yarn --cwd demos/vue-player-demo install",
+    "install-demo:basic": "yarn --cwd demos/basic install",
+    "install-demos": "run-p install-demo:*",
+    "build-demo:vue": "yarn --cwd demos/vue-player-demo build",
+    "build-demo:basic": "yarn --cwd demos/basic build",
+    "build-demos": "run-p build-demo:*",
+    "build-all": "run-s build build-umd build-demos",
+    "netlify-build": "run-s build install-demos build-demos",
+    "lint": "eslint src/",
+    "format": "prettier --write src/"
+  },
+  "author": "Jimmy Utterström",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/modernized-js/osmd-audio-player"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "MusicXML",
+    "Music XML",
+    "audio player",
+    "MusicXML audio",
+    "music notation"
+  ],
+  "dependencies": {
+    "opensheetmusicdisplay": "^1.9.7",
+    "soundfont-player": "^0.12.0",
+    "standardized-audio-context": "^25.3.77"
+  },
+  "resolutions": {
+    "tar": ">=7.5.7"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-commonjs": "^29.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-terser": "^1.0.0",
+    "@rollup/plugin-typescript": "^12.3.0",
+    "eslint": "^10.2.0",
+    "eslint-config-prettier": "^10.1.8",
+    "jsdom": "^29.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^3.8.1",
+    "rollup": "^4.60.1",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.58.0",
+    "vitest": "^4.1.2"
+  }
+}

package/rollup.umd.config.js

@@ -0,0 +1,23 @@
+import typescript from "@rollup/plugin-typescript";
+import { nodeResolve } from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import terser from "@rollup/plugin-terser";
+
+export default {
+  input: "src/index.ts",
+  output: [
+    {
+      file: "umd/OsmdAudioPlayer.min.js",
+      format: "umd",
+      name: "OsmdAudioPlayer",
+    },
+  ],
+  plugins: [
+    typescript({ declaration: false }),
+    nodeResolve(),
+    commonjs({
+      include: "node_modules/**",
+    }),
+    terser(),
+  ],
+};

package/src/PlaybackEngine.test.ts

@@ -0,0 +1,99 @@
+import { describe, test, expect, vi } from "vitest";
+import PlaybackEngine from ".";
+import { OpenSheetMusicDisplay } from "opensheetmusicdisplay";
+import { PlaybackEvent, PlaybackState } from "./PlaybackEngine";
+import { IAudioContext } from "standardized-audio-context";
+
+vi.mock("./PlaybackScheduler");
+
+describe("PlaybackEngine", () => {
+  describe("Events", () => {
+    test("Playback state event on loadScore()", async () => {
+      const acMock = createMockedAudioContext();
+      const osmdMock = createOsmdMock();
+      const stateCb = vi.fn();
+
+      const pbEngine = new PlaybackEngine(acMock);
+
+      pbEngine.on(PlaybackEvent.STATE_CHANGE, stateCb);
+      await pbEngine.loadScore(osmdMock);
+
+      expect(stateCb).toHaveBeenCalledTimes(1);
+      expect(stateCb).toHaveBeenCalledWith(PlaybackState.STOPPED);
+    });
+
+    test("Playback state event on play()", async () => {
+      const acMock = createMockedAudioContext();
+      const osmdMock = createOsmdMock();
+      const stateCb = vi.fn();
+
+      const pbEngine = new PlaybackEngine(acMock);
+
+      await pbEngine.loadScore(osmdMock);
+      pbEngine.on(PlaybackEvent.STATE_CHANGE, stateCb);
+      await pbEngine.play();
+
+      expect(stateCb).toHaveBeenCalledTimes(1);
+      expect(stateCb).toHaveBeenCalledWith(PlaybackState.PLAYING);
+    });
+
+    test("Playback state event on stop()", async () => {
+      const acMock = createMockedAudioContext();
+      const osmdMock = createOsmdMock();
+      const stateCb = vi.fn();
+
+      const pbEngine = new PlaybackEngine(acMock);
+
+      await pbEngine.loadScore(osmdMock);
+      await pbEngine.play();
+      pbEngine.on(PlaybackEvent.STATE_CHANGE, stateCb);
+      await pbEngine.stop();
+
+      expect(stateCb).toHaveBeenCalledTimes(1);
+      expect(stateCb).toHaveBeenCalledWith(PlaybackState.STOPPED);
+    });
+
+    test("Playback state event on pause()", async () => {
+      const acMock = createMockedAudioContext();
+      const osmdMock = createOsmdMock();
+      const stateCb = vi.fn();
+
+      const pbEngine = new PlaybackEngine(acMock);
+
+      await pbEngine.loadScore(osmdMock);
+      await pbEngine.play();
+      pbEngine.on(PlaybackEvent.STATE_CHANGE, stateCb);
+      await pbEngine.pause();
+
+      expect(stateCb).toHaveBeenCalledTimes(1);
+      expect(stateCb).toHaveBeenCalledWith(PlaybackState.PAUSED);
+    });
+  });
+});
+
+function createMockedAudioContext(): IAudioContext {
+  return {
+    currentTime: 0,
+    suspend: vi.fn(async () => {}),
+    resume: vi.fn(async () => {}),
+  } as unknown as IAudioContext;
+}
+
+function createOsmdMock(): OpenSheetMusicDisplay {
+  return {
+    cursor: {
+      Iterator: { EndReached: true },
+      show: vi.fn(),
+      hide: vi.fn(),
+      next: vi.fn(),
+      reset: vi.fn(),
+      VoicesUnderCursor: vi.fn(() => []),
+    },
+    Sheet: {
+      Instruments: [],
+      SheetPlaybackSetting: { rhythm: {} },
+      HasBPMInfo: false,
+      DefaultStartTempoInBpm: 120,
+    },
+  } as unknown as OpenSheetMusicDisplay;
+}