Apply all of the previously scheduled events to the passed in Param or AudioParam. The applied values will start at the context's current time and schedule all of the events which are scheduled on this Param onto the passed in param.

This is similar to cancelScheduledValues except it holds the automated value at time until the next automated event.

Cancels all scheduled parameter changes with times greater than or equal to startTime.

disconnect and dispose.

Start exponentially approaching the target value at the given time. Since it is an exponential approach it will continue approaching after the ramp duration. The rampTime is the time that it takes to reach over 99% of the way towards the value. This methods is similar to setTargetAtTime except the third argument is a time instead of a 'timeConstant'

import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// exponential approach over 4 seconds starting in 1 second
osc.frequency.exponentialApproachValueAtTime("C4", "+1", 4);

Schedules an exponential continuous change in parameter value from the current time and current value to the given value over the duration of the rampTime.

import { FeedbackDelay, Noise } from "tone";
const delay = new FeedbackDelay(0.5, 0.98).toDestination();
// a short burst of noise through the feedback delay
const noise = new Noise().connect(delay).start().stop("+0.1");
// making the delay time shorter over time will also make the pitch rise
delay.delayTime.exponentialRampTo(0.01, 20);

Schedules an exponential continuous change in parameter value from the previous scheduled parameter value to the given value.

Get the object's attributes.

import { Oscillator } from "tone";
const osc = new Oscillator();
console.log(osc.get());
// returns {"type" : "sine", "frequency" : 440, ...etc}

Returns all of the default options belonging to the class.

Get the signals value at the given time. Subsequent scheduling may invalidate the returned value.

import { now, Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// set the frequency to "G4" in exactly 1 second from now.
osc.frequency.setValueAtTime("G4", "+1");
setInterval(() => {
	// check the value every 100 ms
	osc.frequency.getValueAtTime(now());
}, 100);

Return the current time of the Context clock without any lookAhead.

Schedules an linear continuous change in parameter value from the current time and current value to the given value over the duration of the rampTime.

import { FeedbackDelay, Noise } from "tone";
const delay = new FeedbackDelay(0.5, 0.98).toDestination();
// a short burst of noise through the feedback delay
const noise = new Noise().connect(delay).start().stop("+0.1");
// linearly ramp to the value 4 over 3 seconds.
delay.delayTime.linearRampTo(4, 3);

Schedules a linear continuous change in parameter value from the previous scheduled parameter value to the given value.

Return the current time of the Context clock plus the lookAhead.

Ramps to the given value over the duration of the rampTime. Automatically selects the best ramp type (exponential or linear) depending on the units of the signal

import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// schedule it to ramp either linearly or exponentially depending on the units
osc.frequency.rampTo("A2", 10);

import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// schedule it to ramp starting at a specific time
osc.frequency.rampTo("A2", 10, "+2");

Set multiple properties at once with an object.

import { Filter } from "tone";
const filter = new Filter();
// set values using an object
filter.set({
	frequency: 300,
	type: "highpass"
});

Replace the Param's internal AudioParam. Will apply scheduled curves onto the parameter and replace the connections.

Creates a schedule point with the current value at the current time. Automation methods like linearRampToValueAtTime and exponentialRampToValueAtTime require a starting automation value usually set by setValueAtTime. This method is useful since it will do a setValueAtTime with whatever the currently computed value at the given time is.

import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// set the frequency to "G4" in exactly 1 second from now.
osc.frequency.setRampPoint("+1");
osc.frequency.linearRampToValueAtTime("C1", "+2");

Start exponentially approaching the target value at the given time with a rate having the given time constant.

Schedules a parameter value change at the given time.

import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
// set the frequency to "G4" in exactly 1 second from now.
osc.frequency.setValueAtTime("G4", "+1");

Sets an array of arbitrary parameter values starting at the given time for the given duration.

Start exponentially approaching the target value at the given time. Since it is an exponential approach it will continue approaching after the ramp duration. The rampTime is the time that it takes to reach over 99% of the way towards the value.

import { Oscillator } from "tone";
const osc = new Oscillator().toDestination().start();
osc.frequency.targetRampTo("C4", 4);

Convert the input to a frequency number

Convert the incoming time to seconds

Convert the class to a string

import { Oscillator } from "tone";
const osc = new Oscillator();
console.log(osc.toString());

Convert the input time into ticks