// The oscillator of an analog monosynth, as one module: a wave that morphs // from a triangle through a sawtooth and a square to a narrow pulse, a sub // oscillator locked to it, a phase that does not start where the last note's // did, and a pitch that never quite sits still. The vocabulary's own // `oscillator` reaches none of the four. It has no phase anything can read, // so nothing can count its cycles to divide them into a sub; nothing can tell // it where to start, and every voice built for a note starts it at nothing; // nothing can start it over, so it cannot be synced; and its waves are four // fixed shapes, so a knob between them is a crossfade of four oscillators // that only sound like one while they stay in step. // // **Wave** travels triangle, sawtooth, square at nought to two, each pair // mixed sample for sample between, and from two to three the square narrows // from a half of the cycle to a tenth of it rather than fading into anything. // A tenth because the pulse loses its fundamental fast below it — its level // falls with the sine of the width times pi, a third of the square's at a // tenth and a sixth at a twentieth — and because its two edges must stay // further apart than the two samples each one's correction spans, which at a // tenth they do up to C7 and at a twentieth only up to C6. A pulse spends more // of its cycle low than high, so it sits off centre by that much; the offset // is taken off as the width moves, rather than by a filter after it, so a // narrow pulse starts a note centred instead of thumping into place. // // Every wave starts where the platform's other oscillators start theirs: the // triangle and the sawtooth at nothing on their way up, the square at the // start of its high half. So **Phase** at reset starts every note exactly as // an `oscillator` would, and free starts each one somewhere else in its // cycle, drawn from `Math.random` — which is what an analog oscillator does, // since it never stopped running between notes. Two notes in a row, or two of // these detuned against each other, then never start their attack the same // way twice. // // **The sub** is a square one octave or two below, and is the main phase // divided rather than an oscillator of its own: it changes sides every time // the main phase comes round, or every second time, so it cannot drift // against it. It has an output of its own, at full level whatever the mix is, // and the module mixes it into Out through a gain outside this code. // // **Drift** is a slow wander of the pitch, in cents: a new target from the // dice every three tenths of a second, approached through a one-pole with the // same time constant, worked out every 32 samples rather than every one, // since nothing that slow needs more. It is the instability that makes two // analog oscillators beat against each other, and at nothing it is gone. // // **Sync** takes the phase back to its start on the rising zero crossings of // whatever is patched there, as the sync oscillator's Sync input does, a // sample late and never a fraction of one jittery. While it is driving, the // pitch heard is the thing driving it, so that is what the sub divides; when // it lets go, the sub divides the main phase's own turns again. // // Every discontinuity is corrected where it falls between two samples: a // polyBLEP scaled by however far the wave jumped for the sawtooth's fall, the // pulse's two edges, the sub's edges and a reset, and that residual // integrated once — a polyBLAMP — for the triangle's corners. The output // leaves through a one-pole at 5 Hz, as the sync oscillator's does and for // its reason: a wave cut off mid-cycle no longer sits either side of nothing. /** The narrowest the pulse gets, as a fraction of the cycle spent high. */ const NARROWEST = 0.1; /** Samples between two steps of the drift. */ const DRIFT_TICK = 32; /** Seconds between two of its targets, and its time constant. */ const DRIFT_SECONDS = 0.3; /** No more than a wave a sample, and never backwards. */ const limit = (step) => (!Number.isFinite(step) ? 0 : step > 0.49 ? 0.49 : step < 0 ? 0 : step); class AtmosynthAnalog extends AudioWorkletProcessor { static get parameterDescriptors() { return [ // The note, in hertz, off the module's MIDI input. { name: 'frequency', defaultValue: 0, minValue: 0, maxValue: 24000, automationRate: 'a-rate' }, // The knob and whatever is patched into Detune, together. { name: 'detune', defaultValue: 0, minValue: -9600, maxValue: 9600, automationRate: 'a-rate' }, // 0 triangle, 1 sawtooth, 2 square, 3 narrow pulse, and every place between. { name: 'wave', defaultValue: 1, minValue: 0, maxValue: 3, automationRate: 'a-rate' }, // Whatever is patched into Sync. Silence never crosses, so an input with // nothing in it starts nothing over. { name: 'reset', defaultValue: 0, minValue: -1000, maxValue: 1000, automationRate: 'a-rate' }, // How far the pitch wanders, in cents. { name: 'drift', defaultValue: 3, minValue: 0, maxValue: 15, automationRate: 'a-rate' }, // 0 one octave down, 1 two. { name: 'octave', defaultValue: 0, minValue: 0, maxValue: 1, automationRate: 'k-rate' }, // 0 free, 1 reset. Read once, when the note begins. { name: 'phase', defaultValue: 0, minValue: 0, maxValue: 1, automationRate: 'k-rate' }, ]; } constructor() { super(); this.phase = 0; /** The main phase's turns, counted round four: the sub is read off it. */ this.count = 0; /** Whether the first block has drawn where this note starts. */ this.begun = false; /** The Detune the ratio was last worked out for. */ this.cents = 0; this.ratio = 1; /** What the Wave knob was last worked out for, and what it came to. */ this.wave = NaN; this.tri = 0; this.saw = 1; this.pulse = 0; this.width = 0.5; this.offset = 0; this.start = 0; /** The Sync input as it was a sample ago, and samples it still drives for. */ this.lastLevel = 0; this.external = 0; /** Band-limiting owed to this sample and the next, for each output. */ this.owed = 0; this.carry = 0; this.subOwed = 0; this.subCarry = 0; /** The 5 Hz one-pole on the way out, and the two samples it remembers. */ this.pole = 1 - (2 * Math.PI * 5) / sampleRate; this.lastRaw = 0; this.centred = 0; /** The drift: samples to its next step and to its next target, where it is * heading, where it has got to, and the ratio that comes to. */ this.tick = 0; this.every = DRIFT_SECONDS * sampleRate; this.wait = this.every; this.glide = 1 - Math.exp(-DRIFT_TICK / this.every); this.target = 0; this.wander = 0; this.drifted = 1; } /** The Wave knob's travel, as weights on three waves and a pulse's width. */ shape(position) { const place = position < 0 ? 0 : position > 3 ? 3 : position; this.tri = place < 1 ? 1 - place : 0; this.saw = place < 1 ? place : place < 2 ? 2 - place : 0; this.pulse = place < 1 ? 0 : place < 2 ? place - 1 : 1; this.width = place < 2 ? 0.5 : 0.5 - (place - 2) * (0.5 - NARROWEST); // A pulse high for a fraction w of its cycle sits 2w − 1 off centre. this.offset = this.pulse * (2 * this.width - 1); this.start = this.level(0); } /** The wave at a phase, before any band-limiting. */ level(phase) { let value = 0; if (this.tri !== 0) { const turned = phase < 0.75 ? phase + 0.25 : phase - 0.75; value = this.tri * (1 - 4 * Math.abs(turned - 0.5)); } if (this.saw !== 0) value += this.saw * (phase < 0.5 ? 2 * phase : 2 * phase - 2); if (this.pulse !== 0) value += this.pulse * (phase < this.width ? 1 : -1) - this.offset; return value; } /** A band-limited step of `height`, `when` samples after this instant. */ jump(height, when) { const half = height / 2; this.owed += half * (1 - when) * (1 - when); this.carry -= half * when * when; } /** The same for the sub's own output. */ subJump(height, when) { const half = height / 2; this.subOwed += half * (1 - when) * (1 - when); this.subCarry -= half * when * when; } /** A band-limited corner: the slope changes by `change` a sample. */ bend(change, when) { const sixth = change / 6; this.owed += sixth * (1 - when) * (1 - when) * (1 - when); this.carry += sixth * when * when * when; } /** One more turn for the sub to divide, `when` samples after this instant. */ turn(mask, when) { const before = this.count & mask ? -1 : 1; this.count = (this.count + 1) & 3; const after = this.count & mask ? -1 : 1; if (after !== before) this.subJump(after - before, when); } process(inputs, outputs, parameters) { const output = outputs[0]; const channel = output[0]; const below = outputs[1][0]; // A param that does not move is handed over as one value rather than a // block of them; reading index 0 of it for every sample is the same. const { frequency, detune, wave, reset, drift } = parameters; const everyFrequency = frequency.length > 1 ? 1 : 0; const everyDetune = detune.length > 1 ? 1 : 0; const everyWave = wave.length > 1 ? 1 : 0; const everyReset = reset.length > 1 ? 1 : 0; const everyDrift = drift.length > 1 ? 1 : 0; const mask = parameters.octave[0] < 0.5 ? 1 : 2; const rate = sampleRate; if (!this.begun) { this.begun = true; if (parameters.phase[0] < 0.5) { this.phase = Math.random(); this.count = Math.floor(Math.random() * 4); this.wander = Math.random() * 2 - 1; } this.target = Math.random() * 2 - 1; } for (let index = 0; index < channel.length; index += 1) { const position = wave[index * everyWave]; if (!(position === this.wave)) { this.shape(position); this.wave = position; } const cents = detune[index * everyDetune]; if (cents !== this.cents) { this.cents = cents; this.ratio = Math.pow(2, cents / 1200); } if (this.tick === 0) { this.tick = DRIFT_TICK; this.wait -= DRIFT_TICK; if (this.wait <= 0) { this.wait += this.every; this.target = Math.random() * 2 - 1; } this.wander += (this.target - this.wander) * this.glide; this.drifted = Math.pow(2, (drift[index * everyDrift] * this.wander) / 1200); } this.tick -= 1; const step = limit((frequency[index * everyFrequency] * this.ratio * this.drifted) / rate); // The Sync input's rising zero crossings, placed the same fraction into // this sample as they fell into the last. let syncAt = -1; const level = reset[index * everyReset]; if (this.lastLevel < 0 && level >= 0) { syncAt = -this.lastLevel / (level - this.lastLevel); if (syncAt >= 1) syncAt = 0.999999; this.external = rate | 0; } this.lastLevel = level; const driven = this.external > 0; if (driven) this.external -= 1; // What the last sample's discontinuities left for this one. this.owed = this.carry; this.carry = 0; this.subOwed = this.subCarry; this.subCarry = 0; // Both outputs at this instant, before the interval to the next one is // walked for everything that happens in it. const value = this.level(this.phase); const sub = this.count & mask ? -1 : 1; const { tri, saw, pulse, width } = this; let phase = this.phase; let where = 0; for (let guard = 0; guard < 8; guard += 1) { let boundary = 1; if (tri !== 0) { if (phase < 0.25) boundary = 0.25; else if (phase < 0.75) boundary = 0.75; } if (saw !== 0 && phase < 0.5 && 0.5 < boundary) boundary = 0.5; if (pulse !== 0 && phase < width && width < boundary) boundary = width; let when = step > 0 ? where + (boundary - phase) / step : 2; if (when < where) when = where; if (syncAt >= where && syncAt <= when) { // Back to the start, from wherever the wave had got to, and the // triangle's slope with it where it was on its way down. phase += (syncAt - where) * step; where = syncAt; syncAt = -1; this.jump(this.start - this.level(phase), where); if (tri !== 0 && phase >= 0.25 && phase < 0.75) this.bend(8 * tri * step, where); phase = 0; this.turn(mask, where); continue; } if (when > 1) break; where = when; phase = boundary; if (tri !== 0) { if (boundary === 0.25) this.bend(-8 * tri * step, where); else if (boundary === 0.75) this.bend(8 * tri * step, where); } if (saw !== 0 && boundary === 0.5) this.jump(-2 * saw, where); if (pulse !== 0 && boundary === width) this.jump(-2 * pulse, where); if (boundary === 1) { if (pulse !== 0) this.jump(2 * pulse, where); phase = 0; if (!driven) this.turn(mask, where); } } this.phase = phase + (1 - where) * step; const raw = value + this.owed; this.centred = raw - this.lastRaw + this.pole * this.centred; this.lastRaw = raw; channel[index] = this.centred; below[index] = sub + this.subOwed; } for (let other = 1; other < output.length; other += 1) output[other].set(channel); for (let other = 1; other < outputs[1].length; other += 1) outputs[1][other].set(below); return true; } } registerProcessor('atmosynth-analog', AtmosynthAnalog);