Add channel 0 (noise) support

15-bit LFSR matching the SN76489AN — white feeds back bit0 ^ bit1, periodic
feeds back bit0 only. Pre-rendered into looping AudioBuffers at the three
documented shift rates (clock/512, clock/1024, clock/2048 against the BBC's
4 MHz chip clock). When channel === 0 the pitch envelope is skipped (chip
ignores PI/PN there) and the SOUND P arg is reinterpreted as a noise mode
via the low 3 bits. UI swaps the pitch input for an 8-option dropdown and
hides the pitch envelope subsection. P=3 / P=7 ("follows tone 2") are
decoded but currently audibly played as medium rate.

Six noise presets seeded (kick, snare, hat, cymbal, bass buzz, explosion).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: kieranhj

README.md

@@ -10,7 +10,8 @@ A static web app for editing, visualising, and auditioning `ENVELOPE` parameters
 - Editable BBC BASIC `ENVELOPE` and `SOUND` lines — paste an existing statement to populate the editor, or copy the formatted line for use in BASIC.
 - Visualisation of the resulting amplitude envelope (with A/D/S/R phase markers) and the absolute pitch over time.
 - Web Audio playback with a sweeping playhead synced to the audio clock.
-- 12 presets covering single-shot envelopes (Piano, Pluck, Bell, Pad, Bass, Drum, Laser) and looping pitch envelopes (Vibrato, Trill, Siren, Arpeggio, Wobble).
+- All four channels supported: tone (1..3) plus the noise channel (0). Noise is generated by a 15-bit LFSR matching the SN76489AN — white or periodic, at any of the three documented shift rates — selected by an 8-option dropdown when channel 0 is active.
+- Game-sourced presets (Sentinel, Zalaga, Elite, Chuckie Egg, Thrust), BBC User Guide example envelopes (UG #1..#9), synth-design presets (Piano, Pluck, Bell, Pad, Bass, Drum, Laser, Vibrato, Trill, Siren, Arpeggio, Wobble), and noise-channel presets (kick, snare, hat, cymbal, bass buzz, explosion).
 - Shareable URL: every change is reflected in the URL bar via `?env=…&sound=…`, so copying the address reproduces the exact state.
 - "Run in BBC emulator" button that opens the current `ENVELOPE`/`SOUND` in [bbc.xania.org](https://bbc.xania.org/) (jsbeeb) for one-click A/B against the real BBC.
 
@@ -51,11 +52,11 @@ A few non-obvious quirks (also documented in `CLAUDE.md`):
 - Pitch sections with `PN = 0` are not free — the OS hits `BEQ skipToNextChannel` after loading the empty section, so each empty section costs `T` cs of dead time. Loop wraps and non-empty section transitions are free.
 - The MOS allocates exactly **4** envelope slots (`N = 1..4`); higher numbers aren't usable.
 - Pitch is musically quantised to the BBC's own divider table (`pitchToHz()` in `src/envelope.ts`), not to equal temperament — higher octaves drift slightly sharp, matching the real machine.
+- Channel 0 noise uses only the low 3 bits of the `SOUND` `P` argument: bit 2 selects type (0 = periodic, 1 = white) and bits 1..0 select the LFSR shift rate (`clock/512`, `clock/1024`, `clock/2048` at the BBC's 4 MHz chip clock — i.e., ~7.8 / 3.9 / 2.0 kHz). PI/PN are ignored on the noise channel; the amplitude envelope works identically to tone channels.
 
 ## Future work
 
-- **Channel 0 (noise).** This tool currently restricts `SOUND` channel to 1..3 and uses a square oscillator. Real BBC channel 0 is a separate noise generator with several modes selected by the pitch parameter (white / periodic at different rates, plus a mode that tracks channel 2's frequency).
-- **Periodic noise as bass.** When channel 0 is set to one of the periodic modes — particularly the mode that tracks channel 2 — the result is a coloured tone an octave or two below the reference. This is the classic BBC "periodic bass" trick used by many games. Supporting it requires emulating the SN76489's noise LFSR rather than substituting a square wave.
+- **Noise rate "follows tone 2".** Two of the eight noise modes (`P=3` and `P=7`) clock the LFSR from channel 2's tone period, letting you sweep noise pitch under tone-channel control. The tool decodes these modes but currently audibly plays them at the medium rate; supporting the cross-channel link properly needs a virtual channel-2 pitch.
 - **Static amplitude.** Negative `SOUND` amplitude (-15..-1) selects a static volume bypassing the envelope. Currently disallowed in the UI.
 - **Stereo / multi-channel mixing.** Real BBC sequences usually involve simultaneous notes across multiple channels; this tool is single-note only.
 - **Authentic SN76489 timbre on tone channels.** The current square oscillator is a stand-in. A `PeriodicWave` or AudioWorklet implementation of the SN76489 tone generator would give a closer match.

src/audio.ts

@@ -1,12 +1,82 @@
-import { pitchToHz, type Sample } from "./envelope";
+import { pitchToHz, type NoiseMode, type Sample } from "./envelope";
 
 const CS = 0.01; // one centisecond, in seconds
 
 let ctx: AudioContext | null = null;
-let activeNodes: { osc: OscillatorNode; gain: GainNode } | null = null;
+interface ActiveNodes {
+  source: OscillatorNode | AudioBufferSourceNode;
+  gain: GainNode;
+}
+let activeNodes: ActiveNodes | null = null;
 let playStart: number | null = null;
 let playDuration: number | null = null;
 
+// Noise buffer cache, keyed by `${type}:${rate}` and rebuilt per AudioContext.
+let noiseBufferCache: { ctx: AudioContext; buffers: Map<string, AudioBuffer> } | null = null;
+
+// BBC Micro feeds the SN76489 at 4 MHz. The TI datasheet documents the noise
+// shift rate as clock/N where N ∈ {512, 1024, 2048} — i.e., the divisors are
+// applied to the raw input clock (the chip's own /16 prescaler is implied
+// in those numbers). High = ~7.8 kHz shift, low = ~1.95 kHz, which is what
+// makes white noise actually sound like noise rather than crackle.
+const BBC_CHIP_CLOCK_HZ = 4_000_000;
+const NOISE_DIVISORS = [512, 1024, 2048] as const;
+
+/**
+ * Build a tiled mono AudioBuffer of the SN76489AN noise output for one
+ * (type, rate) combination. We simulate a 15-bit LFSR — white feeds back the
+ * XOR of bits 0 and 1, periodic feeds back bit 0 only (period 15 → the
+ * characteristic BBC "drum" buzz). The LFSR is advanced sub-sample-accurately
+ * with a fractional counter so the output is correct at any AudioContext rate.
+ *
+ * Two seconds is plenty: white noise loops imperceptibly, periodic loops at
+ * ~30 Hz/8 Hz so two seconds easily contains a whole number of cycles.
+ */
+function buildNoiseBuffer(ac: AudioContext, mode: NoiseMode): AudioBuffer {
+  const sampleRate = ac.sampleRate;
+  const seconds = 2;
+  const n = Math.floor(sampleRate * seconds);
+  const buf = ac.createBuffer(1, n, sampleRate);
+  const data = buf.getChannelData(0);
+
+  // Rate 3 ("follows tone2") is punted to medium (rate 1).
+  const rateIdx = mode.rate === 3 ? 1 : mode.rate;
+  const shiftHz = BBC_CHIP_CLOCK_HZ / NOISE_DIVISORS[rateIdx]!;
+  const shiftsPerSample = shiftHz / sampleRate;
+
+  let lfsr = 0x4000;
+  let phase = 0;
+  let out = (lfsr & 1) === 1 ? 1 : -1;
+
+  for (let i = 0; i < n; i++) {
+    phase += shiftsPerSample;
+    while (phase >= 1) {
+      phase -= 1;
+      const fb = mode.type === "white"
+        ? (lfsr & 1) ^ ((lfsr >> 1) & 1)
+        : (lfsr & 1);
+      lfsr = ((lfsr >> 1) | (fb << 14)) & 0x7fff;
+      if (lfsr === 0) lfsr = 0x4000; // guard against the trivial lock-up state
+      out = (lfsr & 1) === 1 ? 1 : -1;
+    }
+    data[i] = out;
+  }
+  return buf;
+}
+
+function getNoiseBuffer(ac: AudioContext, mode: NoiseMode): AudioBuffer {
+  if (!noiseBufferCache || noiseBufferCache.ctx !== ac) {
+    noiseBufferCache = { ctx: ac, buffers: new Map() };
+  }
+  const key = `${mode.type}:${mode.rate}`;
+  let buf = noiseBufferCache.buffers.get(key);
+  if (!buf) {
+    buf = buildNoiseBuffer(ac, mode);
+    noiseBufferCache.buffers.set(key, buf);
+  }
+  return buf;
+}
+
 function getCtx(): AudioContext {
   if (!ctx) ctx = new (window.AudioContext || (window as unknown as { webkitAudioContext: typeof AudioContext }).webkitAudioContext)();
   return ctx;
@@ -30,42 +100,61 @@ function bbcAmpToGain(amp: number): number {
  * Play a sample stream as if produced by SOUND with the given base pitch.
  * The visualiser and the audio engine consume the same `samples` array, so
  * what you see is what you hear.
+ *
+ * For tone channels (1..3) `basePitch` is the BBC pitch byte that PI/PN
+ * offsets are added to. For the noise channel (0) `basePitch` is ignored
+ * and `noiseMode` selects type + rate; the chip ignores PI/PN there.
  */
-export function play(samples: Sample[], basePitch: number): void {
+export function play(samples: Sample[], basePitch: number, noiseMode: NoiseMode | null = null): void {
   stop();
   if (samples.length === 0) return;
   const ac = getCtx();
   if (ac.state === "suspended") ac.resume();
 
-  const osc = ac.createOscillator();
   const gain = ac.createGain();
-  osc.type = "square"; // closer to the BBC's tonal character than sine
-  osc.connect(gain).connect(ac.destination);
+  let source: OscillatorNode | AudioBufferSourceNode;
+
+  if (noiseMode) {
+    const noiseSrc = ac.createBufferSource();
+    noiseSrc.buffer = getNoiseBuffer(ac, noiseMode);
+    noiseSrc.loop = true;
+    noiseSrc.connect(gain).connect(ac.destination);
+    source = noiseSrc;
+  } else {
+    const osc = ac.createOscillator();
+    osc.type = "square"; // closer to the BBC's tonal character than sine
+    osc.connect(gain).connect(ac.destination);
+    source = osc;
+  }
 
   const t0 = ac.currentTime + 0.02;
   gain.gain.setValueAtTime(0, t0);
-  osc.frequency.setValueAtTime(pitchToHz(basePitch + samples[0]!.pitchOffset), t0);
+  if (!noiseMode && source instanceof OscillatorNode) {
+    source.frequency.setValueAtTime(pitchToHz(basePitch + samples[0]!.pitchOffset), t0);
+  }
 
   for (let i = 0; i < samples.length; i++) {
     const t = t0 + i * CS;
     const s = samples[i]!;
     gain.gain.setValueAtTime(bbcAmpToGain(s.amplitude), t);
-    osc.frequency.setValueAtTime(pitchToHz(basePitch + s.pitchOffset), t);
+    if (!noiseMode && source instanceof OscillatorNode) {
+      source.frequency.setValueAtTime(pitchToHz(basePitch + s.pitchOffset), t);
+    }
   }
 
   const tEnd = t0 + samples.length * CS;
   gain.gain.setValueAtTime(0, tEnd);
-  osc.start(t0);
-  osc.stop(tEnd + 0.05);
+  source.start(t0);
+  source.stop(tEnd + 0.05);
 
-  activeNodes = { osc, gain };
+  activeNodes = { source, gain };
   playStart = t0;
   playDuration = samples.length * CS;
-  osc.onended = () => {
-    // Only clear shared playback state if this osc is still the active one;
-    // otherwise a freshly-started note would have its timing wiped when the
-    // previously-stopped osc's onended fired late.
-    if (activeNodes && activeNodes.osc === osc) {
+  source.onended = () => {
+    // Only clear shared playback state if this source is still the active
+    // one; otherwise a freshly-started note would have its timing wiped
+    // when the previously-stopped source's onended fired late.
+    if (activeNodes && activeNodes.source === source) {
       activeNodes = null;
       playStart = null;
       playDuration = null;
@@ -76,7 +165,7 @@ export function play(samples: Sample[], basePitch: number): void {
 export function stop(): void {
   if (!activeNodes) return;
   try {
-    activeNodes.osc.stop();
+    activeNodes.source.stop();
   } catch {
     // already stopped
   }

src/envelope.ts

@@ -48,6 +48,31 @@ export interface Sample {
 // single sweep that holds at the final pitch when sections are exhausted.
 const PITCH_NO_REPEAT_BIT = 0x80;
 
+/**
+ * SN76489 noise channel mode. The chip's noise control register is 3 bits:
+ * bit 2 selects feedback type (0 = periodic, 1 = white), bits 1..0 select
+ * the LFSR shift rate. Rate 3 ("follows tone2 period") is decoded but the
+ * audio engine treats it as `medium` — see CLAUDE.md / future work.
+ */
+export type NoiseRate = 0 | 1 | 2 | 3;
+export interface NoiseMode {
+  type: "periodic" | "white";
+  rate: NoiseRate;
+}
+
+/**
+ * Decode the BBC SOUND pitch argument for channel 0 into noise type + rate.
+ * Only the low 3 bits matter; the OS masks higher bits when writing the
+ * chip's noise control register.
+ */
+export function decodeNoiseP(pitch: number): NoiseMode {
+  const p = (pitch | 0) & 0x07;
+  return {
+    type: (p & 0x04) !== 0 ? "white" : "periodic",
+    rate: (p & 0x03) as NoiseRate,
+  };
+}
+
 /**
  * Expand an envelope into a stream of per-centisecond samples for a given
  * SOUND command. `soundDuration` is in 1/20 s units (the BBC unit), and the
@@ -56,7 +81,7 @@ const PITCH_NO_REPEAT_BIT = 0x80;
  * The returned stream covers attack + decay + sustain + release, i.e. the
  * full audible lifetime of the note.
  */
-export function expand(env: Envelope, soundAmplitude: number, soundDuration: number, hold = false): Sample[] {
+export function expand(env: Envelope, soundAmplitude: number, soundDuration: number, hold = false, channel = 1): Sample[] {
   const samples: Sample[] = [];
 
   // SOUND amplitude argument: 0 = silence, -15..-1 = static volume, 1..4 = envelope number.
@@ -100,6 +125,7 @@ export function expand(env: Envelope, soundAmplitude: number, soundDuration: num
   //     resets offset and runs the same tick's step from section 0, so the
   //     wrap itself doesn't cost extra time (matches a normal step interval).
   const stepPitch = () => {
+    if (channel === 0) return; // noise channel ignores PI/PN entirely
     if (tStep === 0) return; // T=0 disables the pitch envelope
     if (sectionIdx >= sections.length) {
       if (!repeat) return;

src/main.ts

@@ -1,6 +1,7 @@
 import "./style.css";
 import {
   DEFAULT_ENVELOPE,
+  decodeNoiseP,
   expand,
   formatBasic,
   formatSound,
@@ -52,7 +53,7 @@ interface SoundParams {
 const DEFAULT_SOUND: SoundParams = { channel: 1, amplitude: 1, pitch: 100, duration: 20 };
 
 const SOUND_FIELDS: { key: keyof SoundParams; code: string; label: string; min: number; max: number; hint: string }[] = [
-  { key: "channel",   code: "C", label: "Channel",   min: 1, max: 3,   hint: "1..3 = tone (channel 0 noise is not supported by this tool)" },
+  { key: "channel",   code: "C", label: "Channel",   min: 0, max: 3,   hint: "0 = noise, 1..3 = tone" },
   { key: "amplitude", code: "A", label: "Amplitude", min: 1, max: 4,   hint: "1..4 selects envelope number (negative static volumes are not supported by this tool)" },
   { key: "pitch",     code: "P", label: "Pitch",     min: 0, max: 255, hint: "4 units per semitone, 48 per octave" },
   { key: "duration",  code: "D", label: "Duration",  min: 1, max: 255, hint: "in 1/20 s" },
@@ -108,9 +109,14 @@ function setEnvelopeNumber(n: number): void {
   if (ampInput) ampInput.value = String(c);
 }
 
+function currentNoiseMode(): ReturnType<typeof decodeNoiseP> | null {
+  return sound.channel === 0 ? decodeNoiseP(sound.pitch) : null;
+}
+
 function refresh(skipLine?: "envelope" | "sound"): void {
-  currentSamples = expand(env, sound.amplitude, sound.duration, holdEnabled);
-  render(canvas, currentSamples, sound.pitch, playheadFraction());
+  applyChannelMode();
+  currentSamples = expand(env, sound.amplitude, sound.duration, holdEnabled, sound.channel);
+  render(canvas, currentSamples, sound.pitch, playheadFraction(), currentNoiseMode());
   if (skipLine !== "envelope") envelopeLine.value = formatBasic(env);
   if (skipLine !== "sound") soundLine.value = formatSound(sound.channel, sound.amplitude, sound.pitch, sound.duration, holdEnabled);
   updateUrlParams();
@@ -156,7 +162,7 @@ function animatePlayhead(): void {
   if (playheadRaf !== null) return;
   const tick = () => {
     const f = playheadFraction();
-    render(canvas, currentSamples, sound.pitch, f);
+    render(canvas, currentSamples, sound.pitch, f, currentNoiseMode());
     if (f === null) {
       playheadRaf = null;
       return;
@@ -227,6 +233,72 @@ for (const f of SOUND_FIELDS) {
   soundInputs.set(f.key, input);
 }
 
+// Noise-mode select. Sits in the SOUND grid alongside the pitch input but is
+// only visible when channel === 0; encodes the low 3 bits of the SOUND P arg
+// per the SN76489AN noise control register (bit 2 = type, bits 1..0 = rate).
+const noiseModeWrap = document.createElement("label");
+noiseModeWrap.className = "field";
+noiseModeWrap.title = "SN76489AN noise control: bit 2 = type, bits 1..0 = LFSR shift rate (P=3/7 'follows tone 2' currently treated as medium)";
+{
+  const lbl = document.createElement("span");
+  lbl.className = "field-label";
+  const name = document.createElement("span");
+  name.className = "field-name";
+  name.textContent = "Noise mode";
+  const codeEl = document.createElement("code");
+  codeEl.className = "field-code";
+  codeEl.textContent = "P";
+  lbl.append(name, codeEl);
+  noiseModeWrap.appendChild(lbl);
+}
+const noiseSelect = document.createElement("select");
+const NOISE_OPTIONS: Array<[number, string]> = [
+  [0, "Periodic, high"],
+  [1, "Periodic, medium"],
+  [2, "Periodic, low"],
+  [3, "Periodic, follows tone 2"],
+  [4, "White, high"],
+  [5, "White, medium"],
+  [6, "White, low"],
+  [7, "White, follows tone 2"],
+];
+for (const [v, label] of NOISE_OPTIONS) {
+  const o = document.createElement("option");
+  o.value = String(v);
+  o.textContent = `${label}  (P=${v})`;
+  noiseSelect.appendChild(o);
+}
+noiseSelect.addEventListener("change", () => {
+  sound.pitch = Number(noiseSelect.value);
+  const pi = soundInputs.get("pitch");
+  if (pi) pi.value = String(sound.pitch);
+  refresh();
+});
+noiseModeWrap.appendChild(noiseSelect);
+soundGrid.appendChild(noiseModeWrap);
+
+const pitchH3 = pitchGrid.previousElementSibling as HTMLElement;
+const pitchInputWrap = soundInputs.get("pitch")!.closest("label") as HTMLElement;
+
+function applyChannelMode(): void {
+  const isNoise = sound.channel === 0;
+  pitchH3.style.display = isNoise ? "none" : "";
+  pitchGrid.style.display = isNoise ? "none" : "";
+  pitchInputWrap.style.display = isNoise ? "none" : "";
+  noiseModeWrap.style.display = isNoise ? "" : "none";
+  if (isNoise) {
+    // Channel 0 only uses low 3 bits of P; clamp once on entry so the URL,
+    // BASIC line, and select all stay consistent.
+    const clamped = sound.pitch & 0x07;
+    if (clamped !== sound.pitch) {
+      sound.pitch = clamped;
+      const pi = soundInputs.get("pitch");
+      if (pi) pi.value = String(sound.pitch);
+    }
+    noiseSelect.value = String(sound.pitch);
+  }
+}
+
 // Enforce env.n === sound.amplitude after the inputs are constructed (URL
 // load may have populated mismatched values; treat sound.amplitude as the
 // authoritative side since it's what selects the envelope at playback).
@@ -329,7 +401,7 @@ function playOnce(): void {
   // so audio playback is just a single play() call — no setTimeout-based
   // re-trigger. Mirrors BBC SOUND duration -1 semantics: envelope keeps
   // running, doesn't restart from the top.
-  play(currentSamples, sound.pitch);
+  play(currentSamples, sound.pitch, currentNoiseMode());
   animatePlayhead();
 }
 
@@ -339,7 +411,7 @@ function stopAll(): void {
     cancelAnimationFrame(playheadRaf);
     playheadRaf = null;
   }
-  render(canvas, currentSamples, sound.pitch, null);
+  render(canvas, currentSamples, sound.pitch, null, currentNoiseMode());
 }
 
 document.getElementById("play")!.addEventListener("click", () => {
@@ -409,11 +481,11 @@ refresh();
 // interaction. The fallback no-ops if the immediate attempt already kicked
 // audio into the running state.
 if (autoplayRequested) {
-  play(currentSamples, sound.pitch);
+  play(currentSamples, sound.pitch, currentNoiseMode());
   animatePlayhead();
   const playOnGesture = (): void => {
     if (!audioContextIsRunning()) {
-      play(currentSamples, sound.pitch);
+      play(currentSamples, sound.pitch, currentNoiseMode());
       animatePlayhead();
     }
     document.removeEventListener("click", playOnGesture);