tone 14.8.27

package/Tone/core/worklet/ToneAudioWorklet.ts

@@ -0,0 +1,76 @@
+import { ToneAudioNode, ToneAudioNodeOptions } from "../context/ToneAudioNode";
+import { noOp } from "../util/Interface";
+import { getWorkletGlobalScope } from "./WorkletGlobalScope";
+
+export type ToneAudioWorkletOptions = ToneAudioNodeOptions;
+
+export abstract class ToneAudioWorklet<Options extends ToneAudioWorkletOptions> extends ToneAudioNode<Options> {
+
+	readonly name: string = "ToneAudioWorklet";
+
+	/**
+	 * The processing node
+	 */
+	protected _worklet!: AudioWorkletNode;
+
+	/**
+	 * A dummy gain node to create a dummy audio param from
+	 */
+	private _dummyGain: GainNode;
+
+	/**
+	 * A dummy audio param to use when creating Params
+	 */
+	protected _dummyParam: AudioParam;
+
+	/**
+	 * The constructor options for the node
+	 */
+	protected workletOptions: Partial<AudioWorkletNodeOptions> = {};
+
+	/**
+	 * Get the name of the audio worklet
+	 */
+	protected abstract _audioWorkletName(): string;
+
+	/**
+	 * Invoked when the module is loaded and the node is created
+	 */
+	protected abstract onReady(node: AudioWorkletNode): void;
+
+	/**
+	 * Callback which is invoked when there is an error in the processing
+	 */
+	onprocessorerror: (e: string) => void = noOp;
+
+	constructor(options: Options) {
+		super(options);
+
+		const blobUrl = URL.createObjectURL(new Blob([getWorkletGlobalScope()], { type: "text/javascript" }));
+		const name = this._audioWorkletName();
+
+		this._dummyGain = this.context.createGain();
+		this._dummyParam = this._dummyGain.gain;
+
+		// Register the processor
+		this.context.addAudioWorkletModule(blobUrl, name).then(() => {
+			// create the worklet when it's read
+			if (!this.disposed) {
+				this._worklet = this.context.createAudioWorkletNode(name, this.workletOptions);
+				this._worklet.onprocessorerror = this.onprocessorerror.bind(this);
+				this.onReady(this._worklet);
+			}
+		});
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._dummyGain.disconnect();
+		if (this._worklet) {
+			this._worklet.port.postMessage("dispose");
+			this._worklet.disconnect();
+		}
+		return this;
+	}
+
+}

package/Tone/core/worklet/ToneAudioWorkletProcessor.worklet.ts

@@ -0,0 +1,35 @@
+import { addToWorklet } from "./WorkletGlobalScope";
+
+const toneAudioWorkletProcessor = /* javascript */ `
+	/**
+	 * The base AudioWorkletProcessor for use in Tone.js. Works with the [[ToneAudioWorklet]]. 
+	 */
+	class ToneAudioWorkletProcessor extends AudioWorkletProcessor {
+
+		constructor(options) {
+			
+			super(options);
+			/**
+			 * If the processor was disposed or not. Keep alive until it's disposed.
+			 */
+			this.disposed = false;
+		   	/** 
+			 * The number of samples in the processing block
+			 */
+			this.blockSize = 128;
+			/**
+			 * the sample rate
+			 */
+			this.sampleRate = sampleRate;
+
+			this.port.onmessage = (event) => {
+				// when it receives a dispose 
+				if (event.data === "dispose") {
+					this.disposed = true;
+				}
+			};
+		}
+	}
+`;
+
+addToWorklet(toneAudioWorkletProcessor);

package/Tone/core/worklet/WorkletGlobalScope.ts

@@ -0,0 +1,26 @@
+/**
+ * All of the classes or functions which are loaded into the AudioWorkletGlobalScope
+ */
+const workletContext: Set<string> = new Set();
+
+/**
+ * Add a class to the AudioWorkletGlobalScope
+ */
+export function addToWorklet(classOrFunction: string) {
+	workletContext.add(classOrFunction);
+}
+
+/**
+ * Register a processor in the AudioWorkletGlobalScope with the given name
+ */
+export function registerProcessor(name: string, classDesc: string) {
+	const processor = /* javascript */`registerProcessor("${name}", ${classDesc})`;
+	workletContext.add(processor);
+}
+
+/**
+ * Get all of the modules which have been registered to the AudioWorkletGlobalScope
+ */
+export function getWorkletGlobalScope(): string {
+	return Array.from(workletContext).join("\n");
+}

package/Tone/effect/AutoFilter.test.ts

@@ -0,0 +1,113 @@
+import { AutoFilter } from "./AutoFilter";
+import { BasicTests } from "test/helper/Basic";
+import { EffectTests } from "test/helper/EffectTests";
+import teoria from "teoria";
+import { Offline } from "test/helper/Offline";
+import { expect } from "chai";
+import { CompareToFile } from "test/helper/CompareToFile";
+import { Noise } from "Tone/source";
+
+describe("AutoFilter", () => {
+	
+	BasicTests(AutoFilter);
+	EffectTests(AutoFilter);
+
+	it("matches a file", () => {
+		return CompareToFile(() => {
+			const autoFilter = new AutoFilter({
+				baseFrequency: 200,
+				octaves: 4,
+				frequency: 4,
+				type: "sine"
+			}).toDestination();
+			new Noise().connect(autoFilter).start();
+			autoFilter.start(0.2);
+		}, "autoFilter.wav", 0.1);
+	});
+
+	context("API", () => {
+
+		it("can pass in options in the constructor", () => {
+			const autoFilter = new AutoFilter({
+				baseFrequency: 2000,
+				octaves: 2,
+				type: "sawtooth"
+			});
+			expect(autoFilter.baseFrequency).to.be.closeTo(2000, 0.1);
+			expect(autoFilter.octaves).to.equal(2);
+			expect(autoFilter.type).to.equal("sawtooth");
+			autoFilter.dispose();
+		});
+
+		it("can be started and stopped", () => {
+			const autoFilter = new AutoFilter();
+			autoFilter.start().stop("+0.2");
+			autoFilter.dispose();
+		});
+
+		it("can get/set the options", () => {
+			const autoFilter = new AutoFilter();
+			autoFilter.set({
+				baseFrequency: 1200,
+				frequency: 2.4,
+				type: "triangle"
+			});
+			expect(autoFilter.get().baseFrequency).to.be.closeTo(1200, 0.01);
+			expect(autoFilter.get().frequency).to.be.closeTo(2.4, 0.01);
+			expect(autoFilter.get().type).to.equal("triangle");
+			autoFilter.dispose();
+		});
+
+		it("can set the frequency and depth", () => {
+			const autoFilter = new AutoFilter();
+			autoFilter.depth.value = 0.4;
+			autoFilter.frequency.value = 0.4;
+			expect(autoFilter.depth.value).to.be.closeTo(0.4, 0.01);
+			expect(autoFilter.frequency.value).to.be.closeTo(0.4, 0.01);
+			autoFilter.dispose();
+		});
+
+		it("can set the filter options", () => {
+			const autoFilter = new AutoFilter();
+			autoFilter.filter.Q.value = 2;
+			expect(autoFilter.filter.Q.value).to.be.closeTo(2, 0.01);
+			autoFilter.dispose();
+		});
+
+		it("accepts baseFrequency and octaves as frequency values", () => {
+			const autoFilter = new AutoFilter("2n", "C2", 4);
+			expect(autoFilter.baseFrequency).to.be.closeTo(teoria.note("C2").fq(), 0.01);
+			expect(autoFilter.octaves).to.equal(4);
+			autoFilter.dispose();
+		});
+
+		it("can sync the frequency to the transport", () => {
+
+			return Offline(({ transport }) => {
+				const autoFilter = new AutoFilter(2);
+				autoFilter.sync();
+				autoFilter.frequency.toDestination();
+				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
+				// transport.start(0)
+			}, 0.1).then((buffer) => {
+				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
+			});
+		});
+
+		it("can unsync the frequency to the transport", () => {
+
+			return Offline(({ transport }) => {
+				const autoFilter = new AutoFilter(2);
+				autoFilter.sync();
+				autoFilter.frequency.toDestination();
+				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
+				autoFilter.unsync();
+			}, 0.1).then((buffer) => {
+				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
+			});
+		});
+	});
+});
+

package/Tone/effect/AutoFilter.ts

@@ -0,0 +1,102 @@
+import { Frequency, Positive } from "../core/type/Units";
+import { Filter, FilterOptions } from "../component/filter/Filter";
+import { SourceOptions } from "../source/Source";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { LFOEffect, LFOEffectOptions } from "./LFOEffect";
+
+export interface AutoFilterOptions extends LFOEffectOptions {
+	baseFrequency: Frequency;
+	octaves: Positive;
+	filter: Omit<FilterOptions, keyof SourceOptions | "frequency" | "detune" | "gain">;
+}
+
+/**
+ * AutoFilter is a Tone.Filter with a Tone.LFO connected to the filter cutoff frequency.
+ * Setting the LFO rate and depth allows for control over the filter modulation rate 
+ * and depth.
+ *
+ * @example
+ * // create an autofilter and start it's LFO
+ * const autoFilter = new Tone.AutoFilter("4n").toDestination().start();
+ * // route an oscillator through the filter and start it
+ * const oscillator = new Tone.Oscillator().connect(autoFilter).start();
+ * @category Effect
+ */
+export class AutoFilter extends LFOEffect<AutoFilterOptions> {
+
+	readonly name: string = "AutoFilter";
+
+	/**
+	 * The filter node
+	 */
+	readonly filter: Filter;
+
+	/**
+	 * The octaves placeholder
+	 */
+	private _octaves!: Positive;
+
+	/**
+	 * @param frequency The rate of the LFO.
+	 * @param baseFrequency The lower value of the LFOs oscillation
+	 * @param octaves The number of octaves above the baseFrequency
+	 */
+	constructor(frequency?: Frequency, baseFrequency?: Frequency, octaves?: Positive);
+	constructor(options?: Partial<AutoFilterOptions>);
+	constructor() {
+
+		super(optionsFromArguments(AutoFilter.getDefaults(), arguments, ["frequency", "baseFrequency", "octaves"]));
+		const options = optionsFromArguments(AutoFilter.getDefaults(), arguments, ["frequency", "baseFrequency", "octaves"]);
+
+		this.filter = new Filter(Object.assign(options.filter, {
+			context: this.context,
+		}));
+
+		// connections
+		this.connectEffect(this.filter);
+		this._lfo.connect(this.filter.frequency);
+		this.octaves = options.octaves;
+		this.baseFrequency = options.baseFrequency;
+	}
+
+	static getDefaults(): AutoFilterOptions {
+		return Object.assign(LFOEffect.getDefaults(), {
+			baseFrequency: 200,
+			octaves: 2.6,
+			filter: {
+				type: "lowpass" as "lowpass",
+				rolloff: -12 as -12,
+				Q: 1,
+			}
+		});
+	}
+
+	/**
+	 * The minimum value of the filter's cutoff frequency.
+	 */
+	get baseFrequency(): Frequency {
+		return this._lfo.min;
+	}
+	set baseFrequency(freq) {
+		this._lfo.min = this.toFrequency(freq);
+		// and set the max
+		this.octaves = this._octaves;
+	}
+
+	/**
+	 * The maximum value of the filter's cutoff frequency. 
+	 */
+	get octaves(): Positive {
+		return this._octaves;
+	}
+	set octaves(oct) {
+		this._octaves = oct;
+		this._lfo.max = this._lfo.min * Math.pow(2, oct);
+	}
+
+	dispose(): this {
+		super.dispose();
+		this.filter.dispose();
+		return this;
+	}
+}

package/Tone/effect/AutoPanner.test.ts

@@ -0,0 +1,90 @@
+import { AutoPanner } from "./AutoPanner";
+import { BasicTests } from "test/helper/Basic";
+import { EffectTests } from "test/helper/EffectTests";
+import { Offline } from "test/helper/Offline";
+import { expect } from "chai";
+import { CompareToFile } from "test/helper/CompareToFile";
+import { Oscillator } from "Tone/source/oscillator/Oscillator";
+
+describe("AutoPanner", () => {
+	BasicTests(AutoPanner);
+	EffectTests(AutoPanner);
+
+	it("matches a file", () => {
+		return CompareToFile(() => {
+			const autoFilter = new AutoPanner({
+				type: "sine",
+				frequency: 3,
+			}).toDestination();
+			new Oscillator().connect(autoFilter).start();
+			autoFilter.start(0.2);
+		}, "autoPanner.wav", 0.01);
+	});
+
+	context("API", () => {
+
+		it("can pass in options in the constructor", () => {
+			const autoPanner = new AutoPanner({
+				type: "sawtooth",
+				depth: 0.2
+			});
+			expect(autoPanner.depth.value).to.be.closeTo(0.2, 0.01);
+			expect(autoPanner.type).to.equal("sawtooth");
+			autoPanner.dispose();
+		});
+
+		it("can be started and stopped", () => {
+			const autoPanner = new AutoPanner();
+			autoPanner.start().stop("+0.2");
+			autoPanner.dispose();
+		});
+
+		it("can get/set the options", () => {
+			const autoPanner = new AutoPanner();
+			autoPanner.set({
+				frequency: 2.4,
+				type: "triangle"
+			});
+			expect(autoPanner.get().frequency).to.be.closeTo(2.4, 0.01);
+			expect(autoPanner.get().type).to.equal("triangle");
+			autoPanner.dispose();
+		});
+
+		it("can set the frequency and depth", () => {
+			const autoPanner = new AutoPanner();
+			autoPanner.depth.value = 0.4;
+			autoPanner.frequency.value = 0.4;
+			expect(autoPanner.depth.value).to.be.closeTo(0.4, 0.01);
+			expect(autoPanner.frequency.value).to.be.closeTo(0.4, 0.01);
+			autoPanner.dispose();
+		});
+
+		it("can sync the frequency to the transport", () => {
+			return Offline(({ transport }) => {
+				const panner = new AutoPanner(2);
+				panner.sync();
+				panner.frequency.toDestination();
+				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
+				// transport.start(0)
+			}, 0.1).then((buffer) => {
+				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(4, 0.1);
+			});
+		});
+
+		it("can unsync the frequency to the transport", () => {
+			return Offline(({ transport }) => {
+				const panner = new AutoPanner(2);
+				panner.sync();
+				panner.frequency.toDestination();
+				transport.bpm.setValueAtTime(transport.bpm.value * 2, 0.05);
+				panner.unsync();
+				// transport.start(0)
+			}, 0.1).then((buffer) => {
+				expect(buffer.getValueAtTime(0)).to.be.closeTo(2, 0.1);
+				expect(buffer.getValueAtTime(0.05)).to.be.closeTo(2, 0.1);
+			});
+		});
+	});
+});
+

package/Tone/effect/AutoPanner.ts

@@ -0,0 +1,63 @@
+import { Panner } from "../component/channel/Panner";
+import { optionsFromArguments } from "../core/util/Defaults";
+import { LFOEffect, LFOEffectOptions } from "./LFOEffect";
+import { Frequency } from "../core/type/Units";
+
+export interface AutoPannerOptions extends LFOEffectOptions {
+	channelCount: number;
+}
+
+/**
+ * AutoPanner is a [[Panner]] with an [[LFO]] connected to the pan amount. 
+ * [Related Reading](https://www.ableton.com/en/blog/autopan-chopper-effect-and-more-liveschool/).
+ *
+ * @example
+ * // create an autopanner and start it
+ * const autoPanner = new Tone.AutoPanner("4n").toDestination().start();
+ * // route an oscillator through the panner and start it
+ * const oscillator = new Tone.Oscillator().connect(autoPanner).start();
+ * @category Effect
+ */
+export class AutoPanner extends LFOEffect<AutoPannerOptions> {
+
+	readonly name: string = "AutoPanner";
+
+	/**
+	 * The filter node
+	 */
+	readonly _panner: Panner;
+
+	/**
+	 * @param frequency Rate of left-right oscillation. 
+	 */
+	constructor(frequency?: Frequency);
+	constructor(options?: Partial<AutoPannerOptions>);
+	constructor() {
+
+		super(optionsFromArguments(AutoPanner.getDefaults(), arguments, ["frequency"]));
+		const options = optionsFromArguments(AutoPanner.getDefaults(), arguments, ["frequency"]);
+
+		this._panner = new Panner({
+			context: this.context,
+			channelCount: options.channelCount
+		});
+		// connections
+		this.connectEffect(this._panner);
+		this._lfo.connect(this._panner.pan);
+		this._lfo.min = -1;
+		this._lfo.max = 1;
+	}
+
+	static getDefaults(): AutoPannerOptions {
+		return Object.assign(LFOEffect.getDefaults(), {
+			channelCount: 1
+		});
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._panner.dispose();
+		return this;
+	}
+}
+

package/Tone/effect/AutoWah.test.ts

@@ -0,0 +1,61 @@
+import { AutoWah } from "./AutoWah";
+import { BasicTests } from "test/helper/Basic";
+import { EffectTests } from "test/helper/EffectTests";
+import { expect } from "chai";
+import { CompareToFile } from "test/helper/CompareToFile";
+import { Synth } from "Tone/instrument/Synth";
+
+describe("AutoWah", () => {
+
+	BasicTests(AutoWah);
+	EffectTests(AutoWah);
+
+	it("matches a file", () => {
+		return CompareToFile(() => {
+			const wah = new AutoWah().toDestination();
+			wah.follower = 0.4;
+			const synth = new Synth().connect(wah);
+			synth.triggerAttackRelease("C4", 0.5);
+		}, "autoWah.wav", 0.01);
+	});
+
+	context("API", () => {
+
+		it("can pass in options in the constructor", () => {
+			const autoWah = new AutoWah({
+				baseFrequency: 150,
+				octaves: 3,
+				sensitivity: -10
+			});
+			expect(autoWah.baseFrequency).to.be.closeTo(150, 0.01);
+			autoWah.baseFrequency = 250;
+			expect(autoWah.baseFrequency).to.be.closeTo(250, 0.01);
+			expect(autoWah.octaves).to.be.closeTo(3, 0.01);
+			autoWah.octaves = 2;
+			expect(autoWah.octaves).to.be.closeTo(2, 0.01);
+			expect(autoWah.sensitivity).to.be.closeTo(-10, 0.1);
+			autoWah.sensitivity = -20;
+			expect(autoWah.sensitivity).to.be.closeTo(-20, 0.1);
+			autoWah.dispose();
+		});
+
+		it("can get/set the options", () => {
+			const autoWah = new AutoWah();
+			autoWah.set({
+				Q: 2.4,
+			});
+			expect(autoWah.get().Q).to.be.closeTo(2.4, 0.01);
+			autoWah.dispose();
+		});
+
+		it("can set the gain and follower values", () => {
+			const autoWah = new AutoWah();
+			autoWah.gain.value = 1.2;
+			autoWah.follower = 0.4;
+			expect(autoWah.gain.value).to.be.closeTo(1.2, 0.01);
+			expect(autoWah.follower).to.be.closeTo(0.4, 0.01);
+			autoWah.dispose();
+		});
+	});
+});
+