tone 14.8.35 → 14.8.36

package/Tone/core/clock/TickSource.test.ts

@@ -237,6 +237,35 @@ describe("TickSource", () => {
 			expect(source.getTicksAtTime(6)).to.be.closeTo(6, 0.01);
 			source.dispose();
 		});
+
+		it("will recompute memoized values when events are modified", () => {
+			const source = new TickSource(1);
+			source.start(3).pause(4);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(1, 0.01);
+			source.start(1).pause(2);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(2, 0.01);
+			source.setTicksAtTime(3, 1);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(5, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(5, 0.01);
+			source.cancel(4);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(5, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(6, 0.01);
+			source.dispose();
+		});
 	});
 
 	context("forEachTickBetween", () => {
@@ -591,6 +620,29 @@ describe("TickSource", () => {
 			expect(source.getSecondsAtTime(1.5)).to.be.closeTo(0, 0.01);
 			source.dispose();
 		});
+
+		it("will recompute memoized values when events are modified", () => {
+			const source = new TickSource(1);
+			source.start(3).pause(4);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(4)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(1, 0.01);
+			source.start(1).pause(2);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(4)).to.be.closeTo(2, 0.01);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(2, 0.01);
+			source.cancel(4);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(1, 0.01);
+			expect(source.getSecondsAtTime(4)).to.be.closeTo(2, 0.01);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(3, 0.01);
+			source.dispose();
+		});
 	});
 
 	context("Frequency", () => {

package/Tone/core/clock/TickSource.ts

@@ -3,7 +3,7 @@ import { Seconds, Ticks, Time } from "../type/Units";
 import { optionsFromArguments } from "../util/Defaults";
 import { readOnly } from "../util/Interface";
 import { PlaybackState, StateTimeline, StateTimelineEvent } from "../util/StateTimeline";
-import { Timeline } from "../util/Timeline";
+import { Timeline, TimelineEvent } from "../util/Timeline";
 import { isDefined } from "../util/TypeCheck";
 import { TickSignal } from "./TickSignal";
 import { EQ } from "../util/Math";
@@ -13,12 +13,24 @@ interface TickSourceOptions extends ToneWithContextOptions {
 	units: "bpm" | "hertz";
 }
 
-interface TickSourceOffsetEvent {
+interface TickSourceOffsetEvent extends TimelineEvent {
 	ticks: number;
 	time: number;
 	seconds: number;
 }
 
+interface TickSourceTicksAtTimeEvent extends TimelineEvent {
+	state: PlaybackState;
+	time: number;
+	ticks: number;
+}
+
+interface TickSourceSecondsAtTimeEvent extends TimelineEvent {
+	state: PlaybackState;
+	time: number;
+	seconds: number;
+}
+
 /**
  * Uses [TickSignal](TickSignal) to track elapsed ticks with complex automation curves.
  */
@@ -41,6 +53,16 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 	 */
 	private _tickOffset: Timeline<TickSourceOffsetEvent> = new Timeline();
 
+	/**
+	 * Memoized values of getTicksAtTime at events with state other than "started"
+	 */
+	private _ticksAtTime: Timeline<TickSourceTicksAtTimeEvent> = new Timeline<TickSourceTicksAtTimeEvent>();
+
+	/**
+	 * Memoized values of getSecondsAtTime at events with state other than "started"
+	 */
+	private _secondsAtTime: Timeline<TickSourceSecondsAtTimeEvent> = new Timeline<TickSourceSecondsAtTimeEvent>();
+
 	/**
 	 * @param frequency The initial frequency that the signal ticks at
 	 */
@@ -90,6 +112,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			if (isDefined(offset)) {
 				this.setTicksAtTime(offset, computedTime);
 			}
+			this._ticksAtTime.cancel(computedTime);
+			this._secondsAtTime.cancel(computedTime);
 		}
 		return this;
 	}
@@ -111,6 +135,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		this._state.cancel(computedTime);
 		this._state.setStateAtTime("stopped", computedTime);
 		this.setTicksAtTime(0, computedTime);
+		this._ticksAtTime.cancel(computedTime);
+		this._secondsAtTime.cancel(computedTime);
 		return this;
 	}
 
@@ -122,6 +148,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		const computedTime = this.toSeconds(time);
 		if (this._state.getValueAtTime(computedTime) === "started") {
 			this._state.setStateAtTime("paused", computedTime);
+			this._ticksAtTime.cancel(computedTime);
+			this._secondsAtTime.cancel(computedTime);
 		}
 		return this;
 	}
@@ -134,6 +162,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		time = this.toSeconds(time);
 		this._state.cancel(time);
 		this._tickOffset.cancel(time);
+		this._ticksAtTime.cancel(time);
+		this._secondsAtTime.cancel(time);
 		return this;
 	}
 
@@ -145,16 +175,21 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 	getTicksAtTime(time?: Time): Ticks {
 		const computedTime = this.toSeconds(time);
 		const stopEvent = this._state.getLastState("stopped", computedTime) as StateTimelineEvent;
+
+		// get previously memoized ticks if available
+		const memoizedEvent = this._ticksAtTime.get(computedTime);
+
 		// this event allows forEachBetween to iterate until the current time
 		const tmpEvent: StateTimelineEvent = { state: "paused", time: computedTime };
 		this._state.add(tmpEvent);
 
 		// keep track of the previous offset event
-		let lastState = stopEvent;
-		let elapsedTicks = 0;
+		let lastState = memoizedEvent ? memoizedEvent : stopEvent;
+		let elapsedTicks = memoizedEvent ? memoizedEvent.ticks : 0;
+		let eventToMemoize : TickSourceTicksAtTimeEvent | null = null;
 
 		// iterate through all the events since the last stop
-		this._state.forEachBetween(stopEvent.time, computedTime + this.sampleTime, e => {
+		this._state.forEachBetween(lastState.time, computedTime + this.sampleTime, e => {
 			let periodStartTime = lastState.time;
 			// if there is an offset event in this period use that
 			const offsetEvent = this._tickOffset.get(e.time);
@@ -164,6 +199,10 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			}
 			if (lastState.state === "started" && e.state !== "started") {
 				elapsedTicks += this.frequency.getTicksAtTime(e.time) - this.frequency.getTicksAtTime(periodStartTime);
+				// do not memoize the temporary event
+				if (e.time != tmpEvent.time) {
+					eventToMemoize = { state: e.state, time: e.time, ticks: elapsedTicks };
+				}
 			}
 			lastState = e;
 		});
@@ -171,6 +210,11 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		// remove the temporary event
 		this._state.remove(tmpEvent);
 
+		// memoize the ticks at the most recent event with state other than "started"
+		if (eventToMemoize) {
+			this._ticksAtTime.add(eventToMemoize);
+		}
+
 		// return the ticks
 		return elapsedTicks;
 	}
@@ -211,12 +255,16 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		const tmpEvent: StateTimelineEvent = { state: "paused", time };
 		this._state.add(tmpEvent);
 
+		// get previously memoized seconds if available
+		const memoizedEvent = this._secondsAtTime.get(time);
+
 		// keep track of the previous offset event
-		let lastState = stopEvent;
-		let elapsedSeconds = 0;
+		let lastState = memoizedEvent ? memoizedEvent : stopEvent;
+		let elapsedSeconds = memoizedEvent ? memoizedEvent.seconds : 0;
+		let eventToMemoize : TickSourceSecondsAtTimeEvent | null = null;
 
 		// iterate through all the events since the last stop
-		this._state.forEachBetween(stopEvent.time, time + this.sampleTime, e => {
+		this._state.forEachBetween(lastState.time, time + this.sampleTime, e => {
 			let periodStartTime = lastState.time;
 			// if there is an offset event in this period use that
 			const offsetEvent = this._tickOffset.get(e.time);
@@ -226,6 +274,10 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			}
 			if (lastState.state === "started" && e.state !== "started") {
 				elapsedSeconds += e.time - periodStartTime;
+				// do not memoize the temporary event
+				if (e.time != tmpEvent.time) {
+					eventToMemoize = { state: e.state, time: e.time, seconds: elapsedSeconds };
+				}
 			}
 			lastState = e;
 		});
@@ -233,7 +285,12 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		// remove the temporary event
 		this._state.remove(tmpEvent);
 
-		// return the ticks
+		// memoize the seconds at the most recent event with state other than "started"
+		if (eventToMemoize) {
+			this._secondsAtTime.add(eventToMemoize);
+		}
+
+		// return the seconds
 		return elapsedSeconds;
 	}
 
@@ -250,6 +307,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 			ticks,
 			time,
 		});
+		this._ticksAtTime.cancel(time);
+		this._secondsAtTime.cancel(time);
 		return this;
 	}
 
@@ -332,6 +391,8 @@ export class TickSource<TypeName extends "bpm" | "hertz"> extends ToneWithContex
 		super.dispose();
 		this._state.dispose();
 		this._tickOffset.dispose();
+		this._ticksAtTime.dispose();
+		this._secondsAtTime.dispose();
 		this.frequency.dispose();
 		return this;
 	}

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "14.8.35";
+export const version: string = "14.8.36";