tone 14.8.27

package/Tone/component/channel/Panner3D.ts

@@ -0,0 +1,234 @@
+import { Param } from "../../core/context/Param";
+import { ToneAudioNode, ToneAudioNodeOptions } from "../../core/context/ToneAudioNode";
+import { Degrees, GainFactor } from "../../core/type/Units";
+import { optionsFromArguments } from "../../core/util/Defaults";
+import "../../core/context/Listener";
+
+export interface Panner3DOptions extends ToneAudioNodeOptions {
+	coneInnerAngle: Degrees;
+	coneOuterAngle: Degrees;
+	coneOuterGain: GainFactor;
+	distanceModel: DistanceModelType;
+	maxDistance: number;
+	orientationX: number;
+	orientationY: number;
+	orientationZ: number;
+	panningModel: PanningModelType;
+	positionX: number;
+	positionY: number;
+	positionZ: number;
+	refDistance: number;
+	rolloffFactor: number;
+}
+
+/**
+ * A spatialized panner node which supports equalpower or HRTF panning.
+ * @category Component
+ */
+export class Panner3D extends ToneAudioNode<Panner3DOptions> {
+
+	readonly name: string = "Panner3D";
+
+	/**
+	 * The panning object
+	 */
+	private _panner: PannerNode;
+	readonly input: PannerNode;
+	readonly output: PannerNode;
+
+	readonly positionX: Param<"number">;
+	readonly positionY: Param<"number">;
+	readonly positionZ: Param<"number">;
+
+	readonly orientationX: Param<"number">;
+	readonly orientationY: Param<"number">;
+	readonly orientationZ: Param<"number">;
+
+	/**
+	 * @param positionX The initial x position.
+	 * @param positionY The initial y position.
+	 * @param positionZ The initial z position.
+	 */
+	constructor(positionX: number, positionY: number, positionZ: number);
+	constructor(options?: Partial<Panner3DOptions>);
+	constructor() {
+
+		super(optionsFromArguments(Panner3D.getDefaults(), arguments, ["positionX", "positionY", "positionZ"]));
+		const options = optionsFromArguments(Panner3D.getDefaults(), arguments, ["positionX", "positionY", "positionZ"]);
+
+		this._panner = this.input = this.output = this.context.createPanner();
+		// set some values
+		this.panningModel = options.panningModel;
+		this.maxDistance = options.maxDistance;
+		this.distanceModel = options.distanceModel;
+		this.coneOuterGain = options.coneOuterGain;
+		this.coneOuterAngle = options.coneOuterAngle;
+		this.coneInnerAngle = options.coneInnerAngle;
+		this.refDistance = options.refDistance;
+		this.rolloffFactor = options.rolloffFactor;
+
+		this.positionX = new Param({
+			context: this.context,
+			param: this._panner.positionX,
+			value: options.positionX,
+		});
+		this.positionY = new Param({
+			context: this.context,
+			param: this._panner.positionY,
+			value: options.positionY,
+		});
+		this.positionZ = new Param({
+			context: this.context,
+			param: this._panner.positionZ,
+			value: options.positionZ,
+		});
+		this.orientationX = new Param({
+			context: this.context,
+			param: this._panner.orientationX,
+			value: options.orientationX,
+		});
+		this.orientationY = new Param({
+			context: this.context,
+			param: this._panner.orientationY,
+			value: options.orientationY,
+		});
+		this.orientationZ = new Param({
+			context: this.context,
+			param: this._panner.orientationZ,
+			value: options.orientationZ,
+		});
+	}
+
+	static getDefaults(): Panner3DOptions {
+		return Object.assign(ToneAudioNode.getDefaults(), {
+			coneInnerAngle: 360,
+			coneOuterAngle: 360,
+			coneOuterGain: 0,
+			distanceModel: "inverse" as DistanceModelType,
+			maxDistance: 10000,
+			orientationX: 0,
+			orientationY: 0,
+			orientationZ: 0,
+			panningModel: "equalpower" as PanningModelType,
+			positionX: 0,
+			positionY: 0,
+			positionZ: 0,
+			refDistance: 1,
+			rolloffFactor: 1,
+		});
+	}
+
+	/**
+	 * Sets the position of the source in 3d space.
+	 */
+	setPosition(x: number, y: number, z: number): this {
+		this.positionX.value = x;
+		this.positionY.value = y;
+		this.positionZ.value = z;
+		return this;
+	}
+
+	/**
+	 * Sets the orientation of the source in 3d space.
+	 */
+	setOrientation(x: number, y: number, z: number): this {
+		this.orientationX.value = x;
+		this.orientationY.value = y;
+		this.orientationZ.value = z;
+		return this;
+	}
+
+	/**
+	 * The panning model. Either "equalpower" or "HRTF".
+	 */
+	get panningModel(): PanningModelType {
+		return this._panner.panningModel;
+	}
+	set panningModel(val) {
+		this._panner.panningModel = val;
+	}
+
+	/**
+	 * A reference distance for reducing volume as source move further from the listener
+	 */
+	get refDistance(): number {
+		return this._panner.refDistance;
+	}
+	set refDistance(val) {
+		this._panner.refDistance = val;
+	}
+
+	/**
+	 * Describes how quickly the volume is reduced as source moves away from listener.
+	 */
+	get rolloffFactor(): number {
+		return this._panner.rolloffFactor;
+	}
+	set rolloffFactor(val) {
+		this._panner.rolloffFactor = val;
+	}
+
+	/**
+	 * The distance model used by,  "linear", "inverse", or "exponential".
+	 */
+	get distanceModel(): DistanceModelType {
+		return this._panner.distanceModel;
+	}
+	set distanceModel(val) {
+		this._panner.distanceModel = val;
+	}
+
+	/**
+	 * The angle, in degrees, inside of which there will be no volume reduction
+	 */
+	get coneInnerAngle(): Degrees {
+		return this._panner.coneInnerAngle;
+	}
+	set coneInnerAngle(val) {
+		this._panner.coneInnerAngle = val;
+	}
+
+	/**
+	 * The angle, in degrees, outside of which the volume will be reduced
+	 * to a constant value of coneOuterGain
+	 */
+	get coneOuterAngle(): Degrees {
+		return this._panner.coneOuterAngle;
+	}
+	set coneOuterAngle(val) {
+		this._panner.coneOuterAngle = val;
+	}
+
+	/**
+	 * The gain outside of the coneOuterAngle
+	 */
+	get coneOuterGain(): GainFactor {
+		return this._panner.coneOuterGain;
+	}
+	set coneOuterGain(val) {
+		this._panner.coneOuterGain = val;
+	}
+
+	/**
+	 * The maximum distance between source and listener,
+	 * after which the volume will not be reduced any further.
+	 */
+	get maxDistance(): number {
+		return this._panner.maxDistance;
+	}
+	set maxDistance(val) {
+		this._panner.maxDistance = val;
+	}
+
+	dispose(): this {
+		super.dispose();
+		this._panner.disconnect();
+		this.orientationX.dispose();
+		this.orientationY.dispose();
+		this.orientationZ.dispose();
+		this.positionX.dispose();
+		this.positionY.dispose();
+		this.positionZ.dispose();
+		return this;
+	}
+}

package/Tone/component/channel/Recorder.test.ts

@@ -0,0 +1,119 @@
+import { expect } from "chai";
+import { connectFrom } from "test/helper/Connect";
+import { Recorder } from "./Recorder";
+import { Context } from "Tone/core/context/Context";
+import { ToneWithContext } from "Tone/core/context/ToneWithContext";
+import { Synth } from "Tone/instrument/Synth";
+
+describe("Recorder", () => {
+
+	context("basic", () => {
+
+		it("can be created and disposed", () => {
+			const rec = new Recorder();
+			rec.dispose();
+		});
+
+		it("handles input connections", () => {
+			const rec = new Recorder();
+			connectFrom().connect(rec);
+			rec.dispose();
+		});
+
+		it("reports if it is supported or not", () => {
+			expect(Recorder.supported).to.be.a("boolean");
+		});
+
+		it("can get the mime type", () => {
+			const rec = new Recorder();
+			expect(rec.mimeType).to.be.a("string");
+			rec.dispose();
+		});
+
+		it("can set a different context", () => {
+			const testContext = new Context();
+			const rec = new Recorder({
+				context: testContext
+			});
+			for (const member in rec) {
+				if (rec[member] instanceof ToneWithContext) {
+					expect(rec[member].context, `member: ${member}`).to.equal(testContext);
+				}
+			}
+			testContext.dispose();
+			rec.dispose();
+			return testContext.close();
+		});
+	});
+
+	function wait(time) {
+		return new Promise(done => setTimeout(done, time));
+	}
+
+	context("start/stop/pause", () => {
+
+		it("can be started", () => {
+			const rec = new Recorder();
+			rec.start();
+			expect(rec.state).to.equal("started");
+			rec.dispose();
+		});
+
+		it("can be paused after starting", async () => {
+			const rec = new Recorder();
+			rec.start();
+			expect(rec.state).to.equal("started");
+			await wait(100);
+			rec.pause();
+			expect(rec.state).to.equal("paused");
+			rec.dispose();
+		});
+
+		it("can be stopped after starting", async () => {
+			const rec = new Recorder();
+			rec.start();
+			expect(rec.state).to.equal("started");
+			await wait(100);
+			rec.stop();
+			expect(rec.state).to.equal("stopped");
+			rec.dispose();
+		});
+
+		it("throws an error if stopped or paused before starting", async () => {
+			const rec = new Recorder();
+			let didThrow = false;
+			try {
+				await rec.stop();
+			} catch (e) {
+				didThrow = true;
+			}
+			expect(didThrow).to.be.true;
+			expect(() => {
+				rec.pause();
+			}).to.throw(Error);
+			rec.dispose();
+		});
+
+		it("stop returns a blob", async () => {
+			const rec = new Recorder();
+			rec.start();
+			await wait(100);
+			const recording = await rec.stop();
+			expect(recording).to.be.instanceOf(Blob);
+			rec.dispose();
+		});
+
+		it("can record some sound", async () => {
+			const rec = new Recorder();
+			const synth = new Synth().connect(rec);
+			rec.start();
+			synth.triggerAttack("C3");
+			await wait(200);
+			const recording = await rec.stop();
+			expect(recording.size).to.be.greaterThan(0);
+			rec.dispose();
+			synth.dispose();
+		});
+
+	});
+});

package/Tone/component/channel/Recorder.ts

@@ -0,0 +1,162 @@
+import { ToneAudioNode, ToneAudioNodeOptions } from "../../core/context/ToneAudioNode";
+import { Gain } from "../../core/context/Gain";
+import { assert } from "../../core/util/Debug";
+import { theWindow } from "../../core/context/AudioContext";
+import { optionsFromArguments } from "../../core/util/Defaults";
+import { PlaybackState } from "../../core/util/StateTimeline";
+
+export interface RecorderOptions extends ToneAudioNodeOptions {
+	mimeType?: string;
+}
+
+/**
+ * A wrapper around the MediaRecorder API. Unlike the rest of Tone.js, this module does not offer
+ * any sample-accurate scheduling because it is not a feature of the MediaRecorder API.
+ * This is only natively supported in Chrome and Firefox. 
+ * For a cross-browser shim, install (audio-recorder-polyfill)[https://www.npmjs.com/package/audio-recorder-polyfill]. 
+ * @example
+ * const recorder = new Tone.Recorder();
+ * const synth = new Tone.Synth().connect(recorder);
+ * // start recording
+ * recorder.start();
+ * // generate a few notes
+ * synth.triggerAttackRelease("C3", 0.5);
+ * synth.triggerAttackRelease("C4", 0.5, "+1");
+ * synth.triggerAttackRelease("C5", 0.5, "+2");
+ * // wait for the notes to end and stop the recording
+ * setTimeout(async () => {
+ * 	// the recorded audio is returned as a blob
+ * 	const recording = await recorder.stop();
+ * 	// download the recording by creating an anchor element and blob url
+ * 	const url = URL.createObjectURL(recording);
+ * 	const anchor = document.createElement("a");
+ * 	anchor.download = "recording.webm";
+ * 	anchor.href = url;
+ * 	anchor.click();
+ * }, 4000);
+ * @category Component
+ */
+export class Recorder extends ToneAudioNode<RecorderOptions> {
+
+	readonly name = "Recorder";
+
+	/**
+	 * Recorder uses the Media Recorder API
+	 */
+	private _recorder: MediaRecorder;
+
+	/**
+	 * MediaRecorder requires 
+	 */
+	private _stream: MediaStreamAudioDestinationNode;
+
+	readonly input: Gain;
+	readonly output: undefined;
+
+	constructor(options?: Partial<RecorderOptions>);
+	constructor() {
+
+		super(optionsFromArguments(Recorder.getDefaults(), arguments));
+		const options = optionsFromArguments(Recorder.getDefaults(), arguments);
+
+		this.input = new Gain({
+			context: this.context
+		});
+
+		assert(Recorder.supported, "Media Recorder API is not available");
+
+		this._stream = this.context.createMediaStreamDestination();
+		this.input.connect(this._stream);
+		this._recorder = new MediaRecorder(this._stream.stream, {
+			mimeType: options.mimeType
+		});
+	}
+
+	static getDefaults(): RecorderOptions {
+		return ToneAudioNode.getDefaults();
+	}
+
+	/**
+	 * The mime type is the format that the audio is encoded in. For Chrome 
+	 * that is typically webm encoded as "vorbis". 
+	 */
+	get mimeType(): string {
+		return this._recorder.mimeType;
+	}
+
+	/**
+	 * Test if your platform supports the Media Recorder API. If it's not available, 
+	 * try installing this (polyfill)[https://www.npmjs.com/package/audio-recorder-polyfill].
+	 */
+	static get supported(): boolean {
+		return theWindow !== null && Reflect.has(theWindow, "MediaRecorder");
+	}
+
+	/**
+	 * Get the playback state of the Recorder, either "started", "stopped" or "paused"
+	 */
+	get state(): PlaybackState {
+		if (this._recorder.state === "inactive") {
+			return "stopped";
+		} else if (this._recorder.state === "paused") {
+			return "paused";
+		} else {
+			return "started";
+		}
+	}
+
+	/**
+	 * Start the Recorder. Returns a promise which resolves
+	 * when the recorder has started.
+	 */
+	async start() {
+		assert(this.state !== "started", "Recorder is already started");
+		const startPromise = new Promise(done => {
+			const handleStart = () => {
+				this._recorder.removeEventListener("start", handleStart, false);
+
+				done();
+			};
+
+			this._recorder.addEventListener("start", handleStart, false);
+		});
+
+		this._recorder.start();
+		return await startPromise;
+	}
+
+	/**
+	 * Stop the recorder. Returns a promise with the recorded content until this point
+	 * encoded as [[mimeType]]
+	 */
+	async stop(): Promise<Blob> {
+		assert(this.state !== "stopped", "Recorder is not started");
+		const dataPromise: Promise<Blob> = new Promise(done => {
+			const handleData = (e: BlobEvent) => {
+				this._recorder.removeEventListener("dataavailable", handleData, false);
+
+				done(e.data);
+			};
+
+			this._recorder.addEventListener("dataavailable", handleData, false);
+		});
+		this._recorder.stop();
+		return await dataPromise;
+	}
+
+	/**
+	 * Pause the recorder
+	 */
+	pause(): this {
+		assert(this.state === "started", "Recorder must be started");
+		this._recorder.pause();
+		return this;
+	}
+
+	dispose(): this {
+		super.dispose();
+		this.input.dispose();
+		this._stream.disconnect();
+		return this;
+	}
+}

package/Tone/component/channel/Solo.test.ts

@@ -0,0 +1,138 @@
+import { expect } from "chai";
+import { BasicTests } from "test/helper/Basic";
+import { ConstantOutput } from "test/helper/ConstantOutput";
+import { Signal } from "Tone/signal/Signal";
+import { Solo } from "./Solo";
+
+describe("Solo", () => {
+
+	BasicTests(Solo);
+
+	context("Soloing", () => {
+
+		it("can be soloed an unsoloed", () => {
+			const sol = new Solo();
+			sol.solo = true;
+			expect(sol.solo).to.be.true;
+			sol.solo = false;
+			expect(sol.solo).to.be.false;
+			sol.dispose();
+		});
+
+		it("can be passed into the constructor", () => {
+			const sol = new Solo(true);
+			expect(sol.solo).to.be.true;
+			sol.dispose();
+		});
+
+		it("can be passed into the constructor with an object", () => {
+			const sol = new Solo({ solo: true });
+			expect(sol.solo).to.be.true;
+			sol.dispose();
+		});
+
+		it("other instances are unsoloed when one is soloed", () => {
+			const solA = new Solo();
+			const solB = new Solo();
+			solA.solo = true;
+			solB.solo = false;
+			expect(solA.solo).to.be.true;
+			expect(solB.solo).to.be.false;
+			solB.solo = true;
+			expect(solA.solo).to.be.true;
+			expect(solB.solo).to.be.true;
+			solA.solo = false;
+			expect(solA.solo).to.be.false;
+			expect(solB.solo).to.be.true;
+			solA.dispose();
+			solB.dispose();
+		});
+
+		it("other instances report themselves as muted", () => {
+			const solA = new Solo();
+			const solB = new Solo();
+			solA.solo = true;
+			solB.solo = false;
+			expect(solA.muted).to.be.false;
+			expect(solB.muted).to.be.true;
+			solA.dispose();
+			solB.dispose();
+		});
+
+		it("all instances are unmuted when there is no solo", () => {
+			const solA = new Solo();
+			const solB = new Solo();
+			solA.solo = true;
+			solB.solo = false;
+			solA.solo = false;
+			expect(solA.muted).to.be.false;
+			expect(solB.muted).to.be.false;
+			solA.dispose();
+			solB.dispose();
+		});
+
+		it("a newly created instance will be muted if there is already a soloed instance", () => {
+			const solA = new Solo(true);
+			const solB = new Solo();
+			expect(solA.muted).to.be.false;
+			expect(solB.muted).to.be.true;
+			solA.dispose();
+			solB.dispose();
+		});
+
+		it("passes both signals when nothing is soloed", () => {
+			return ConstantOutput(() => {
+				const soloA = new Solo().toDestination();
+				const soloB = new Solo().toDestination();
+				new Signal(10).connect(soloA);
+				new Signal(20).connect(soloB);
+			}, 30, 0.01);
+		});
+
+		it("passes one signal when it is soloed", () => {
+			return ConstantOutput(() => {
+				const soloA = new Solo().toDestination();
+				const soloB = new Solo().toDestination();
+				new Signal(10).connect(soloA);
+				new Signal(20).connect(soloB);
+				soloA.solo = true;
+			}, 10, 0.01);
+		});
+
+		it("can solo multiple at once", () => {
+			return ConstantOutput(() => {
+				const soloA = new Solo().toDestination();
+				const soloB = new Solo().toDestination();
+				new Signal(10).connect(soloA);
+				new Signal(20).connect(soloB);
+				soloA.solo = true;
+				soloB.solo = true;
+			}, 30, 0.01);
+		});
+
+		it("can unsolo all", () => {
+			return ConstantOutput(() => {
+				const soloA = new Solo().toDestination();
+				const soloB = new Solo().toDestination();
+				new Signal(10).connect(soloA);
+				new Signal(20).connect(soloB);
+				soloA.solo = true;
+				soloB.solo = true;
+				soloA.solo = false;
+				soloB.solo = false;
+			}, 30, 0.01);
+		});
+
+		it("can solo and unsolo while keeping previous soloed", () => {
+			return ConstantOutput(() => {
+				const soloA = new Solo().toDestination();
+				const soloB = new Solo().toDestination();
+				new Signal(10).connect(soloA);
+				new Signal(20).connect(soloB);
+				soloA.solo = true;
+				soloB.solo = true;
+				soloB.solo = false;
+			}, 10, 0.01);
+		});
+	});
+});