tone 15.5.17 → 15.5.19

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

@@ -544,6 +544,65 @@ describe("TickSource", () => {
 			});
 			source.dispose();
 		});
+
+		it("does not fire duplicate ticks across consecutive windows at a tick boundary", () => {
+			// Reproduces the double-trigger bug from issues #1080/#1098/#1175.
+			// At 400 ticks/sec (equivalent to BPM=125, PPQ=192), tick 7680 falls
+			// at exactly t=19.2s.
+			const source = new TickSource(400);
+			source.start(0);
+
+			const firedTicks: number[] = [];
+			// Window 1 ends just above the tick-7680 boundary
+			source.forEachTickBetween(
+				19.19709750566994,
+				19.20000000000101,
+				(_, tick) => firedTicks.push(tick)
+			);
+			// Window 2 starts at exactly that same boundary
+			source.forEachTickBetween(
+				19.20000000000101,
+				19.202902494332076,
+				(_, tick) => firedTicks.push(tick)
+			);
+
+			const occurrences = firedTicks.filter((t) => t === 7680).length;
+			expect(occurrences).to.equal(
+				1,
+				`tick 7680 should fire exactly once, but fired ${occurrences} times`
+			);
+			source.dispose();
+		});
+
+		it("fires every tick exactly once across many consecutive windows", () => {
+			// At 2 Hz, ticks fall at 0, 0.5, 1.0, 1.5, 2.0.
+			// Window boundaries are placed just above each tick time (tick + eps)
+			// so every tick lands right at the end of one window and the start of the next.
+			const source = new TickSource(2);
+			source.start(0);
+
+			const tickCount = new Map<number, number>();
+			const record = (_: number, tick: number) => {
+				tickCount.set(tick, (tickCount.get(tick) ?? 0) + 1);
+			};
+
+			// Non-overlapping consecutive windows whose boundaries sit just above
+			// the tick times (0, 0.5, 1.0, 1.5, 2.0).
+			const eps = 1e-10;
+			source.forEachTickBetween(0, 0.5 + eps, record); // tick 0 (at 0.0) and tick 1 (at 0.5)
+			source.forEachTickBetween(0.5 + eps, 1.0 + eps, record); // tick 2 (at 1.0)
+			source.forEachTickBetween(1.0 + eps, 1.5 + eps, record); // tick 3 (at 1.5)
+			source.forEachTickBetween(1.5 + eps, 2.0 + eps, record); // tick 4 (at 2.0)
+			source.forEachTickBetween(2.0 + eps, 2.5, record); // tick 5 (at 2.5, not included)
+
+			for (const [tick, count] of tickCount) {
+				expect(count).to.equal(
+					1,
+					`tick ${tick} fired ${count} times instead of once`
+				);
+			}
+			source.dispose();
+		});
 	});
 
 	context("Seconds", () => {

package/Tone/core/clock/TickSource.ts

@@ -415,18 +415,28 @@ export class TickSource<
 
 		if (lastStateEvent && lastStateEvent.state === "started") {
 			const maxStartTime = Math.max(lastStateEvent.time, startTime);
-			// figure out the difference between the frequency ticks and the
+			// Figure out how far past the last whole-tick boundary maxStartTime
+			// sits, so we can compute the time of the next tick at or after it.
 			const startTicks = this.frequency.getTicksAtTime(maxStartTime);
 			const ticksAtStart = this.frequency.getTicksAtTime(
 				lastStateEvent.time
 			);
 			const diff = startTicks - ticksAtStart;
-			let offset = Math.ceil(diff) - diff;
-			// guard against floating point issues
-			offset = EQ(offset, 1) ? 0 : offset;
-			let nextTickTime = this.frequency.getTimeOfTick(
-				startTicks + offset
-			);
+			const offset = Math.ceil(diff) - diff;
+			// Guard against floating-point issues: when startTicks is just barely
+			// above an integer tick boundary (offset ≈ 1), snap back to that integer
+			const firstTick = EQ(offset, 1)
+				? Math.floor(startTicks)
+				: startTicks + offset;
+			let nextTickTime = this.frequency.getTimeOfTick(firstTick);
+			// Advance past any ticks that land before the start of this window
+			// to avoid any tick that was already processed.
+			if (nextTickTime < maxStartTime) {
+				nextTickTime += this.frequency.getDurationOfTicks(
+					1,
+					nextTickTime
+				);
+			}
 			while (nextTickTime < endTime) {
 				try {
 					callback(

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

@@ -75,6 +75,20 @@ describe("Transport", () => {
 			expect(invocations).to.equal(5);
 		});
 
+		it("does not double-fire events when looping many times", async () => {
+			let invocations = 0;
+			await Offline((context) => {
+				const transport = new TransportInstance({ context });
+				transport.schedule(() => {
+					invocations++;
+				}, 0);
+				transport.setLoopPoints(0, 1).start(0);
+				transport.loop = true;
+			}, 120.1);
+			// Should fire exactly 121 times: at t=0,1,2,...,120
+			expect(invocations).to.equal(121);
+		});
+
 		it("jumps to the loopStart after the loopEnd point", async () => {
 			let looped = false;
 			await Offline((context) => {

package/Tone/source/Source.ts

@@ -173,6 +173,19 @@ export abstract class Source<
 		duration?: Time
 	): void;
 
+	/**
+	 * Compute the buffer offset to use when the source is started mid-playback.
+	 * @param explicitOffset The buffer-time offset the caller passed to `start()`
+	 * @param transportElapsed Seconds of Transport time that have elapsed since
+	 *   this source was scheduled to start.
+	 */
+	protected _getSyncedStartOffset(
+		explicitOffset: Seconds,
+		transportElapsed: Seconds
+	): Seconds {
+		return explicitOffset + transportElapsed;
+	}
+
 	/**
 	 * Ensure that the scheduled time is not before the current time.
 	 * Should only be used when scheduled unsynced.
@@ -338,7 +351,10 @@ export abstract class Source<
 						}
 						this._start(
 							time,
-							this.toSeconds(stateEvent.offset) + startOffset,
+							this._getSyncedStartOffset(
+								this.toSeconds(stateEvent.offset),
+								startOffset
+							),
 							duration
 						);
 					}

package/Tone/source/buffer/Player.test.ts

@@ -620,7 +620,124 @@ describe("Player", () => {
 				// start halfway through
 				transport.start(0, 0.15);
 			}, 0.05);
-			expect(buff.getValueAtTime(0)).to.be.closeTo(0.5, 0.05);
+			// With playbackRate=0.5, transport position 0.15 maps to buffer position
+			// 0.15 * 0.5 = 0.075. The ramp value there is 0.075 / 0.3 = 0.25.
+			expect(buff.getValueAtTime(0)).to.be.closeTo(0.25, 0.03);
+		});
+
+		it("seeks to the correct buffer position when Transport starts at a non-zero offset with playbackRate != 1", async () => {
+			const buff = await Offline(({ transport }) => {
+				// Ramp 0 -> 1 over 0.4 s
+				const ramp = new Float32Array(
+					Math.floor(getContext().sampleRate * 0.4)
+				);
+				for (let i = 0; i < ramp.length; i++) {
+					ramp[i] = i / ramp.length;
+				}
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
+				// Buffer plays at 2x speed: 1 transport-second advances 2 buffer-seconds
+				player.playbackRate = 2;
+				player.sync().start(0);
+				// Seek transport to 0.1 s. The player should start at buffer position
+				// 0.1 * 2 = 0.2, giving a ramp value of 0.2 / 0.4 = 0.5.
+				transport.start(0, 0.1);
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(0.5, 0.03);
+		});
+
+		it("explicit buffer-time offset is not scaled by playbackRate when synced", async () => {
+			const buff = await Offline(({ transport }) => {
+				const ramp = new Float32Array(
+					Math.floor(getContext().sampleRate * 0.3)
+				);
+				for (let i = 0; i < ramp.length; i++) {
+					ramp[i] = i / ramp.length;
+				}
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
+				player.loop = true;
+				player.playbackRate = 2;
+				player.sync().start(0, 0.1);
+				transport.start(0);
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(1 / 3, 0.03);
+		});
+
+		it("combines explicit buffer-time offset with transport-elapsed time scaled by playbackRate", async () => {
+			const buff = await Offline(({ transport }) => {
+				const ramp = new Float32Array(
+					Math.floor(getContext().sampleRate * 0.3)
+				);
+				for (let i = 0; i < ramp.length; i++) {
+					ramp[i] = i / ramp.length;
+				}
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
+				player.loop = true;
+				player.playbackRate = 2;
+				player.sync().start(0, 0.1);
+				transport.start(0, 0.05);
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(2 / 3, 0.03);
+		});
+
+		it("looping player wraps correctly when transport offset exceeds buffer duration (playbackRate=1)", async () => {
+			// buffer duration = 1s, transport seeks to 2.5s
+			// buffer offset = 2.5 * 1 = 2.5 → wrapped = 2.5 % 1 = 0.5
+			const buff = await Offline(({ transport }) => {
+				const ramp = new Float32Array(getContext().sampleRate); // 1 s
+				for (let i = 0; i < ramp.length; i++) {
+					ramp[i] = i / ramp.length;
+				}
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
+				player.loop = true;
+				player.sync().start(0);
+				transport.start(0, 2.5);
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(0.5, 0.03);
+		});
+
+		it("looping player wraps correctly when transport offset exceeds buffer duration (playbackRate=2)", async () => {
+			// buffer duration = 1s, transport seeks to 1.25s, playbackRate=2
+			// buffer offset = 1.25 * 2 = 2.5 → wrapped = 2.5 % 1 = 0.5
+			const buff = await Offline(({ transport }) => {
+				const ramp = new Float32Array(getContext().sampleRate); // 1 s
+				for (let i = 0; i < ramp.length; i++) {
+					ramp[i] = i / ramp.length;
+				}
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
+				player.loop = true;
+				player.playbackRate = 2;
+				player.sync().start(0);
+				transport.start(0, 1.25);
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(0.5, 0.03);
+		});
+
+		it("looping player with loopStart/loopEnd wraps correctly when transport offset exceeds loop duration (playbackRate=2)", async () => {
+			// buffer duration = 1s, loopStart=0.2, loopEnd=1.0, loopDuration=0.8
+			// transport seeks to 1.15s, playbackRate=2
+			// buffer offset = 1.15 * 2 = 2.3
+			// wrapped = ((2.3 - 0.2) % 0.8) + 0.2 = (2.1 % 0.8) + 0.2 = 0.5 + 0.2 = 0.7
+			// ramp value at 0.7 in a 1s ramp = 0.7
+			const buff = await Offline(({ transport }) => {
+				const ramp = new Float32Array(getContext().sampleRate); // 1 s
+				for (let i = 0; i < ramp.length; i++) {
+					ramp[i] = i / ramp.length;
+				}
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
+				player.loop = true;
+				player.loopStart = 0.2;
+				player.loopEnd = 1.0;
+				player.playbackRate = 2;
+				player.sync().start(0);
+				transport.start(0, 1.15);
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(0.7, 0.03);
 		});
 
 		it("starts with an offset when synced and started after Transport is running", async () => {

package/Tone/source/buffer/Player.ts

@@ -262,6 +262,17 @@ export class Player extends Source<PlayerOptions> {
 		return this;
 	}
 
+	/**
+	 * Factor in the playback rate to compute the buffer offset when the player
+	 * is synced to the Transport.
+	 */
+	protected _getSyncedStartOffset(
+		explicitOffset: number,
+		transportElapsed: number
+	): number {
+		return explicitOffset + transportElapsed * this._playbackRate;
+	}
+
 	/**
 	 * Internal start method
 	 */

package/Tone/version.ts

@@ -1 +1 @@
-export const version: string = "15.5.17";
+export const version: string = "15.5.19";