build

docs/_snowpack/pkg/@tonejs/piano.js

@@ -0,0 +1,538 @@
+import { T as ToneAudioNode, V as Volume, F as Frequency, M as Midi, S as Sampler, a as ToneAudioBuffers, b as ToneBufferSource, o as optionsFromArguments, G as Gain, i as isString } from '../common/index-b6fc655f.js';
+import '../common/webmidi.min-97732fd4.js';
+import '../common/_commonjsHelpers-8c19dec8.js';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/**
+ * Base class for the other components
+ */
+class PianoComponent extends ToneAudioNode {
+    constructor(options) {
+        super(options);
+        this.name = 'PianoComponent';
+        this.input = undefined;
+        this.output = new Volume({ context: this.context });
+        /**
+         * If the component is enabled or not
+         */
+        this._enabled = false;
+        /**
+         * The volume output of the component
+         */
+        this.volume = this.output.volume;
+        /**
+         * Boolean indication of if the component is loaded or not
+         */
+        this._loaded = false;
+        this.volume.value = options.volume;
+        this._enabled = options.enabled;
+        this.samples = options.samples;
+    }
+    /**
+     * If the samples are loaded or not
+     */
+    get loaded() {
+        return this._loaded;
+    }
+    /**
+     * Load the samples
+     */
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._enabled) {
+                yield this._internalLoad();
+                this._loaded = true;
+            }
+            else {
+                return Promise.resolve();
+            }
+        });
+    }
+}
+
+// import * as Tone from '../node_modules/tone/Tone'
+function midiToNote(midi) {
+    const frequency = Frequency(midi, 'midi');
+    const ret = frequency.toNote();
+    return ret;
+}
+function randomBetween(low, high) {
+    return Math.random() * (high - low) + low;
+}
+
+function getReleasesUrl(midi) {
+    return `rel${midi - 20}.[mp3|ogg]`;
+}
+function getHarmonicsUrl(midi) {
+    return `harmS${midiToNote(midi).replace('#', 's')}.[mp3|ogg]`;
+}
+function getNotesUrl(midi, vel) {
+    return `${midiToNote(midi).replace('#', 's')}v${vel}.[mp3|ogg]`;
+}
+/**
+ * Maps velocity depths to Salamander velocities
+ */
+const velocitiesMap = {
+    1: [8],
+    2: [6, 12],
+    3: [1, 7, 15],
+    4: [1, 5, 10, 15],
+    5: [1, 4, 8, 12, 16],
+    6: [1, 3, 7, 10, 13, 16],
+    7: [1, 3, 6, 9, 11, 13, 16],
+    8: [1, 3, 5, 7, 9, 11, 13, 16],
+    9: [1, 3, 5, 7, 9, 11, 13, 15, 16],
+    10: [1, 2, 3, 5, 7, 9, 11, 13, 15, 16],
+    11: [1, 2, 3, 5, 7, 9, 11, 13, 14, 15, 16],
+    12: [1, 2, 3, 4, 5, 7, 9, 11, 13, 14, 15, 16],
+    13: [1, 2, 3, 4, 5, 7, 9, 11, 12, 13, 14, 15, 16],
+    14: [1, 2, 3, 4, 5, 6, 7, 9, 11, 12, 13, 14, 15, 16],
+    15: [1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16],
+    16: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+};
+/**
+ * All the notes of audio samples
+ */
+const allNotes = [
+    21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54,
+    57, 60, 63, 66, 69, 72, 75, 78, 81, 84,
+    87, 90, 93, 96, 99, 102, 105, 108
+];
+function getNotesInRange(min, max) {
+    return allNotes.filter(note => min <= note && note <= max);
+}
+/**
+ * All the notes of audio samples
+ */
+const harmonics = [21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63, 66, 69, 72, 75, 78, 81, 84, 87];
+function getHarmonicsInRange(min, max) {
+    return harmonics.filter(note => min <= note && note <= max);
+}
+function inHarmonicsRange(note) {
+    return harmonics[0] <= note && note <= harmonics[harmonics.length - 1];
+}
+
+class Harmonics extends PianoComponent {
+    constructor(options) {
+        super(options);
+        this._urls = {};
+        const notes = getHarmonicsInRange(options.minNote, options.maxNote);
+        for (const n of notes) {
+            this._urls[n] = getHarmonicsUrl(n);
+        }
+    }
+    triggerAttack(note, time, velocity) {
+        if (this._enabled && inHarmonicsRange(note)) {
+            this._sampler.triggerAttack(Midi(note).toNote(), time, velocity * randomBetween(0.5, 1));
+        }
+    }
+    _internalLoad() {
+        return new Promise(onload => {
+            this._sampler = new Sampler({
+                baseUrl: this.samples,
+                onload,
+                urls: this._urls,
+            }).connect(this.output);
+        });
+    }
+}
+
+class Keybed extends PianoComponent {
+    constructor(options) {
+        super(options);
+        /**
+         * The urls to load
+         */
+        this._urls = {};
+        for (let i = options.minNote; i <= options.maxNote; i++) {
+            this._urls[i] = getReleasesUrl(i);
+        }
+    }
+    _internalLoad() {
+        return new Promise(success => {
+            this._buffers = new ToneAudioBuffers(this._urls, success, this.samples);
+        });
+    }
+    start(note, time, velocity) {
+        if (this._enabled && this._buffers.has(note)) {
+            const source = new ToneBufferSource({
+                url: this._buffers.get(note),
+                context: this.context,
+            }).connect(this.output);
+            // randomize the velocity slightly
+            source.start(time, 0, undefined, 0.015 * velocity * randomBetween(0.5, 1));
+        }
+    }
+}
+
+class Pedal extends PianoComponent {
+    constructor(options) {
+        super(options);
+        this._downTime = Infinity;
+        this._currentSound = null;
+        this._downTime = Infinity;
+    }
+    _internalLoad() {
+        return new Promise((success) => {
+            this._buffers = new ToneAudioBuffers({
+                down1: 'pedalD1.mp3',
+                down2: 'pedalD2.mp3',
+                up1: 'pedalU1.mp3',
+                up2: 'pedalU2.mp3',
+            }, success, this.samples);
+        });
+    }
+    /**
+     *  Squash the current playing sound
+     */
+    _squash(time) {
+        if (this._currentSound && this._currentSound.state !== 'stopped') {
+            this._currentSound.stop(time);
+        }
+        this._currentSound = null;
+    }
+    _playSample(time, dir) {
+        if (this._enabled) {
+            this._currentSound = new ToneBufferSource({
+                url: this._buffers.get(`${dir}${Math.random() > 0.5 ? 1 : 2}`),
+                context: this.context,
+                curve: 'exponential',
+                fadeIn: 0.05,
+                fadeOut: 0.1,
+            }).connect(this.output);
+            this._currentSound.start(time, randomBetween(0, 0.01), undefined, 0.1 * randomBetween(0.5, 1));
+        }
+    }
+    /**
+     * Put the pedal down
+     */
+    down(time) {
+        this._squash(time);
+        this._downTime = time;
+        this._playSample(time, 'down');
+    }
+    /**
+     * Put the pedal up
+     */
+    up(time) {
+        this._squash(time);
+        this._downTime = Infinity;
+        this._playSample(time, 'up');
+    }
+    /**
+     * Indicates if the pedal is down at the given time
+     */
+    isDown(time) {
+        return time > this._downTime;
+    }
+}
+
+/**
+ * A single velocity of strings
+ */
+class PianoString extends ToneAudioNode {
+    constructor(options) {
+        super(options);
+        this.name = 'PianoString';
+        this._urls = {};
+        // create the urls
+        options.notes.forEach(note => this._urls[note] = getNotesUrl(note, options.velocity));
+        this.samples = options.samples;
+    }
+    load() {
+        return new Promise(onload => {
+            this._sampler = this.output = new Sampler({
+                attack: 0,
+                baseUrl: this.samples,
+                curve: 'exponential',
+                onload,
+                release: 0.4,
+                urls: this._urls,
+                volume: 3,
+            });
+        });
+    }
+    triggerAttack(note, time, velocity) {
+        this._sampler.triggerAttack(note, time, velocity);
+    }
+    triggerRelease(note, time) {
+        this._sampler.triggerRelease(note, time);
+    }
+}
+
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/**
+ *  Manages all of the hammered string sounds
+ */
+class PianoStrings extends PianoComponent {
+    constructor(options) {
+        super(options);
+        const notes = getNotesInRange(options.minNote, options.maxNote);
+        const velocities = velocitiesMap[options.velocities].slice();
+        this._strings = velocities.map(velocity => {
+            const string = new PianoString(Object.assign(options, {
+                notes, velocity,
+            }));
+            return string;
+        });
+        this._activeNotes = new Map();
+    }
+    /**
+     * Scale a value between a given range
+     */
+    scale(val, inMin, inMax, outMin, outMax) {
+        return ((val - inMin) / (inMax - inMin)) * (outMax - outMin) + outMin;
+    }
+    triggerAttack(note, time, velocity) {
+        const scaledVel = this.scale(velocity, 0, 1, -0.5, this._strings.length - 0.51);
+        const stringIndex = Math.max(Math.round(scaledVel), 0);
+        let gain = 1 + scaledVel - stringIndex;
+        if (this._strings.length === 1) {
+            gain = velocity;
+        }
+        const sampler = this._strings[stringIndex];
+        if (this._activeNotes.has(note)) {
+            this.triggerRelease(note, time);
+        }
+        this._activeNotes.set(note, sampler);
+        sampler.triggerAttack(Midi(note).toNote(), time, gain);
+    }
+    triggerRelease(note, time) {
+        // trigger the release of all of the notes at that velociy
+        if (this._activeNotes.has(note)) {
+            this._activeNotes.get(note).triggerRelease(Midi(note).toNote(), time);
+            this._activeNotes.delete(note);
+        }
+    }
+    _internalLoad() {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            yield Promise.all(this._strings.map((s) => __awaiter$1(this, void 0, void 0, function* () {
+                yield s.load();
+                s.connect(this.output);
+            })));
+        });
+    }
+}
+
+var __awaiter$2 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/**
+ *  The Piano
+ */
+class Piano extends ToneAudioNode {
+    constructor() {
+        super(optionsFromArguments(Piano.getDefaults(), arguments));
+        this.name = 'Piano';
+        this.input = undefined;
+        this.output = new Gain({ context: this.context });
+        /**
+         * The currently held notes
+         */
+        this._heldNotes = new Map();
+        /**
+         * If it's loaded or not
+         */
+        this._loaded = false;
+        const options = optionsFromArguments(Piano.getDefaults(), arguments);
+        // make sure it ends with a /
+        if (!options.url.endsWith('/')) {
+            options.url += '/';
+        }
+        this.maxPolyphony = options.maxPolyphony;
+        this._heldNotes = new Map();
+        this._sustainedNotes = new Map();
+        this._strings = new PianoStrings(Object.assign({}, options, {
+            enabled: true,
+            samples: options.url,
+            volume: options.volume.strings,
+        })).connect(this.output);
+        this.strings = this._strings.volume;
+        this._pedal = new Pedal(Object.assign({}, options, {
+            enabled: options.pedal,
+            samples: options.url,
+            volume: options.volume.pedal,
+        })).connect(this.output);
+        this.pedal = this._pedal.volume;
+        this._keybed = new Keybed(Object.assign({}, options, {
+            enabled: options.release,
+            samples: options.url,
+            volume: options.volume.keybed,
+        })).connect(this.output);
+        this.keybed = this._keybed.volume;
+        this._harmonics = new Harmonics(Object.assign({}, options, {
+            enabled: options.release,
+            samples: options.url,
+            volume: options.volume.harmonics,
+        })).connect(this.output);
+        this.harmonics = this._harmonics.volume;
+    }
+    static getDefaults() {
+        return Object.assign(ToneAudioNode.getDefaults(), {
+            maxNote: 108,
+            minNote: 21,
+            pedal: true,
+            release: false,
+            url: 'https://tambien.github.io/Piano/audio/',
+            velocities: 1,
+            maxPolyphony: 32,
+            volume: {
+                harmonics: 0,
+                keybed: 0,
+                pedal: 0,
+                strings: 0,
+            },
+        });
+    }
+    /**
+     *  Load all the samples
+     */
+    load() {
+        return __awaiter$2(this, void 0, void 0, function* () {
+            yield Promise.all([
+                this._strings.load(),
+                this._pedal.load(),
+                this._keybed.load(),
+                this._harmonics.load(),
+            ]);
+            this._loaded = true;
+        });
+    }
+    /**
+     * If all the samples are loaded or not
+     */
+    get loaded() {
+        return this._loaded;
+    }
+    /**
+     *  Put the pedal down at the given time. Causes subsequent
+     *  notes and currently held notes to sustain.
+     */
+    pedalDown({ time = this.immediate() } = {}) {
+        if (this.loaded) {
+            time = this.toSeconds(time);
+            if (!this._pedal.isDown(time)) {
+                this._pedal.down(time);
+            }
+        }
+        return this;
+    }
+    /**
+     *  Put the pedal up. Dampens sustained notes
+     */
+    pedalUp({ time = this.immediate() } = {}) {
+        if (this.loaded) {
+            const seconds = this.toSeconds(time);
+            if (this._pedal.isDown(seconds)) {
+                this._pedal.up(seconds);
+                // dampen each of the notes
+                this._sustainedNotes.forEach((t, note) => {
+                    if (!this._heldNotes.has(note)) {
+                        this._strings.triggerRelease(note, seconds);
+                    }
+                });
+                this._sustainedNotes.clear();
+            }
+        }
+        return this;
+    }
+    /**
+     *  Play a note.
+     *  @param note	  The note to play. If it is a number, it is assumed to be MIDI
+     *  @param velocity  The velocity to play the note
+     *  @param time	  The time of the event
+     */
+    keyDown({ note, midi, time = this.immediate(), velocity = 0.8 }) {
+        if (this.loaded && this.maxPolyphony > this._heldNotes.size + this._sustainedNotes.size) {
+            time = this.toSeconds(time);
+            if (isString(note)) {
+                midi = Math.round(Midi(note).toMidi());
+            }
+            if (!this._heldNotes.has(midi)) {
+                // record the start time and velocity
+                this._heldNotes.set(midi, { time, velocity });
+                this._strings.triggerAttack(midi, time, velocity);
+            }
+        }
+        else {
+            console.warn('samples not loaded');
+        }
+        return this;
+    }
+    /**
+     *  Release a held note.
+     */
+    keyUp({ note, midi, time = this.immediate(), velocity = 0.8 }) {
+        if (this.loaded) {
+            time = this.toSeconds(time);
+            if (isString(note)) {
+                midi = Math.round(Midi(note).toMidi());
+            }
+            if (this._heldNotes.has(midi)) {
+                const prevNote = this._heldNotes.get(midi);
+                this._heldNotes.delete(midi);
+                // compute the release velocity
+                const holdTime = Math.pow(Math.max(time - prevNote.time, 0.1), 0.7);
+                const prevVel = prevNote.velocity;
+                let dampenGain = (3 / holdTime) * prevVel * velocity;
+                dampenGain = Math.max(dampenGain, 0.4);
+                dampenGain = Math.min(dampenGain, 4);
+                if (this._pedal.isDown(time)) {
+                    if (!this._sustainedNotes.has(midi)) {
+                        this._sustainedNotes.set(midi, time);
+                    }
+                }
+                else {
+                    // release the string sound
+                    this._strings.triggerRelease(midi, time);
+                    // trigger the harmonics sound
+                    this._harmonics.triggerAttack(midi, time, dampenGain);
+                }
+                // trigger the keybed release sound
+                this._keybed.start(midi, time, velocity);
+            }
+        }
+        return this;
+    }
+    stopAll() {
+        this.pedalUp();
+        this._heldNotes.forEach((_, midi) => {
+            this.keyUp({ midi });
+        });
+        return this;
+    }
+}
+
+var __awaiter$3 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+
+export { Piano };

docs/_snowpack/pkg/import-map.json

@@ -1,6 +1,7 @@
 {
   "imports": {
     "@tonaljs/tonal": "./@tonaljs/tonal.js",
+    "@tonejs/piano": "./@tonejs/piano.js",
     "chord-voicings": "./chord-voicings.js",
     "codemirror/lib/codemirror.css": "./codemirror/lib/codemirror.css",
     "codemirror/mode/javascript/javascript.js": "./codemirror/mode/javascript/javascript.js",