tone 14.8.45 → 14.8.46

package/Tone/core/clock/Transport.ts

@@ -1,6 +1,8 @@
 import { TimeClass } from "../../core/type/Time";
 import { PlaybackState } from "../../core/util/StateTimeline";
 import { TimelineValue } from "../../core/util/TimelineValue";
+import { ToneAudioNode } from "../../core/context/ToneAudioNode";
+import { Pow } from "../../signal/Pow";
 import { Signal } from "../../signal/Signal";
 import {
 	onContextClose,
@@ -58,7 +60,7 @@ type TransportEventNames =
 interface SyncedSignalEvent {
 	signal: Signal;
 	initial: number;
-	ratio: Gain;
+	nodes: ToneAudioNode<any>[];
 }
 
 type TransportCallback = (time: Seconds) => void;
@@ -707,25 +709,45 @@ export class Transport
 	 * 			Otherwise it will be computed based on their current values.
 	 */
 	syncSignal(signal: Signal<any>, ratio?: number): this {
+		const now = this.now();
+		let source : TickParam<"bpm"> | ToneAudioNode<any> = this.bpm;
+		let sourceValue = 1 / (60 / source.getValueAtTime(now) / this.PPQ);
+		let nodes : ToneAudioNode<any>[] = [];
+		// If the signal is in the time domain, sync it to the reciprocal of
+		// the tempo instead of the tempo.
+		if (signal.units === "time") {
+			// The input to Pow should be in the range [1 / 4096, 1], where
+			// where 4096 is half of the buffer size of Pow's waveshaper.
+			// Pick a scaling factor based on the initial tempo that ensures
+			// that the initial input is in this range, while leaving room for
+			// tempo changes.
+			const scaleFactor = 1 / 64 / sourceValue;
+			const scaleBefore = new Gain(scaleFactor);
+			const reciprocal = new Pow(-1);
+			const scaleAfter = new Gain(scaleFactor);
+			// @ts-ignore
+			source.chain(scaleBefore, reciprocal, scaleAfter);
+			source = scaleAfter;
+			sourceValue = 1 / sourceValue;
+			nodes = [scaleBefore, reciprocal, scaleAfter];
+		}
 		if (!ratio) {
 			// get the sync ratio
-			const now = this.now();
 			if (signal.getValueAtTime(now) !== 0) {
-				const bpm = this.bpm.getValueAtTime(now);
-				const computedFreq = 1 / (60 / bpm / this.PPQ);
-				ratio = signal.getValueAtTime(now) / computedFreq;
+				ratio = signal.getValueAtTime(now) / sourceValue;
 			} else {
 				ratio = 0;
 			}
 		}
 		const ratioSignal = new Gain(ratio);
 		// @ts-ignore
-		this.bpm.connect(ratioSignal);
+		source.connect(ratioSignal);
 		// @ts-ignore
 		ratioSignal.connect(signal._param);
+		nodes.push(ratioSignal);
 		this._syncedSignals.push({
 			initial: signal.value,
-			ratio: ratioSignal,
+			nodes: nodes,
 			signal,
 		});
 		signal.value = 0;
@@ -740,7 +762,7 @@ export class Transport
 		for (let i = this._syncedSignals.length - 1; i >= 0; i--) {
 			const syncedSignal = this._syncedSignals[i];
 			if (syncedSignal.signal === signal) {
-				syncedSignal.ratio.dispose();
+				syncedSignal.nodes.forEach((node) => node.dispose());
 				syncedSignal.signal.value = syncedSignal.initial;
 				this._syncedSignals.splice(i, 1);
 			}

package/Tone/signal/Signal.test.ts

@@ -480,6 +480,15 @@ describe("Signal", () => {
 			}, 10);
 		});
 
+		it("keeps the ratio of a time signal when the bpm changes", () => {
+			return ConstantOutput(({ transport }) => {
+				transport.bpm.value = 120;
+				const sig = new Signal("4n", "time").toDestination();
+				transport.syncSignal(sig);
+				transport.bpm.value = 240;
+			}, 0.25);
+		});
+
 		it("outputs 0 when the signal is 0", () => {
 			return ConstantOutput(({ transport }) => {
 				transport.bpm.value = 120;

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "14.8.45";
+export const version: string = "14.8.46";