tone 14.8.35 → 14.8.38

package/Tone/component/analysis/Meter.test.ts

@@ -5,6 +5,8 @@ import { ONLINE_TESTING } from "test/helper/Supports";
 import { Signal } from "Tone/signal/Signal";
 import { Oscillator } from "Tone/source/oscillator/Oscillator";
 import { Meter } from "./Meter";
+import { Panner } from "Tone/component/channel/Panner";
+import { Merge } from "Tone/component/channel/Merge";
 
 describe("Meter", () => {
 
@@ -86,6 +88,29 @@ describe("Meter", () => {
 					done();
 				}, 400);
 			});
+
+			it("can get the rms levels for multiple channels", (done) => {
+				const meter = new Meter({
+					channelCount: 2,
+					smoothing: 0.5,
+				});
+				const merge = new Merge().connect(meter);
+				const osc0 = new Oscillator().connect(merge, 0, 0).start();
+				const osc1 = new Oscillator().connect(merge, 0, 1).start();
+				osc0.volume.value = -6;
+				osc1.volume.value = -18;
+				setTimeout(() => {
+					const values = meter.getValue();
+					expect(values).to.have.lengthOf(2);
+					expect(values[0]).to.be.closeTo(-9, 1);
+					expect(values[1]).to.be.closeTo(-21, 1);
+					meter.dispose();
+					merge.dispose();
+					osc0.dispose();
+					osc1.dispose();
+					done();
+				}, 400);
+			});
 		}
 	});
 });

package/Tone/component/analysis/Meter.ts

@@ -42,9 +42,9 @@ export class Meter extends MeterBase<MeterOptions> {
 	smoothing: number;
 
 	/**
-	 * The previous frame's value
+	 * The previous frame's value for each channel.
 	 */
-	private _rms = 0;
+	private _rms: number[];
 
 	/**
 	 * @param smoothing The amount of smoothing applied between frames.
@@ -64,6 +64,8 @@ export class Meter extends MeterBase<MeterOptions> {
 
 		this.smoothing = options.smoothing,
 		this.normalRange = options.normalRange;
+		this._rms = new Array(options.channelCount);
+		this._rms.fill(0);
 	}
 
 	static getDefaults(): MeterOptions {
@@ -93,13 +95,13 @@ export class Meter extends MeterBase<MeterOptions> {
 	getValue(): number | number[] {
 		const aValues = this._analyser.getValue();
 		const channelValues = this.channels === 1 ? [aValues as Float32Array] : aValues as Float32Array[];
-		const vals = channelValues.map(values => {
+		const vals = channelValues.map((values, index) => {
 			const totalSquared = values.reduce((total, current) => total + current * current, 0);
 			const rms = Math.sqrt(totalSquared / values.length);
 			// the rms can only fall at the rate of the smoothing
 			// but can jump up instantly
-			this._rms = Math.max(rms, this._rms * this.smoothing);
-			return this.normalRange ? this._rms : gainToDb(this._rms);
+			this._rms[index] = Math.max(rms, this._rms[index]  * this.smoothing);
+			return this.normalRange ? this._rms[index] : gainToDb(this._rms[index]);
 		});
 		if (this.channels === 1) {
 			return vals[0];

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/core/clock/Ticker.ts

@@ -16,7 +16,12 @@ export class Ticker {
 	/**
 	 * The update interval of the worker
 	 */
-	private _updateInterval: Seconds;
+	private _updateInterval!: Seconds;
+
+	/**
+	 * The lowest allowable interval, preferably calculated from context sampleRate
+	 */
+	private _minimumUpdateInterval: Seconds;
 
 	/**
 	 * The callback to invoke at regular intervals
@@ -33,11 +38,12 @@ export class Ticker {
 	 */
 	private _worker!: Worker;
 
-	constructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds) {
+	constructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds, contextSampleRate?: number) {
 
 		this._callback = callback;
 		this._type = type;
-		this._updateInterval = updateInterval;
+		this._minimumUpdateInterval = Math.max( 128/(contextSampleRate || 44100), .001 );
+		this.updateInterval = updateInterval;
 
 		// create the clock source for the first time
 		this._createClock();
@@ -121,9 +127,9 @@ export class Ticker {
 		return this._updateInterval;
 	}
 	set updateInterval(interval: Seconds) {
-		this._updateInterval = Math.max(interval, 128 / 44100);
+		this._updateInterval = Math.max(interval, this._minimumUpdateInterval);
 		if (this._type === "worker") {
-			this._worker.postMessage(Math.max(interval * 1000, 1));
+			this._worker?.postMessage(this._updateInterval * 1000);
 		}
 	}
 

package/Tone/core/context/Context.test.ts

@@ -75,8 +75,10 @@ describe("Context", () => {
 				clockSource: "timeout",
 				latencyHint: "playback",
 				lookAhead: 0.2,
+				updateInterval: 0.1
 			});
 			expect(ctx.lookAhead).to.equal(0.2);
+			expect(ctx.updateInterval).to.equal(0.1);
 			expect(ctx.latencyHint).to.equal("playback");
 			expect(ctx.clockSource).to.equal("timeout");
 			ctx.dispose();

package/Tone/core/context/Context.ts

@@ -3,7 +3,7 @@ import { Seconds } from "../type/Units";
 import { isAudioContext } from "../util/AdvancedTypeCheck";
 import { optionsFromArguments } from "../util/Defaults";
 import { Timeline } from "../util/Timeline";
-import { isDefined, isString } from "../util/TypeCheck";
+import { isDefined } from "../util/TypeCheck";
 import {
 	AnyAudioContext,
 	createAudioContext,
@@ -39,13 +39,6 @@ export interface ContextTimeoutEvent {
 export class Context extends BaseContext {
 	readonly name: string = "Context";
 
-	/**
-	 * The amount of time into the future events are scheduled. Giving Web Audio
-	 * a short amount of time into the future to schedule events can reduce clicks and
-	 * improve performance. This value can be set to 0 to get the lowest latency.
-	 */
-	lookAhead: Seconds;
-
 	/**
 	 * private reference to the BaseAudioContext
 	 */
@@ -116,16 +109,20 @@ export class Context extends BaseContext {
 
 		if (options.context) {
 			this._context = options.context;
+			// custom context provided, latencyHint unknown (unless explicitly provided in options)
+			this._latencyHint = arguments[0]?.latencyHint || "";
 		} else {
 			this._context = createAudioContext({
 				latencyHint: options.latencyHint,
 			});
+			this._latencyHint = options.latencyHint;
 		}
 
 		this._ticker = new Ticker(
 			this.emit.bind(this, "tick"),
 			options.clockSource,
-			options.updateInterval
+			options.updateInterval,
+			this._context.sampleRate
 		);
 		this.on("tick", this._timeoutLoop.bind(this));
 
@@ -133,9 +130,9 @@ export class Context extends BaseContext {
 		this._context.onstatechange = () => {
 			this.emit("statechange", this.state);
 		};
-
-		this._setLatencyHint(options.latencyHint);
-		this.lookAhead = options.lookAhead;
+		
+		// if no custom updateInterval provided, updateInterval will be derived by lookAhead setter
+		this[arguments[0]?.hasOwnProperty("updateInterval") ? "_lookAhead" : "lookAhead"] = options.lookAhead;
 	}
 
 	static getDefaults(): ContextOptions {
@@ -391,8 +388,9 @@ export class Context extends BaseContext {
 	/**
 	 * How often the interval callback is invoked.
 	 * This number corresponds to how responsive the scheduling
-	 * can be. context.updateInterval + context.lookAhead gives you the
-	 * total latency between scheduling an event and hearing it.
+	 * can be. Setting to 0 will result in the lowest practial interval
+	 * based on context properties. context.updateInterval + context.lookAhead
+	 * gives you the total latency between scheduling an event and hearing it.
 	 */
 	get updateInterval(): Seconds {
 		return this._ticker.updateInterval;
@@ -412,6 +410,22 @@ export class Context extends BaseContext {
 		this._ticker.type = type;
 	}
 
+	/**
+	 * The amount of time into the future events are scheduled. Giving Web Audio
+	 * a short amount of time into the future to schedule events can reduce clicks and
+	 * improve performance. This value can be set to 0 to get the lowest latency.
+	 * Adjusting this value also affects the [[updateInterval]].
+	 */
+	get lookAhead(): Seconds {
+		return this._lookAhead;
+	}
+	set lookAhead(time: Seconds) {
+		this._lookAhead = time;
+		// if lookAhead is 0, default to .01 updateInterval
+		this.updateInterval = time ? (time / 2) : .01;
+	}	
+	private _lookAhead!: Seconds;
+
 	/**
 	 * The type of playback, which affects tradeoffs between audio
 	 * output latency and responsiveness.
@@ -431,29 +445,6 @@ export class Context extends BaseContext {
 		return this._latencyHint;
 	}
 
-	/**
-	 * Update the lookAhead and updateInterval based on the latencyHint
-	 */
-	private _setLatencyHint(hint: ContextLatencyHint | Seconds): void {
-		let lookAheadValue = 0;
-		this._latencyHint = hint;
-		if (isString(hint)) {
-			switch (hint) {
-				case "interactive":
-					lookAheadValue = 0.1;
-					break;
-				case "playback":
-					lookAheadValue = 0.5;
-					break;
-				case "balanced":
-					lookAheadValue = 0.25;
-					break;
-			}
-		}
-		this.lookAhead = lookAheadValue;
-		this.updateInterval = lookAheadValue / 2;
-	}
-
 	/**
 	 * The unwrapped AudioContext or OfflineAudioContext
 	 */
@@ -469,7 +460,7 @@ export class Context extends BaseContext {
 	 * }, 100);
 	 */
 	now(): Seconds {
-		return this._context.currentTime + this.lookAhead;
+		return this._context.currentTime + this._lookAhead;
 	}
 
 	/**