tone 15.5.59 → 15.5.61

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

@@ -428,6 +428,38 @@ describe("Clock", () => {
 				["start", restartTime],
 			]);
 		});
+
+		it("invokes pending ticks and state events in time order", async () => {
+			const events: Array<[string, number]> = [];
+			let pauseTime = 0;
+			await Offline(() => {
+				const clock = new Clock((time, ticks) => {
+					events.push(["tick " + ticks, time]);
+				}, 200);
+				clock.on("pause", (time) => events.push(["pause", time]));
+				clock.on("start", (time) => events.push(["start", time]));
+				clock.start(0);
+				// ticks 0-4 (every 0.005s) and the pause are all pending in
+				// the same clock update; the ticks before the pause must be
+				// invoked before the pause event, not after it
+				return atTime(
+					0.022,
+					holdClock(clock, (time) => {
+						pauseTime = time;
+						clock.pause(time);
+					})
+				);
+			}, 0.03);
+			expect(events).to.deep.equal([
+				["start", 0],
+				["tick 0", 0],
+				["tick 1", 0.005],
+				["tick 2", 0.01],
+				["tick 3", 0.015],
+				["tick 4", 0.02],
+				["pause", pauseTime],
+			]);
+		});
 	});
 
 	context("Events", () => {

package/Tone/core/clock/Clock.ts

@@ -7,7 +7,12 @@ import { assertContextRunning } from "../util/Debug.js";
 import { optionsFromArguments } from "../util/Defaults.js";
 import { Emitter } from "../util/Emitter.js";
 import { noOp, readOnly } from "../util/Interface.js";
-import { PlaybackState, StateTimeline } from "../util/StateTimeline.js";
+import { GT } from "../util/Math.js";
+import {
+	PlaybackState,
+	StateTimeline,
+	StateTimelineEvent,
+} from "../util/StateTimeline.js";
 import { TickSignal } from "./TickSignal.js";
 import { TickSource } from "./TickSource.js";
 
@@ -290,39 +295,62 @@ export class Clock<TypeName extends "bpm" | "hertz" = "hertz">
 
 	/**
 	 * Invoke the state-transition events (start/stop/pause) and tick
-	 * callbacks scheduled between startTime and endTime, and advance
-	 * _lastUpdate to endTime.
+	 * callbacks scheduled between startTime and endTime in time order,
+	 * and advance _lastUpdate to endTime.
 	 * @param startTime The beginning of the range to process.
 	 * @param endTime The end of the range to process.
 	 */
 	private _processRange(startTime: number, endTime: number): void {
 		this._lastUpdate = endTime;
 		if (startTime !== endTime) {
-			// the state change events
+			// the state change events, interleaved with the tick callbacks
+			// so that e.g. a tick just before a pause is delivered before
+			// the pause event, not after it
+			const stateEvents: StateTimelineEvent[] = [];
 			this._state.forEachBetween(startTime, endTime, (e) => {
-				switch (e.state) {
-					case "started":
-						const offset = this._tickSource.getTicksAtTime(e.time);
-						this.emit("start", e.time, offset);
-						break;
-					case "stopped":
-						if (e.time !== 0) {
-							this.emit("stop", e.time);
-						}
-						break;
-					case "paused":
-						this.emit("pause", e.time);
-						break;
-				}
+				stateEvents.push(e);
 			});
-			// the tick callbacks
+			let nextStateEvent = 0;
+			const emitStateEventsUpTo = (time: Seconds) => {
+				// a callback may have disposed the clock
+				while (
+					!this.disposed &&
+					nextStateEvent < stateEvents.length &&
+					!GT(stateEvents[nextStateEvent].time, time)
+				) {
+					this._emitStateEvent(stateEvents[nextStateEvent]);
+					nextStateEvent++;
+				}
+			};
 			this._tickSource.forEachTickBetween(
 				startTime,
 				endTime,
 				(time, ticks) => {
+					emitStateEventsUpTo(time);
 					this.callback(time, ticks);
 				}
 			);
+			emitStateEventsUpTo(endTime);
+		}
+	}
+
+	/**
+	 * Emit the event corresponding to a state change
+	 */
+	private _emitStateEvent(event: StateTimelineEvent): void {
+		switch (event.state) {
+			case "started":
+				const offset = this._tickSource.getTicksAtTime(event.time);
+				this.emit("start", event.time, offset);
+				break;
+			case "stopped":
+				if (event.time !== 0) {
+					this.emit("stop", event.time);
+				}
+				break;
+			case "paused":
+				this.emit("pause", event.time);
+				break;
 		}
 	}
 

package/Tone/source/Source.test.ts

@@ -3,6 +3,7 @@ import { expect } from "chai";
 import { atTime, holdClock, Offline } from "../../test/helper/Offline.js";
 import { ToneAudioBuffer } from "../core/context/ToneAudioBuffer.js";
 import { getContext } from "../core/Global.js";
+import { noOp } from "../core/util/Interface.js";
 import { Player } from "./buffer/Player.js";
 import { Oscillator } from "./oscillator/Oscillator.js";
 
@@ -351,6 +352,55 @@ describe("Source", () => {
 			expect(output.getValueAtTime(0.4)).to.be.closeTo(0.7, 0.01);
 		});
 
+		it("stops a source whose start was pending in the same clock update as a pause (#1289)", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0.5);
+				transport.start(0);
+				// the clip's start tick at 0.5 and the pause at ~0.52 are
+				// processed in the same clock update
+				return atTime(
+					0.52,
+					holdClock(transport, (time) => {
+						transport.pause(time);
+					})
+				);
+			}, 1);
+			expect(output.getValueAtTime(0.7)).to.equal(0);
+			expect(output.getValueAtTime(0.9)).to.equal(0);
+		});
+
+		it("stops a source whose start was pending in the same clock update as a stop (#1289)", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0.5);
+				transport.start(0);
+				return atTime(
+					0.52,
+					holdClock(transport, (time) => {
+						transport.stop(time);
+					})
+				);
+			}, 1);
+			expect(output.getValueAtTime(0.7)).to.equal(0);
+			expect(output.getValueAtTime(0.9)).to.equal(0);
+		});
+
+		it("stops a source whose start was pending in the same clock update as a stop scheduled ahead of time", async () => {
+			const output = await Offline(({ transport }) => {
+				const source = new Player(rampBuffer).toDestination();
+				source.sync().start(0.5);
+				transport.start(0);
+				// stop scheduled in advance; the start tick at 0.5 and the
+				// stop at 0.52 are both pending when the clock catches up
+				transport.stop(0.52);
+				return atTime(0.55, holdClock(transport, noOp));
+			}, 1);
+			expect(output.getValueAtTime(0.51)).to.be.closeTo(0.01, 0.005);
+			expect(output.getValueAtTime(0.7)).to.equal(0);
+			expect(output.getValueAtTime(0.9)).to.equal(0);
+		});
+
 		it("gives the correct offset on time on start/stop events when started with an offset", async () => {
 			const output = await Offline(({ transport }) => {
 				const source = new Player(rampBuffer).toDestination();

package/Tone/source/oscillator/Oscillator.test.ts

@@ -9,6 +9,7 @@ import { Offline } from "../../../test/helper/Offline.js";
 import { OscillatorTests } from "../../../test/helper/OscillatorTests.js";
 import { OutputAudio } from "../../../test/helper/OutputAudio.js";
 import { SourceTests } from "../../../test/helper/SourceTests.js";
+import { OfflineContext } from "../../core/context/OfflineContext.js";
 import { Signal } from "../../signal/Signal.js";
 import { Oscillator } from "./Oscillator.js";
 import { ToneOscillatorType } from "./OscillatorInterface.js";
@@ -111,14 +112,103 @@ describe("Oscillator", () => {
 				}
 			});
 		});
+	});
+
+	context("Periodic Wave Cache", () => {
+		beforeEach(() => {
+			// @ts-ignore
+			Oscillator._periodicWaveCache = [];
+		});
 
 		it("can go past the cache max size of 100", () => {
 			const osc = new Oscillator();
 			for (let i = 0; i < 110; i++) {
 				osc.phase = i;
 			}
+			// @ts-ignore
+			expect(Oscillator._periodicWaveCache.length).to.equal(100);
 			osc.dispose();
 		});
+
+		it("caches periodic waves by sample rate", () => {
+			const createWave = sinon.spy(
+				OfflineContext.prototype,
+				"createPeriodicWave"
+			);
+			const context44k = new OfflineContext(1, 0.01, 44100);
+			const context48k = new OfflineContext(1, 0.01, 48000);
+
+			const osc1 = new Oscillator({
+				context: context44k,
+				phase: 90,
+			});
+			const osc2 = new Oscillator({
+				context: context44k,
+				phase: 90,
+			});
+			expect(createWave).to.have.been.calledOnce;
+
+			const osc3 = new Oscillator({
+				context: context48k,
+				phase: 90,
+			});
+			expect(createWave).to.have.been.calledTwice;
+
+			const osc4 = new Oscillator({
+				context: context48k,
+				phase: 90,
+			});
+			expect(createWave).to.have.been.calledTwice;
+
+			osc1.dispose();
+			osc2.dispose();
+			osc3.dispose();
+			osc4.dispose();
+			context44k.dispose();
+			context48k.dispose();
+		});
+
+		it("caches custom waveforms by sample rate", () => {
+			const createWave = sinon.spy(
+				OfflineContext.prototype,
+				"createPeriodicWave"
+			);
+			const context44k = new OfflineContext(1, 0.01, 44100);
+			const context48k = new OfflineContext(1, 0.01, 48000);
+
+			const osc1 = new Oscillator({
+				context: context44k,
+				partials: [1, 2, 3],
+				type: "custom",
+			});
+			const osc2 = new Oscillator({
+				context: context44k,
+				partials: [1, 2, 3],
+				type: "custom",
+			});
+			expect(createWave).to.have.been.calledOnce;
+
+			const osc3 = new Oscillator({
+				context: context48k,
+				partials: [1, 2, 3],
+				type: "custom",
+			});
+			expect(createWave).to.have.been.calledTwice;
+
+			const osc4 = new Oscillator({
+				context: context48k,
+				partials: [1, 2, 3],
+				type: "custom",
+			});
+			expect(createWave).to.have.been.calledTwice;
+
+			osc1.dispose();
+			osc2.dispose();
+			osc3.dispose();
+			osc4.dispose();
+			context44k.dispose();
+			context48k.dispose();
+		});
 	});
 
 	context("Type", () => {

package/Tone/source/oscillator/Oscillator.ts

@@ -230,6 +230,7 @@ export class Oscillator
 		phase: number;
 		type: string;
 		partialCount: number;
+		sampleRate: number;
 		real: Float32Array;
 		imag: Float32Array;
 		wave: PeriodicWave;
@@ -252,6 +253,7 @@ export class Oscillator
 			const oscProps = Oscillator._periodicWaveCache.find(
 				(description) => {
 					return (
+						description.sampleRate === this.context.sampleRate &&
 						description.phase === this._phase &&
 						deepEquals(description.partials, this._partials)
 					);
@@ -262,6 +264,7 @@ export class Oscillator
 			const oscProps = Oscillator._periodicWaveCache.find(
 				(description) => {
 					return (
+						description.sampleRate === this.context.sampleRate &&
 						description.type === this._type &&
 						description.phase === this._phase
 					);
@@ -315,6 +318,7 @@ export class Oscillator
 					partialCount: this._partialCount,
 					partials: this._partials,
 					phase: this._phase,
+					sampleRate: this.context.sampleRate,
 					real,
 					type: this._type,
 					wave: this._wave,

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.59";
+export const version: string = "15.5.61";