tone 15.5.16 → 15.5.18

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

@@ -1,3 +1,5 @@
+import "../clock/Transport.js";
+
 import { expect } from "chai";
 
 import { TestAudioBuffer } from "../../../test/helper/compare/TestAudioBuffer.js";
@@ -58,4 +60,22 @@ describe("Offline", () => {
 		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
 		expect(testBuff.getTimeOfFirstSound()).to.be.closeTo(0.05, 0.0001);
 	});
+
+	it("nodes created in transport scheduleRepeat callbacks use the offline context", async () => {
+		// Addresses #781
+		// When transport callbacks fire during offline rendering, any nodes
+		// created inside them must use the offline context.
+		const buffer = await Offline(
+			({ transport }) => {
+				transport.scheduleRepeat((time) => {
+					new ToneOscillatorNode().toDestination().start(time);
+				}, 0.1);
+				transport.start(0);
+			},
+			0.5,
+			1
+		);
+		const testBuff = new TestAudioBuffer(buffer.get() as AudioBuffer);
+		expect(testBuff.isSilent()).to.equal(false);
+	});
 });

package/Tone/core/context/OfflineContext.ts

@@ -1,5 +1,6 @@
 import { createOfflineAudioContext } from "../context/AudioContext.js";
 import { Context } from "../context/Context.js";
+import { getContext, setContext } from "../Global.js";
 import { Seconds } from "../type/Units.js";
 import { isOfflineAudioContext } from "../util/AdvancedTypeCheck.js";
 import { ToneAudioBuffer } from "./ToneAudioBuffer.js";
@@ -83,8 +84,12 @@ export class OfflineContext extends Context {
 	private async _renderClock(asynchronous: boolean): Promise<void> {
 		let index = 0;
 		while (this._duration - this._currentTime >= 0) {
-			// invoke all the callbacks on that time
+			// temporarily set this offline context as the global default
+			// so that any nodes created inside tick callbacks use this context
+			const previousContext = getContext();
+			setContext(this);
 			this.emit("tick");
+			setContext(previousContext);
 
 			// increment the clock in block-sized chunks
 			this._currentTime += 128 / this.sampleRate;

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.16";
+export const version: string = "15.5.18";