linked-rolls 0.0.1 → 0.1.0

package/lib/Emulation.js

@@ -1,365 +1,128 @@
 import { MIDIControlEvents } from "midifile-ts";
-import { KinematicConversion } from "./PlaceTimeConversion";
-import { getSnapshot } from "./Version";
-import { dimensionOf } from "./Symbol";
-function resize(arr, newSize, defaultValue) {
-    while (newSize > arr.length)
-        arr.push(defaultValue);
-}
-const simplifySymbol = (symbol) => {
-    if (!symbol.carriers || !symbol.carriers.length)
-        return null;
-    const mean = dimensionOf(symbol);
-    return {
-        ...symbol,
-        ...mean
-    };
+import { valueOf } from "./Assumption";
+/** The punch diameter the edition's copies report, where any of them does. */
+const punchDiameterOf = (view) => {
+    const measured = view.edition.copies
+        .map(copy => copy.measurements.punchDiameter?.value)
+        .filter((value) => value !== undefined && value > 0);
+    if (measured.length === 0)
+        return undefined;
+    return measured.reduce((sum, value) => sum + value, 0) / measured.length;
 };
+const propertiesOf = (view) => ({
+    punchDiameter: punchDiameterOf(view),
+    tempo: view.edition.tempoAdjustment
+});
+/**
+ * A version of the edition, performed: the symbols are negotiated into
+ * placed events, the reproducing system plays them, and the result goes
+ * out as MIDI in which every note and pedal step is labelled with the
+ * symbol it performs.
+ */
 export class Emulation {
-    constructor(options = {
-        welte_p: 35,
-        welte_f: 90,
-        welte_mf: 60,
-        welte_loud: 75,
-        trackerBarDiameter: 1.413,
-        punchExtensionFraction: 0.75,
-        slow_decay_rate: 2380,
-        fastC_decay_rate: 300,
-        fastD_decay_rate: 400,
-        division: 54
-    }) {
-        Object.defineProperty(this, "placeTimeConversion", {
+    constructor(system, options = system.defaultOptions) {
+        Object.defineProperty(this, "system", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new KinematicConversion()
+            value: void 0
         });
-        Object.defineProperty(this, "midiEvents", {
+        Object.defineProperty(this, "options", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: void 0
         });
-        // sorted list of events with the negotiated assumptions already applied
-        Object.defineProperty(this, "negotiatedEvents", {
+        Object.defineProperty(this, "midiEvents", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: []
         });
-        // stores a velocity for every millisecond
-        Object.defineProperty(this, "trebleVelocities", {
+        // sorted list of events with the negotiated assumptions already applied
+        Object.defineProperty(this, "negotiatedEvents", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "bassVelocities", {
+        Object.defineProperty(this, "curves", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "startTempo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "endTempo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         Object.defineProperty(this, "source", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        options.slow_step = (options.welte_mf - options.welte_p) / options.slow_decay_rate;
-        options.fastC_step = (options.welte_mf - options.welte_p) / options.fastC_decay_rate;
-        options.fastD_step = -(options.welte_f - options.welte_p) / options.fastD_decay_rate;
+        this.system = system;
         this.options = options;
     }
-    findRollTempo(tempo) {
-        if (!tempo) {
-            this.startTempo = 104.331;
-            this.endTempo = 104.331;
-            return;
-        }
-        this.startTempo = tempo.startsWith;
-        this.endTempo = tempo.endsWith;
-    }
-    assignPhysicalTime(skipToFirstNote = false) {
-        if (this.negotiatedEvents.length === 0)
-            return;
-        const first = skipToFirstNote ? this.negotiatedEvents[0].horizontal.from : 0;
-        for (const event of this.negotiatedEvents) {
-            if (!event.assumedPhysicalTime) {
-                // convert from mm to cm and then to time
-                event.assumedPhysicalTime = [
-                    this.placeTimeConversion.placeToTime((event.horizontal.from - first) / 10),
-                    this.placeTimeConversion.placeToTime((event.horizontal.to - first) / 10)
-                ];
-            }
-        }
-    }
-    applyTrackerBarExtension() {
-        const correction = this.options.trackerBarDiameter * this.options.punchExtensionFraction + 0.5;
-        for (const event of this.negotiatedEvents) {
-            if (event.horizontal.to) {
-                event.horizontal.to += correction;
-            }
-        }
-    }
-    convertEventsToMIDI() {
-        for (const event of this.negotiatedEvents) {
-            if (event.type === 'expression') {
-                const expression = event;
-                const map = new Map([
-                    ['SustainPedalOn', 'sustainPedalOn'],
-                    ['SustainPedalOff', 'sustainPedalOff'],
-                    ['SoftPedalOn', 'softPedalOn'],
-                    ['SoftPedalOff', 'softPedalOff']
-                ]);
-                if (map.has(expression.expressionType)) {
-                    this.midiEvents.push({
-                        type: map.get(expression.expressionType),
-                        performs: event,
-                        at: event.assumedPhysicalTime[0],
-                    });
-                }
-            }
-            else if (event.type === 'note') {
-                const note = event;
-                // take velocity from the calculated velocity list
-                const pitch = note.pitch;
-                if (event.vertical.from >= this.options.division) {
-                    this.insertNote(event, pitch, this.trebleVelocities[+(event.assumedPhysicalTime[0] * 1000).toFixed()]);
-                }
-                else {
-                    this.insertNote(event, pitch, this.bassVelocities[+(event.assumedPhysicalTime[0] * 1000).toFixed()]);
-                }
-            }
-        }
-        this.midiEvents.sort((a, b) => a.at - b.at);
-    }
-    emulateFromRoll(events) {
-        this.startTempo = 104.331;
-        this.endTempo = 104.331;
-        this.negotiatedEvents = events
-            .map(simplifySymbol)
-            .filter(s => s !== null);
-        this.applyTrackerBarExtension();
-        this.assignPhysicalTime();
-        this.applyTrackerBarExtension();
-        this.calculateVelocities('treble');
-        this.calculateVelocities('bass');
-        this.convertEventsToMIDI();
-        return this.midiEvents;
+    applyConstraints() {
+        this.negotiatedEvents
+            .filter((e) => e.alignedWith !== undefined)
+            .forEach(e => {
+            const ref = this.negotiatedEvents.find(ev => ev.id === valueOf(e.alignedWith));
+            if (!ref)
+                return;
+            const distance = ref.horizontal.from - e.horizontal.from;
+            e.horizontal.from += distance;
+            e.horizontal.to += distance;
+        });
     }
-    emulateVersion(version, rollTempo, skipToFirstNote = false) {
+    emulateVersion(version, view, { range, skipToFirstNote = false } = {}) {
         this.source = version.id;
         this.negotiatedEvents =
-            getSnapshot(version)
+            view.snapshot(version.id)
                 .filter(s => s.type === 'note' || s.type === 'expression')
-                .map(simplifySymbol)
-                .filter(s => s !== null);
-        this.findRollTempo(rollTempo);
-        this.applyTrackerBarExtension();
-        this.assignPhysicalTime(skipToFirstNote);
-        this.calculateVelocities('treble');
-        this.calculateVelocities('bass');
-        this.convertEventsToMIDI();
-        return this.midiEvents;
-    }
-    /**
-     * The original code of the calculateVelocities() method,
-     * written by Kitty Shi and Craig Stuart Sapp,
-     * was taken from the midi2exp project (https://github.com/pianoroll/midi2exp)
-     * and adapted to the different data representation.
-     */
-    calculateVelocities(scope) {
-        if (!this.negotiatedEvents.length)
-            return;
-        const velocities = scope === 'treble' ? this.trebleVelocities : this.bassVelocities;
-        const isMF = []; // is MF hook on?
-        const isSlowC = []; // is slow crescendo on?
-        const isFastC = []; // is fast crescendo on?
-        const isFastD = []; // is fast decrescendo on?
-        let lastOnsetMs = this.negotiatedEvents[this.negotiatedEvents.length - 1].assumedPhysicalTime[0];
-        if (!lastOnsetMs) {
-            console.log('Failed calculating the last onset.');
-            return;
-        }
-        lastOnsetMs *= 1000;
-        // set all of the times to piano by default
-        resize(velocities, lastOnsetMs, this.options.welte_p);
-        // fill all hook maps with false
-        for (const target of [isMF, isSlowC, isFastC, isFastD]) {
-            resize(target, lastOnsetMs, false);
-        }
-        // Lock and Cancel
-        let valve_mf_on = false;
-        let valve_slowc_on = false;
-        let valve_mf_starttime = 0; // 0 for off
-        let valve_slowc_starttime = 0;
-        // First pass: For each time section calculate the current boolean
-        // state of each expression.
-        for (const negotiatedEvent of this.negotiatedEvents) {
-            if (negotiatedEvent.type !== 'expression')
-                continue;
-            if (scope === 'treble' && negotiatedEvent.vertical.from < this.options.division)
-                continue;
-            else if (scope === 'bass' && negotiatedEvent.vertical.from >= this.options.division)
-                continue;
-            const event = negotiatedEvent;
-            const startMs = event.assumedPhysicalTime[0] * 1000;
-            const endMs = event.assumedPhysicalTime[1] * 1000;
-            // console.log('encoutering expression', event.expressionType["@id"], 'from', startMs, 'to', endMs)
-            if (event.expressionType === 'MezzoforteOn') {
-                // update the mezzoforte start time
-                // only if the mf valve is not on already
-                if (!valve_mf_on) {
-                    valve_mf_on = true;
-                    valve_mf_starttime = startMs;
+                .filter(s => {
+                if (range && s.type === 'note') {
+                    const dimensions = view.dimensionOf(s);
+                    if (!dimensions)
+                        return true; // in case of doubt, include the note
+                    // check if the note onset is within the specified range
+                    const onset = dimensions.horizontal.from;
+                    return onset > range[0] && onset < range[1];
                 }
-            }
-            else if (event.expressionType === 'MezzoforteOff') {
-                if (valve_mf_on) {
-                    // fill from the mezzoforte start time to here ...
-                    isMF.fill(true, valve_mf_starttime, startMs);
-                }
-                valve_mf_on = false;
-            }
-            else if (event.expressionType === 'SlowCrescendoOn') {
-                // update the slow crescendo start time
-                // only if slow crescendo is not on already
-                if (!valve_slowc_on) {
-                    valve_slowc_on = true;
-                    valve_slowc_starttime = startMs;
-                }
-            }
-            else if (event.expressionType === 'SlowCrescendoOff') {
-                if (valve_slowc_on) {
-                    // fill from the mezzoforte start time to here ...
-                    isSlowC.fill(true, valve_slowc_starttime, startMs);
-                }
-                valve_slowc_on = false;
-            }
-            else if (event.expressionType === 'ForzandoOn') {
-                // Forzando On/Off are a direct operations (length of perforation matters)
-                isFastC.fill(true, startMs, endMs);
-            }
-            else if (event.expressionType === 'ForzandoOff') {
-                // Forzando On/Off are a direct operations (length of perforation matters)
-                isFastD.fill(true, startMs, endMs);
-            }
-        }
-        // TODO: deal with the last case (if crescendo OFF is missing)
-        // Second pass, update the current velocity according to the previous one
-        let amount = 0.0;
-        let eps = 0.0001;
-        for (let i = 1; i < lastOnsetMs; i++) {
-            if (!isSlowC[i] && !isFastC[i] && !isFastD[i]) {
-                // slow decrescendo is always on
-                amount = -this.options.slow_step;
-            }
-            else {
-                amount =
-                    (isSlowC[i] ? this.options.slow_step : 0) +
-                        (isFastC[i] ? this.options.fastC_step : 0) +
-                        (isFastD[i] ? this.options.fastD_step : 0);
-            }
-            velocities[i] = velocities[i - 1] + amount;
-            if (isMF[i]) {
-                if (velocities[i - 1] > this.options.welte_mf) {
-                    if (amount < 0) {
-                        velocities[i] = Math.max(this.options.welte_mf + eps, velocities[i]);
-                    }
-                    else {
-                        velocities[i] = Math.min(this.options.welte_f, velocities[i]);
-                    }
-                }
-                else if (velocities[i - 1] < this.options.welte_mf) {
-                    if (amount > 0) {
-                        velocities[i] = Math.min(this.options.welte_mf - eps, velocities[i]);
-                    }
-                    else {
-                        velocities[i] = Math.max(this.options.welte_p, velocities[i]);
-                    }
-                }
-            }
-            else {
-                // slow crescendo will only reach welte_loud
-                if (isSlowC[i] && !isFastC[i] && velocities[i - 1] < this.options.welte_loud) {
-                    velocities[i] = Math.min(velocities[i], this.options.welte_loud - eps);
-                }
-            }
-            // regulating max and min
-            velocities[i] = Math.max(this.options.welte_p, velocities[i]);
-            velocities[i] = Math.min(this.options.welte_f, velocities[i]);
+                return true;
+            })
+                .map((e) => view.simplifySymbol(e))
+                .filter(s => s !== null);
+        if (this.negotiatedEvents.length === 0) {
+            this.midiEvents = [];
+            this.curves = [];
+            return this.midiEvents;
         }
-    }
-    insertNote(event, pitch, velocity) {
-        this.midiEvents.push({
-            type: 'noteOn',
-            performs: event,
-            velocity,
-            at: event.assumedPhysicalTime[0],
-            pitch
-        });
-        this.midiEvents.push({
-            type: 'noteOff',
-            performs: event,
-            velocity: 127,
-            at: event.assumedPhysicalTime[1],
-            pitch
-        });
+        this.applyConstraints();
+        const performance = this.system.perform(this.negotiatedEvents, this.options, propertiesOf(view));
+        this.curves = performance.curves;
+        const onsets = performance.events.filter(event => event.type === 'noteOn').map(event => event.at);
+        const origin = skipToFirstNote && onsets.length > 0 ? Math.min(...onsets) : 0;
+        this.midiEvents = performance.events
+            .map(event => ({ ...event, at: event.at - origin }))
+            .filter(event => event.at >= 0)
+            .sort((a, b) => a.at - b.at);
+        return this.midiEvents;
     }
     findEventsPerforming(id) {
         return this.midiEvents.filter(event => event.performs.id === id);
     }
     asMIDI() {
+        const TICKS_PER_SECOND = 1000;
         const events = [];
         this.midiEvents.sort((a, b) => a.at - b.at);
-        let currentTime = 0;
-        // insert metadata first
-        events.push({
-            type: 'meta',
-            subtype: 'text',
-            text: 'linked-rolls (based on midi2exp)',
-            deltaTime: 0
-        });
+        const text = (text, deltaTime = 0) => ({ type: 'meta', subtype: 'text', text, deltaTime });
+        const controller = (controllerType, value, deltaTime = 0) => ({ type: 'channel', subtype: 'controller', controllerType, value, deltaTime, channel: 0 });
+        const controllerOf = (event) => event.type === 'damper' ? MIDIControlEvents.SUSTAIN : MIDIControlEvents.SOFT_PEDAL;
+        events.push(text(`linked-rolls (${this.system.name})`));
         if (this.source) {
-            events.push({
-                type: 'meta',
-                subtype: 'text',
-                text: this.source,
-                deltaTime: 0
-            });
+            events.push(text(this.source));
         }
-        events.push({
-            type: 'meta',
-            subtype: 'text',
-            text: `place-time-conversion: ${this.placeTimeConversion.summary}`,
-            deltaTime: 0
-        });
         for (const [key, value] of Object.entries(this.options)) {
-            events.push({
-                type: 'meta',
-                subtype: 'text',
-                text: `${key}=${value}`,
-                deltaTime: 0
-            });
+            events.push(text(`${key}=${typeof value === 'object' ? JSON.stringify(value) : value}`));
         }
         events.push({
             type: 'meta',
@@ -367,16 +130,18 @@ export class Emulation {
             microsecondsPerBeat: 1000000,
             deltaTime: 0
         });
+        // both pedals start at rest
+        events.push(controller(MIDIControlEvents.SUSTAIN, 0), controller(MIDIControlEvents.SOFT_PEDAL, 0));
+        // a pedal step is labelled with its perforation only where that
+        // perforation changes, so the file is not swamped with labels
+        const lastCause = {};
+        let currentTick = 0;
         for (const event of this.midiEvents) {
-            const deltaTimeMs = (event.at - currentTime) * 1000;
+            const tick = Math.round(event.at * TICKS_PER_SECOND);
+            const deltaTime = tick - currentTick;
+            currentTick = tick;
             if (event.type === 'noteOn') {
-                console.log('dealing with note on', event.pitch, event.at, deltaTimeMs);
-                events.push({
-                    type: 'meta',
-                    subtype: 'text',
-                    deltaTime: deltaTimeMs,
-                    text: event.performs.id
-                });
+                events.push(text(event.performs.id, deltaTime));
                 events.push({
                     type: 'channel',
                     subtype: 'noteOn',
@@ -392,79 +157,22 @@ export class Emulation {
                     subtype: 'noteOff',
                     noteNumber: event.pitch,
                     velocity: 127,
-                    deltaTime: deltaTimeMs,
+                    deltaTime,
                     channel: 0
                 });
             }
-            else if (event.type === 'sustainPedalOn') {
-                events.push({
-                    type: 'meta',
-                    subtype: 'text',
-                    deltaTime: deltaTimeMs,
-                    text: event.performs.id
-                });
-                events.push({
-                    type: 'channel',
-                    subtype: 'controller',
-                    controllerType: MIDIControlEvents.SUSTAIN,
-                    deltaTime: 0,
-                    channel: 0,
-                    value: 127
-                });
-            }
-            else if (event.type === 'sustainPedalOff') {
-                events.push({
-                    type: 'meta',
-                    subtype: 'text',
-                    deltaTime: deltaTimeMs,
-                    text: event.performs.id
-                });
-                events.push({
-                    type: 'channel',
-                    subtype: 'controller',
-                    controllerType: MIDIControlEvents.SUSTAIN,
-                    deltaTime: 0,
-                    channel: 0,
-                    value: 0
-                });
-            }
-            else if (event.type === 'softPedalOn') {
-                events.push({
-                    type: 'meta',
-                    subtype: 'text',
-                    deltaTime: deltaTimeMs,
-                    text: event.performs.id
-                });
-                events.push({
-                    type: 'channel',
-                    subtype: 'controller',
-                    controllerType: MIDIControlEvents.SOFT_PEDAL,
-                    deltaTime: 0,
-                    channel: 0,
-                    value: 127
-                });
-            }
-            else if (event.type === 'softPedalOff') {
-                events.push({
-                    type: 'meta',
-                    subtype: 'text',
-                    deltaTime: deltaTimeMs,
-                    text: event.performs.id
-                });
-                events.push({
-                    type: 'channel',
-                    subtype: 'controller',
-                    controllerType: MIDIControlEvents.SOFT_PEDAL,
-                    deltaTime: 0,
-                    channel: 0,
-                    value: 0
-                });
+            else {
+                const labelled = lastCause[event.type] === event.performs.id;
+                lastCause[event.type] = event.performs.id;
+                if (!labelled) {
+                    events.push(text(event.performs.id, deltaTime));
+                }
+                events.push(controller(controllerOf(event), event.value, labelled ? deltaTime : 0));
             }
-            currentTime = event.at;
         }
         return {
             header: {
-                ticksPerBeat: 1000,
+                ticksPerBeat: TICKS_PER_SECOND,
                 formatType: 0,
                 trackCount: 1
             },