jsbeeb 1.20.0 → 1.20.2

package/README.md

@@ -289,6 +289,11 @@ sudo rpm -i out/dist/jsbeeb-1.0.1.x86_64.rpm
 - (mostly internal use) `logFdcCommands`, `logFdcStateChanges` - turn on logging in the disc controller.
 - `audioDebug` - show the audio lead chart, and log one console line per second in which the emulator tick ran late or the sound stalled or skipped.
 - `audioLatencyMs` - how far the sound runs behind the emulator, in milliseconds (default 20). Raising it lets the sound ride out longer stalls of the emulator, at the cost of lagging the picture by that much.
+- `audiofilterfreq` / `audiofilterq` - the corner frequency in Hz and the Q of the lowpass modelling the board's output
+  filter, applied to the sound chip before it is resampled. The defaults, 7234 and 0.696, are the Beeb's own.
+  `audiofilterfreq=0` turns the filter off.
+- `displayMode=X` - picks the display: `rgb` (the default, a plain monitor), `pal` (a television fed by the Beeb's UHF modulator)
+  or `xbr` (an upscaler, see [docs/xbr-display-mode.md](docs/xbr-display-mode.md)).
 
 ### Atom-specific parameters
 

package/package.json

@@ -7,7 +7,7 @@
   "name": "jsbeeb",
   "description": "Emulate a BBC Micro",
   "repository": "git@github.com:mattgodbolt/jsbeeb.git",
-  "version": "1.20.0",
+  "version": "1.20.2",
   "//engines": "If you change the version of Node, it must also be updated at the top of the Dockerfile.",
   "engines": {
     "node": ">=24.15.0"

package/src/acia.js

@@ -4,8 +4,9 @@
 // https://books.google.com/books?id=wUecAQAAQBAJ&pg=PA431&lpg=PA431&dq=acia+tdre&source=bl&ots=mp-yF-mK-P&sig=e6aXkFRfiIOb57WZmrvdIGsCooI&hl=en&sa=X&ei=0g2fVdDyFIXT-QG8-JD4BA&ved=0CCwQ6AEwAw#v=onepage&q=acia%20tdre&f=false
 // http://www.classiccmp.org/dunfield/r/6850.pdf
 
-export class Acia {
+export class Acia extends EventTarget {
     constructor(cpu, toneGen, scheduler, relayNoise) {
+        super();
         this.cpu = cpu;
         this.toneGen = toneGen;
         this.rs423Handler = null;
@@ -20,6 +21,7 @@ export class Acia {
         this.tapeCarrierCount = 0;
         this.tapeDcdLineLevel = false;
         this.hadDcdHigh = false;
+        this.saidOverrun = false;
         this.serialReceiveRate = 0;
         this.serialReceiveCyclesPerByte = 0;
         this.serialTransmitRate = 0;
@@ -200,8 +202,8 @@ export class Acia {
             // TODO: this doesn't match the datasheet:
             // "The Overrun does not occur in the Status Register until the
             // valid character prior to Overrun has been read."
-            console.log("Serial overrun");
             this.sr |= 0xa0;
+            this.noteOverrun();
         } else {
             // If bit 7 contains parity, mask it off.
             this.dr = byte & (this.cr & 0x10 ? 0xff : 0x7f);
@@ -210,6 +212,22 @@ export class Acia {
         this.updateIrq();
     }
 
+    noteOverrun() {
+        if (this.saidOverrun) return;
+        this.saidOverrun = true;
+        this.dispatchEvent(
+            new CustomEvent("notice", {
+                detail: {
+                    message:
+                        "A serial byte arrived before the previous one was read, so it was lost. " +
+                        "A tape load that stops with Data? is usually this.",
+                    title: "Serial",
+                    quietKey: "quietSerialOverrun",
+                },
+            }),
+        );
+    }
+
     snapshotState() {
         const scheduler = this.txCompleteTask.scheduler;
         return {

package/src/app/app.js

@@ -250,6 +250,16 @@ const template = [
                 click: sendAction("rewind"),
             },
             { type: "separator" },
+            {
+                label: "Pause and Show Debugger",
+                accelerator: "CmdOrCtrl+Home",
+                click: sendAction("pause"),
+            },
+            {
+                label: "Resume",
+                click: sendAction("resume"),
+            },
+            { type: "separator" },
             {
                 label: "Soft Reset",
                 click: sendAction("soft-reset"),

package/src/biquad.js

@@ -0,0 +1,36 @@
+// Coefficients from the RBJ Audio EQ Cookbook: the second-order prototype
+// under a bilinear transform prewarped so the corner lands on `frequency`.
+export class LowPassBiquad {
+    constructor(sampleRate, frequency, q) {
+        const w0 = (2 * Math.PI * frequency) / sampleRate;
+        const alpha = Math.sin(w0) / (2 * q);
+        const cosW0 = Math.cos(w0);
+        const a0 = 1 + alpha;
+        this.b0 = (1 - cosW0) / (2 * a0);
+        this.b1 = (1 - cosW0) / a0;
+        this.a1 = (-2 * cosW0) / a0;
+        this.a2 = (1 - alpha) / a0;
+        this.x1 = 0;
+        this.x2 = 0;
+        this.y1 = 0;
+        this.y2 = 0;
+    }
+
+    process(buffer, offset, length) {
+        const { b0, b1, a1, a2 } = this;
+        let { x1, x2, y1, y2 } = this;
+        for (let i = offset; i < offset + length; ++i) {
+            const x = buffer[i];
+            const y = b0 * x + b1 * x1 + b0 * x2 - a1 * y1 - a2 * y2;
+            x2 = x1;
+            x1 = x;
+            y2 = y1;
+            y1 = y;
+            buffer[i] = y;
+        }
+        this.x1 = x1;
+        this.x2 = x2;
+        this.y1 = y1;
+        this.y2 = y2;
+    }
+}

package/src/canvas.js

@@ -240,7 +240,8 @@ export class GlCanvas {
         this.filter.setUniforms({
             width,
             height,
-            frameCount: frame.frameCount,
+            lineBaseEven: frame.lineBaseEven,
+            lineBaseOdd: frame.lineBaseOdd,
             lineGrid: frame.lineGrid,
             // How much of the framebuffer each output pixel covers, which sets
             // how wide an edge-smoothing ramp should be. `extent` holds texel

package/src/jsbeeb.css

@@ -81,6 +81,12 @@ body {
   width: 90px;
 }
 
+#debug-keys {
+  clear: both;
+  padding-top: 3px;
+  color: #aaaaaa;
+}
+
 #crtc_debug {
   background-color: #333333;
   border: 1px solid #555555;

package/src/main.js

@@ -89,6 +89,11 @@ function stringToMachineKeys(text) {
 }
 
 const gamepad = new GamePad();
+if (!window.isSecureContext)
+    toast("Gamepads only work over https, so any joystick plugged in here is not seen.", {
+        title: "Gamepads",
+        quietKey: "quietInsecureGamepads",
+    });
 const availableImages = [
     {
         name: "Elite",
@@ -175,12 +180,6 @@ const cpuMultiplier = parsedQuery.cpuMultiplier ?? 1;
 let fastAsPossible = false;
 let fastTape = false;
 let noSeek;
-// The board's output filter is an equal-component Sallen-Key (Service Manual
-// section 3.8: 10K and 2n2 twice, gain 1 + 22/39): f0 = 1/(2*pi*RC) = 7234 Hz,
-// Q = 1/(3 - K) = 0.696, below 1/sqrt(2), so no resonant peak. BiquadFilterNode
-// takes lowpass Q in decibels: 20*log10(0.696) = -3.15.
-let audioFilterFreq = 7234;
-let audioFilterQ = -3.15;
 let stationId = 101;
 let econet = null;
 
@@ -209,8 +208,6 @@ if (parsedQuery.embed) {
 fastTape = !!parsedQuery.fasttape;
 noSeek = !!parsedQuery.noseek;
 
-if (parsedQuery.audiofilterfreq !== undefined) audioFilterFreq = parsedQuery.audiofilterfreq;
-if (parsedQuery.audiofilterq !== undefined) audioFilterQ = parsedQuery.audiofilterq;
 if (parsedQuery.stationId !== undefined) stationId = parsedQuery.stationId;
 if (parsedQuery.frameSkip !== undefined) frameSkip = parsedQuery.frameSkip;
 
@@ -239,7 +236,15 @@ const userPort = {
 // Speech output: initialised from URL param; can be toggled at runtime via the Settings panel.
 // Must be created before Config so the onClose callback and the initial checkbox state can reference it.
 const speechOutput = new SpeechOutput();
-speechOutput.enabled = !!parsedQuery.speechOutput;
+
+function setSpeechOutput(enabled) {
+    speechOutput.enabled = enabled;
+    if (enabled && typeof speechSynthesis === "undefined")
+        toast("This browser has no speech synthesis, so speech output has nothing to speak with.", {
+            title: "Speech",
+        });
+}
+setSpeechOutput(!!parsedQuery.speechOutput);
 
 const config = new Config(
     function onChange(changed) {
@@ -266,9 +271,7 @@ const config = new Config(
                 setupMicrophone();
             }
         }
-        if (changed.speechOutput !== undefined) {
-            speechOutput.enabled = !!changed.speechOutput;
-        }
+        if (changed.speechOutput !== undefined) setSpeechOutput(!!changed.speechOutput);
         if (changed.tubeCpuMultiplier !== undefined) {
             emulationConfig.tubeCpuMultiplier = changed.tubeCpuMultiplier;
             config.setTubeCpuMultiplier(changed.tubeCpuMultiplier);
@@ -557,7 +560,15 @@ displayModeFilter = canvas.filterClass;
 // frame into the canvas and an animation frame presents it, so a stalled
 // display holds up the picture and not the emulation (issue #885).
 const videoFb32 = new Uint32Array(canvas.fb32.length);
-const pendingFrame = { minx: 0, miny: 0, maxx: 0, maxy: 0, frameCount: 0, lineGrid: new Uint8Array(0) };
+const pendingFrame = {
+    minx: 0,
+    miny: 0,
+    maxx: 0,
+    maxy: 0,
+    lineBaseEven: 0,
+    lineBaseOdd: 0,
+    lineGrid: new Uint8Array(0),
+};
 let presentScheduled = false;
 let paintMsThisTick = 0;
 let presentMsMax = 0;
@@ -581,7 +592,14 @@ video = new Video(
         if (pendingFrame.lineGrid.length !== this.lineGrid.length)
             pendingFrame.lineGrid = new Uint8Array(this.lineGrid.length);
         pendingFrame.lineGrid.set(this.lineGrid);
-        Object.assign(pendingFrame, { minx, miny, maxx, maxy, frameCount: this.frameCount });
+        Object.assign(pendingFrame, {
+            minx,
+            miny,
+            maxx,
+            maxy,
+            lineBaseEven: this.lineBaseEven,
+            lineBaseOdd: this.lineBaseOdd,
+        });
         paintMsThisTick += performance.now() - start;
         if (!presentScheduled) {
             presentScheduled = true;
@@ -598,8 +616,8 @@ const audioStatsNode = parsedQuery.audioDebug ? audioStatsEl : null;
 const audioHandler = new AudioHandler({
     warningNode: document.getElementById("audio-warning"),
     statsNode: audioStatsNode,
-    audioFilterFreq,
-    audioFilterQ,
+    audioFilterFreq: parsedQuery.audiofilterfreq,
+    audioFilterQ: parsedQuery.audiofilterq,
     audioLatencyMs: parsedQuery.audioLatencyMs,
     noSeek,
     cpuSpeed,
@@ -704,8 +722,10 @@ pastetext.addEventListener("drop", async function (event) {
         } else if (file.name.toLowerCase().endsWith(".uef")) {
             // Regular UEF tape image (not a BeebEm save state)
             setProcessorTape(await loadTapeFromData(file.name, new Uint8Array(arrayBuffer), model));
+            toast(`Loaded ${file.name} as the tape.`, { title: "Dropped" });
         } else {
             await loadHTMLFile(file);
+            toast(`Loaded ${file.name} into drive 0.`, { title: "Dropped" });
         }
     } catch (error) {
         reportLoadFailure(file.name, error);
@@ -757,20 +777,36 @@ window.addEventListener("blur", function () {
 });
 window.addEventListener("focus", () => setEmulationLead(audioHandler.setWindowFocused(true)));
 
-document.getElementById("fs").addEventListener("click", function (event) {
-    screenCanvas.requestFullscreen();
-    event.preventDefault();
-});
+const fullscreenItem = document.getElementById("fs");
+if (document.fullscreenEnabled) {
+    fullscreenItem.addEventListener("click", async (event) => {
+        event.preventDefault();
+        try {
+            await screenCanvas.requestFullscreen();
+        } catch (error) {
+            toast(`Could not go fullscreen: ${errorText(error)}`, { title: "Fullscreen" });
+        }
+    });
+} else {
+    fullscreenItem.closest("li").hidden = true;
+}
 
 let keyboard; // This will be initialised after the processor is created
 
 const debugPause = document.getElementById("debug-pause");
 const debugPlay = document.getElementById("debug-play");
-debugPause.addEventListener("click", () => stop(true));
-debugPlay.addEventListener("click", () => {
+
+function pauseIntoDebugger() {
+    stop(true);
+}
+
+function resumeFromDebugger() {
     dbgr.hide();
-    go();
-});
+    keyboard.resumeEmulation();
+}
+
+debugPause.addEventListener("click", pauseIntoDebugger);
+debugPlay.addEventListener("click", resumeFromDebugger);
 
 // To lower chance of data loss, only accept drop events in the drop
 // zone in the menu bar.
@@ -848,6 +884,7 @@ processor = new CpuClass(model, {
 printer.attach(processor.uservia);
 
 processor.teletextAdaptor?.addEventListener("notice", showNotice);
+processor.acia.addEventListener("notice", showNotice);
 
 // Create input sources
 const gamepadSource = new GamepadSource(emulationConfig.getGamepads);
@@ -1692,12 +1729,6 @@ document.querySelector("#google-drive-auth form").addEventListener("submit", asy
 });
 
 async function gdLoad(cat, layout) {
-    // TODO: have a onclose flush event, handle errors
-    /*
-     $(window).bind("beforeunload", function() {
-     return confirm("Do you really want to close?");
-     });
-     */
     popupLoading("Loading '" + cat.name + "' from Google Drive");
     try {
         const available = await googleDrive.initialise();
@@ -1718,6 +1749,12 @@ async function gdLoad(cat, layout) {
         const ssd = await googleDrive.load(processor.fdc, cat.id, layout);
         console.log("Google Drive loading finished");
         loadingFinished();
+        if (!ssd.savesChanges) {
+            toast(`${cat.name} is read only on Google Drive, so changes to it are not written back.`, {
+                title: "Google Drive",
+                quietKey: "quietDriveReadOnly",
+            });
+        }
         return ssd;
     } catch (error) {
         console.error("Google Drive loading error:", error);
@@ -2681,6 +2718,8 @@ electron({
         "hard-reset": hardReset,
         "save-state": () => document.getElementById("save-state").click(),
         rewind: () => rewindUI.open(),
+        pause: pauseIntoDebugger,
+        resume: resumeFromDebugger,
     },
 });
 

package/src/resampler.js

@@ -0,0 +1,92 @@
+function besselI0(x) {
+    let sum = 1;
+    let term = 1;
+    for (let k = 1; k < 50; ++k) {
+        term *= (x / (2 * k)) ** 2;
+        sum += term;
+        if (term < sum * 1e-12) break;
+    }
+    return sum;
+}
+
+/**
+ * Rate conversion by a Kaiser-windowed sinc evaluated only where an output
+ * sample falls, so the cost scales with the output rate, not the input rate.
+ * The kernel is tabulated at `phases` fractional offsets and interpolated
+ * between them. Each quantum the caller reserves room for its input, renders
+ * into `buffer` at `inputOffset`, reads the output with `read`, then calls
+ * `commit` to carry the last `taps` input samples over as the next quantum's
+ * history. Nothing is allocated once the buffer has reached its working size.
+ */
+export class PolyphaseResampler {
+    constructor(inputRate, cutoffHz, { taps = 201, phases = 64, beta = 8.5 } = {}) {
+        this.taps = taps;
+        this.phases = phases;
+        this.half = (taps - 1) / 2;
+        this.table = new Float32Array((phases + 1) * taps);
+        const scale = (2 * cutoffHz) / inputRate;
+        const norm = besselI0(beta);
+        for (let p = 0; p <= phases; ++p) {
+            const row = p * taps;
+            let sum = 0;
+            for (let k = 0; k < taps; ++k) {
+                const t = k - this.half - p / phases;
+                const x = Math.PI * scale * t;
+                const sinc = x === 0 ? 1 : Math.sin(x) / x;
+                const u = t / (this.half + 1);
+                const window = u <= -1 || u >= 1 ? 0 : besselI0(beta * Math.sqrt(1 - u * u)) / norm;
+                this.table[row + k] = scale * sinc * window;
+                sum += this.table[row + k];
+            }
+            for (let k = 0; k < taps; ++k) this.table[row + k] /= sum;
+        }
+        this.buffer = new Float32Array(taps);
+        this.newSamples = 0;
+    }
+
+    /** Make room for `count` new input samples after the history. */
+    reserve(count) {
+        const needed = this.taps + count + 1;
+        if (this.buffer.length < needed) {
+            const grown = new Float32Array(needed * 2);
+            grown.set(this.buffer.subarray(0, this.taps));
+            this.buffer = grown;
+        }
+        this.newSamples = count;
+    }
+
+    get inputOffset() {
+        return this.taps;
+    }
+
+    /**
+     * Fill `out` with samples taken `ratio` input samples apart, the first at
+     * `phase` (0 to 1) past the last sample of the previous quantum. The
+     * output lags the input by `half` samples, which the kernel needs ahead.
+     */
+    read(out, phase, ratio) {
+        const { buffer, table, taps, phases } = this;
+        for (let i = 0; i < out.length; ++i) {
+            const pos = phase + i * ratio;
+            const loc = Math.floor(pos);
+            const fracPhase = (pos - loc) * phases;
+            const p = Math.min(Math.floor(fracPhase), phases - 1);
+            const mix = fracPhase - p;
+            const rowA = p * taps;
+            const rowB = rowA + taps;
+            let a = 0;
+            let b = 0;
+            for (let k = 0; k < taps; ++k) {
+                const x = buffer[loc + k];
+                a += table[rowA + k] * x;
+                b += table[rowB + k] * x;
+            }
+            out[i] = a + (b - a) * mix;
+        }
+    }
+
+    /** Keep the last `taps` input samples as history for the next quantum. */
+    commit() {
+        this.buffer.copyWithin(0, this.newSamples, this.newSamples + this.taps);
+    }
+}

package/src/tapes.js

@@ -315,6 +315,5 @@ export async function loadTapeFromData(name, data, model) {
         console.log("Detected a UEF tape");
         return new UefTape(stream, model);
     }
-    console.log("Unknown tape format");
-    return null;
+    throw new Error(`${name} is not a UEF or tapefile tape image`);
 }

package/src/video-filters/pal-composite.js

@@ -4,7 +4,7 @@
 //
 // Simulates PAL composite video artifacts by encoding the framebuffer to a
 // composite signal and decoding it back to RGB, mimicking the behavior of
-// connecting a BBC Micro to a PAL television via composite cable.
+// a BBC Micro's UHF-modulated picture on a PAL television.
 //
 // REFERENCES:
 // - John Watkinson's "Engineer's Guide to Decoding & Encoding" (Section 3.4)
@@ -40,7 +40,7 @@ export class PALCompositeFilter {
             uFramebuffer: gl.getUniformLocation(this.program, "uFramebuffer"),
             uResolution: gl.getUniformLocation(this.program, "uResolution"),
             uTexelSize: gl.getUniformLocation(this.program, "uTexelSize"),
-            uFrameCount: gl.getUniformLocation(this.program, "uFrameCount"),
+            uLineBase: gl.getUniformLocation(this.program, "uLineBase"),
         };
     }
 
@@ -55,6 +55,6 @@ export class PALCompositeFilter {
         gl.uniform1i(this.locations.uFramebuffer, 0); // Texture unit 0
         gl.uniform2f(this.locations.uResolution, params.width, params.height);
         gl.uniform2f(this.locations.uTexelSize, 1.0 / params.width, 1.0 / params.height);
-        gl.uniform1f(this.locations.uFrameCount, params.frameCount % 8); // 8-field temporal phase sequence
+        gl.uniform2f(this.locations.uLineBase, params.lineBaseEven, params.lineBaseOdd);
     }
 }

package/src/video-filters/shaders/pal-composite.frag.glsl

@@ -5,23 +5,21 @@ varying vec2 vTexCoord;
 uniform sampler2D uFramebuffer;
 uniform vec2 uResolution;
 uniform vec2 uTexelSize;
-uniform float uFrameCount;
+// Line numbers of texture rows 0 (x) and 1 (y)
+uniform vec2 uLineBase;
 
 const float PI = 3.14159265359;
 
 // IMPLEMENTATION (Baseband Blending Method):
 // 1. Encode RGB to PAL composite: Y + U*sin(ωt) + V*cos(ωt)*v_switch
 // 2. Demodulate current line (with correct phase) → U_curr, V_curr
-// 3. Demodulate previous line (2H for interlaced, same field) → U_prev, V_prev
+// 3. Demodulate the previous scanline (two texture rows up) → U_prev, V_prev
 // 4. Blend at baseband: U_final = mix(U_curr, U_prev), V_final = mix(V_curr, V_prev)
-// 5. Remodulate blended chroma back to composite frequency
-// 6. Extract luma via complementary subtraction: Y = composite - remodulated_chroma
-// 7. Combine luma and chroma, convert back to RGB
+// 5. Luma: composite through the set's low-pass and subcarrier trap
+// 6. Combine luma and chroma, convert back to RGB
 //
-// NOTE: Uses 2H delay (line-2) not 1H (line-1) because jsbeeb simulates interlacing by
-// rendering only odd or even lines per frame. A real PAL TV's 1H delay line would contain
-// the previous scanline from the SAME field, which is 2 texture lines apart. Proper
-// support for non-interlaced modes needs to be added.
+// NOTE: Texture rows are half-lines, so the previous scanline of the same field is two rows
+// up, and the subcarrier phase and V-switch come from uLineBase, not from the row.
 
 // Chroma demodulation gain: compensates for sin²(x) = 0.5 - 0.5·cos(2x) amplitude loss
 const float FIR_GAIN = 2.0;
@@ -35,13 +33,9 @@ const float PAL_FRAME_RATE = 25.0;           // Frames per second
 const float PAL_SUBCARRIER_MHZ = 4.43361875; // PAL color subcarrier frequency (exact)
 
 // Derived PAL parameters
-const float PAL_LINES_PER_FIELD = PAL_TOTAL_LINES / 2.0;
 const float PAL_CYCLES_PER_LINE = PAL_SUBCARRIER_MHZ * 1e6 / (PAL_TOTAL_LINES * PAL_FRAME_RATE);
-const float PAL_LINE_PHASE_OFFSET = fract(PAL_CYCLES_PER_LINE);
-const float PAL_FIELD_PHASE_OFFSET = PAL_LINE_PHASE_OFFSET * PAL_LINES_PER_FIELD;
-
-// jsbeeb texture parameters
-const float TEXTURE_WIDTH = 1024.0;          // Framebuffer width (896 visible + 128 blanking)
+// fract(PAL_CYCLES_PER_LINE), spelt out: float keeps more of it alone than inside 283.7516
+const float PAL_LINE_PHASE_OFFSET = 0.7516;
 
 // RGB → YUV conversion with proper PAL signal levels baked in
 // Derived from ITU-R BT.470-6: white at 0.7V, peak at 0.931V
@@ -63,45 +57,58 @@ vec3 yuv_to_rgb(vec3 yuv) {
     );
 }
 
-// Demodulate composite signal at given position
-vec2 demodulate_uv(vec2 xy, float pixel_x, float offset_pixels, float v_switch, float cycles_per_pixel, float phase_offset) {
-    float t = ((pixel_x + offset_pixels) * cycles_per_pixel + phase_offset) * 2.0 * PI;
+// Subcarrier phase (radians) at offset_pixels from pixel_x
+float carrier_phase(float pixel_x, float offset_pixels, float cycles_per_pixel, float phase_offset) {
+    return ((pixel_x + offset_pixels) * cycles_per_pixel + phase_offset) * 2.0 * PI;
+}
 
+// Encode the texel at offset_pixels from xy to composite: Y + U*sin(ωt) + V*cos(ωt)*v_switch
+float encode_composite(vec2 xy, float offset_pixels, float t, float v_switch) {
     vec2 sample_uv = xy + vec2(offset_pixels * uTexelSize.x, 0.0);
     vec3 rgb = texture2D(uFramebuffer, sample_uv).rgb;
     vec3 yuv = rgb_to_yuv(rgb);
+    return yuv.x + yuv.y * sin(t) + yuv.z * cos(t) * v_switch;
+}
 
-    // Encode to composite: Y + U*sin(ωt) + V*cos(ωt)*v_switch
-    float composite = yuv.x + yuv.y * sin(t) + yuv.z * cos(t) * v_switch;
+// Demodulate composite signal at given position
+vec2 demodulate_uv(vec2 xy, float pixel_x, float offset_pixels, float v_switch, float cycles_per_pixel, float phase_offset) {
+    float t = carrier_phase(pixel_x, offset_pixels, cycles_per_pixel, phase_offset);
+    float composite = encode_composite(xy, offset_pixels, t, v_switch);
 
     // Demodulate: multiply by carrier to shift chroma to baseband
     return vec2(composite * sin(t), composite * cos(t) * v_switch);
 }
 
 void main() {
-    // Use gl_FragCoord for pixel coordinates - it's hardware-provided and avoids interpolation artifacts
-    vec2 pixelCoord = vec2(gl_FragCoord.x, uResolution.y - gl_FragCoord.y);
+    // Texel column and row, whatever size the drawing buffer is.
+    vec2 pixelCoord = floor(vTexCoord * uResolution);
 
     // BEGIN_FIR_COEFFICIENTS
     // This section is replaced by the Vite build to include FIR filter coefficients.
     // Change Cutoff (in comment below) or FIRTAPS value to configure.
-    // Cutoff: 1.108 MHz (quarter subcarrier)
+    // Cutoff: 1.108 MHz (quarter subcarrier; the -6 dB design point, -3 dB at about 0.83 MHz)
     const int FIRTAPS = 21;
     float FIR[FIRTAPS];
     // END_FIR_COEFFICIENTS
 
-    float line = floor(pixelCoord.y);
+    // BEGIN_LUMA_COEFFICIENTS
+    // This section is replaced by the Vite build with the set's luma path, low-pass and
+    // subcarrier trap in one symmetric FIR, as designed in tools/luma-fir-generator.js.
+    const int LUMA_TAPS = 31;
+    float LUMA_FIR[LUMA_TAPS];
+    // END_LUMA_COEFFICIENTS
+
+    float row = pixelCoord.y;
+    float line = (mod(row, 2.0) < 1.0 ? uLineBase.x : uLineBase.y) + floor(row / 2.0);
 
     // PAL phase alternates each scanline (V component inverts)
     float v_switch = mod(line, 2.0) < 1.0 ? 1.0 : -1.0;
 
-    // Map PAL subcarrier across texture width
-    float cycles_per_pixel = PAL_CYCLES_PER_LINE / TEXTURE_WIDTH;
+    // Map PAL subcarrier across the full line, blanking included
+    float cycles_per_pixel = PAL_CYCLES_PER_LINE / uResolution.x;
 
-    // PAL temporal phase (8-field sequence creates animated dot crawl)
-    float line_phase_offset = line * PAL_LINE_PHASE_OFFSET;
-    float frame_phase_offset = uFrameCount * PAL_FIELD_PHASE_OFFSET;
-    float phase_offset = line_phase_offset + frame_phase_offset;
+    // Subcarrier phase at the start of this line, carried across frames by the line count
+    float phase_offset = fract(line * PAL_LINE_PHASE_OFFSET);
 
     // Step 1: Demodulate current line with FIR filter
     vec2 filtered_uv_curr = vec2(0.0);
@@ -111,14 +118,11 @@ void main() {
         filtered_uv_curr += FIR_GAIN * uv * FIR[i];
     }
 
-    // Step 2: Demodulate previous line (2H for interlaced, same field) with FIR filter
-    // In interlaced mode, only odd OR even lines are rendered per frame.
-    // Using 2H (line-2) ensures we sample from the same field (both fresh data).
-    // This represents the TV's 1H delay within a single field.
+    // Step 2: Demodulate the previous scanline of the same field (two rows up, one line
+    // earlier) with FIR filter. This represents the TV's 1H delay line.
     vec2 prev_uv = vTexCoord - vec2(0.0, 2.0 * uTexelSize.y);
-    float prev_line = line - 2.0;
-    float prev_v_switch = v_switch * -1.0;
-    float prev_phase_offset = prev_line * PAL_LINE_PHASE_OFFSET + frame_phase_offset;
+    float prev_v_switch = -v_switch;
+    float prev_phase_offset = fract((line - 1.0) * PAL_LINE_PHASE_OFFSET);
 
     vec2 filtered_uv_prev = vec2(0.0);
     for (int i = 0; i < FIRTAPS; i++) {
@@ -130,17 +134,13 @@ void main() {
     // Step 3: Blend chroma at baseband
     vec2 filtered_uv = mix(filtered_uv_curr, filtered_uv_prev, CHROMA_BLEND_WEIGHT);
 
-    // Step 4: Get luma via complementary subtraction
-    float t_curr = (pixelCoord.x * cycles_per_pixel + phase_offset) * 2.0 * PI;
-    vec3 rgb_curr = texture2D(uFramebuffer, vTexCoord).rgb;
-    vec3 yuv_curr = rgb_to_yuv(rgb_curr);
-    float composite_curr = yuv_curr.x + yuv_curr.y * sin(t_curr) + yuv_curr.z * cos(t_curr) * v_switch;
-
-    // Remodulate blended chroma back to composite frequency
-    float remodulated_chroma = filtered_uv.x * sin(t_curr) + filtered_uv.y * cos(t_curr) * v_switch;
-
-    // Complementary subtraction: luma = composite - chroma
-    float y_out = composite_curr - remodulated_chroma;
+    // Step 4: Luma is the composite through the set's low-pass and subcarrier trap
+    float y_out = 0.0;
+    for (int i = 0; i < LUMA_TAPS; i++) {
+        float offset = float(i - (LUMA_TAPS - 1) / 2);
+        float t = carrier_phase(pixelCoord.x, offset, cycles_per_pixel, phase_offset);
+        y_out += encode_composite(vTexCoord, offset, t, v_switch) * LUMA_FIR[i];
+    }
 
     vec3 rgb_out = yuv_to_rgb(vec3(y_out, filtered_uv.x, filtered_uv.y));
     gl_FragColor = vec4(clamp(rgb_out, 0.0, 1.0), 1.0);

package/src/video.js

@@ -19,6 +19,10 @@ export const OPAQUE_WHITE = 0xffffffff;
 
 export const MinPaintedFrameRows = 64;
 
+// The PAL subcarrier advances 283.7516 cycles per line (4433618.75 Hz / 15625 Hz), and
+// 0.7516 = 1879 / 2500, so its phase against the line is periodic in 2500 lines.
+export const PalPhasePeriodLines = 2500;
+
 ////////////////////
 // VideoNULA - programmable 12-bit RGB palette extension (RobC hardware mod).
 // Reference: b-em src/video.c (stardot/b-em).
@@ -348,6 +352,11 @@ export class Video {
         this.bitmapY = 0;
         this.oddClock = false;
         this.frameCount = 0;
+        this.hsyncCount = 0;
+        // The hsyncCount in effect while framebuffer rows 0 and 1 were drawn: row r was drawn
+        // during line lineBase[r & 1] + (r >> 1), which sets its PAL subcarrier phase.
+        this.lineBaseEven = 0;
+        this.lineBaseOdd = 0;
         this.doEvenFrameLogic = false;
         this.isEvenRender = true;
         this.lastRenderWasEven = false;
@@ -460,6 +469,9 @@ export class Video {
             bitmapY: this.bitmapY,
             oddClock: this.oddClock,
             frameCount: this.frameCount,
+            hsyncCount: this.hsyncCount,
+            lineBaseEven: this.lineBaseEven,
+            lineBaseOdd: this.lineBaseOdd,
             doEvenFrameLogic: this.doEvenFrameLogic,
             isEvenRender: this.isEvenRender,
             lastRenderWasEven: this.lastRenderWasEven,
@@ -512,6 +524,9 @@ export class Video {
         this.bitmapY = state.bitmapY;
         this.oddClock = state.oddClock;
         this.frameCount = state.frameCount;
+        this.hsyncCount = state.hsyncCount ?? 0;
+        this.lineBaseEven = state.lineBaseEven ?? 0;
+        this.lineBaseOdd = state.lineBaseOdd ?? 0;
         this.doEvenFrameLogic = state.doEvenFrameLogic;
         this.isEvenRender = state.isEvenRender;
         this.lastRenderWasEven = state.lastRenderWasEven;
@@ -606,13 +621,26 @@ export class Video {
         this.dispEnabled |= enable;
         this.cursorInvertedOffset = -1;
 
-        this.bitmapY = 0;
         // Interlace even frame fires vsync midway through a scanline.
-        if (!!(this.regs[8] & 1) && !!(this.frameCount & 1)) {
-            this.bitmapY = -1;
+        const oddField = !!(this.regs[8] & 1) && !!(this.frameCount & 1);
+        this.bitmapY = oddField ? -1 : 0;
+
+        // The even field draws the rest of the vsync line on row 0; the odd field's first row
+        // is the first hsync after it.
+        const firstRowLine = (this.hsyncCount + (oddField ? 1 : 0)) % PalPhasePeriodLines;
+        if (this.doublesLines()) {
+            this.lineBaseEven = this.lineBaseOdd = firstRowLine;
+        } else if (oddField) {
+            this.lineBaseOdd = firstRowLine;
+        } else {
+            this.lineBaseEven = firstRowLine;
         }
     }
 
+    doublesLines() {
+        return (this.doubledScanlines && !this.interlacedSyncAndVideo) || this.isEvenRender === this.lastRenderWasEven;
+    }
+
     debugOffset(x, y) {
         if (x < 0 || x >= 1024) return -1;
         if (y < 0 || y >= 768) return -1;
@@ -715,9 +743,7 @@ export class Video {
         if (!this.halfClock || !this.oddClock) return;
         if ((this.dispEnabled & EVERYTHINGENABLED) !== EVERYTHINGENABLED) return;
         if (this.bitmapX < 0 || this.bitmapX >= 1024 || this.bitmapY < 0 || this.bitmapY >= 625) return;
-        // The same line doubling decision as the render loop, which inlines it for speed.
-        const doubledLines =
-            (this.doubledScanlines && !this.interlacedSyncAndVideo) || this.isEvenRender === this.lastRenderWasEven;
+        const doubledLines = this.doublesLines();
         const bitmapRow = doubledLines ? this.bitmapY & ~1 : this.bitmapY;
         const offset = bitmapRow * 1024 + this.bitmapX;
         const halfCell = this.pixelsPerChar >>> 1;
@@ -903,6 +929,7 @@ export class Video {
             // The CRT vertical beam speed is constant, so this is actually
             // an approximation that works if hsyncs are spaced evenly.
             this.bitmapY += 2;
+            this.hsyncCount = (this.hsyncCount + 1) % PalPhasePeriodLines;
 
             // Arbitrary moment when TV will give up and start flyback in the absence of an explicit VSync signal
             return this.bitmapY >= 768;
@@ -1064,7 +1091,8 @@ export class Video {
                     // There's a painting subtlety here: if we're in an
                     // interlace mode but R6>R4 then we'll get stuck
                     // painting just an odd or even frame, so we double up
-                    // scanlines to avoid a ghost half frame.
+                    // scanlines to avoid a ghost half frame. This is
+                    // doublesLines(), inlined for speed.
                     if (
                         (this.doubledScanlines && !this.interlacedSyncAndVideo) ||
                         this.isEvenRender === this.lastRenderWasEven

package/src/web/audio-handler.js

@@ -62,7 +62,7 @@ export class AudioHandler {
             this.masterGain.connect(this.audioContext.destination);
             this.ddNoise = noSeek ? new FakeDdNoise() : new DdNoise(this.audioContext, this.masterGain);
             this.relayNoise = new RelayNoise(this.audioContext, this.masterGain);
-            this._setup(audioFilterFreq, audioFilterQ).catch((error) => this._audioUnavailable(error));
+            this._setup({ audioFilterFreq, audioFilterQ }).catch((error) => this._audioUnavailable(error));
         } else {
             if (this.audioContext && !this.audioContext.audioWorklet) {
                 this.audioContext = null;
@@ -127,27 +127,18 @@ export class AudioHandler {
         this.chart.streamTo(statsNode, 100);
     }
 
-    async _setup(audioFilterFreq, audioFilterQ) {
+    async _setup({ audioFilterFreq, audioFilterQ }) {
         await this.audioContext.audioWorklet.addModule(rendererUrl);
-        if (audioFilterFreq !== 0) {
-            const filterNode = this.audioContext.createBiquadFilter();
-            filterNode.type = "lowpass";
-            filterNode.frequency.value = audioFilterFreq;
-            filterNode.Q.value = audioFilterQ;
-            this._audioDestination = filterNode;
-            filterNode.connect(this.audioContext.destination);
-        } else {
-            this._audioDestination = this.audioContext.destination;
-        }
-
         this._jsAudioNode = new AudioWorkletNode(this.audioContext, "sound-chip-processor", {
             processorOptions: {
                 targetLatencyMs: this._targetLatencyMs(),
                 isAtom: this.isAtom,
                 cpuSpeed: this.cpuSpeed,
+                audioFilterFreq,
+                audioFilterQ,
             },
         });
-        this._jsAudioNode.connect(this._audioDestination);
+        this._jsAudioNode.connect(this.audioContext.destination);
         this._jsAudioNode.port.onmessage = (event) => {
             const now = Date.now();
             if (event.data.event) {

package/src/web/audio-renderer.js

@@ -1,8 +1,20 @@
 /* global sampleRate, currentTime, registerProcessor, AudioWorkletProcessor */
 import { SoundChip, AtomSoundChip } from "../soundchip.js";
-
-const lowPassFilterFreq = sampleRate / 2;
-const RC = 1 / (2 * Math.PI * lowPassFilterFreq);
+import { LowPassBiquad } from "../biquad.js";
+import { PolyphaseResampler } from "../resampler.js";
+
+// The board's output filter is an equal-component Sallen-Key (Service Manual
+// section 3.8: 10K and 2n2 twice, gain K = 1 + 22/39): f0 = 1/(2*pi*RC) = 7234 Hz,
+// Q = 1/(3 - K) = 0.696, below 1/sqrt(2), so no resonant peak. Run at the chip
+// rate, ahead of the resampler.
+const OutputFilterHz = 7234;
+const OutputFilterQ = 0.696;
+
+// The resampler's sinc is cut off below the output Nyquist so that its
+// transition band has finished before anything folds; sampled sound rides on
+// a 31 kHz or higher carrier that would otherwise land in the audible band.
+const ResamplerCutoffOfOutputRate = 0.4;
+const ResamplerTaps = 201;
 
 const DefaultTargetLatencyMs = 1000 * (1 / 50); // One frame
 const MaxTargetLatencyMs = 250;
@@ -22,10 +34,20 @@ const isResync = (event) => event.state !== undefined || event.reset !== undefin
 class SoundChipProcessor extends AudioWorkletProcessor {
     constructor(options) {
         super(options);
-        const { isAtom = false, cpuSpeed = 1000000, targetLatencyMs } = options?.processorOptions ?? {};
+        const {
+            isAtom = false,
+            cpuSpeed = 1000000,
+            targetLatencyMs,
+            audioFilterFreq,
+            audioFilterQ,
+        } = options?.processorOptions ?? {};
         this.chip = isAtom ? new AtomSoundChip(null, { cpuSpeed }) : new SoundChip(null);
         this.inputSampleRate = this.chip.soundchipFreq;
         this.samplesPerCycle = this.chip.samplesPerCycle;
+        this.outputFilter = this._makeOutputFilter(audioFilterFreq, audioFilterQ);
+        this.resampler = new PolyphaseResampler(this.inputSampleRate, ResamplerCutoffOfOutputRate * sampleRate, {
+            taps: ResamplerTaps,
+        });
 
         this.events = [];
         this.eventsHead = 0;
@@ -36,10 +58,7 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         this.skippedMs = 0;
         this.minLeadMs = Infinity;
 
-        this._lastFilteredOutput = 0;
         this._phase = 0;
-        this._source = new Float32Array(0);
-        this._rendered = new Float32Array(0);
         this.smoothedLeadError = 0;
         this.setTargetLatency(targetLatencyMs);
         this.port.onmessage = (event) => {
@@ -49,6 +68,15 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         this.nextStats = 0;
     }
 
+    // Zero turns it off; a setting the biquad cannot realise (non-finite, at or
+    // above Nyquist, non-positive Q) falls back to the board's own values.
+    _makeOutputFilter(frequency = OutputFilterHz, q = OutputFilterQ) {
+        if (frequency <= 0) return null;
+        const usable = frequency < this.inputSampleRate / 2 && q > 0;
+        if (!usable) return new LowPassBiquad(this.inputSampleRate, OutputFilterHz, OutputFilterQ);
+        return new LowPassBiquad(this.inputSampleRate, frequency, q);
+    }
+
     setTargetLatency(ms) {
         const valid = Number.isFinite(ms) && ms > 0;
         this.targetLatencyMs = valid ? Math.min(ms, MaxTargetLatencyMs) : DefaultTargetLatencyMs;
@@ -157,12 +185,11 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         return Math.floor((boundary - this.clock) * this.samplesPerCycle);
     }
 
-    _renderInput(out, length) {
+    _renderInput(out, offset, length) {
         if (this.stalled) {
-            this._stall(out, 0, length);
+            this._stall(out, offset, length);
             return;
         }
-        let offset = 0;
         while (length > 0) {
             const n = Math.min(length, this._samplesUntilNextChange());
             if (n > 0) {
@@ -189,34 +216,17 @@ class SoundChipProcessor extends AudioWorkletProcessor {
         const effectiveSampleRate = this._effectiveSampleRate(channel.length / sampleRate);
         const sampleRatio = effectiveSampleRate / sampleRate;
 
-        const dt = 1 / effectiveSampleRate;
-        const filterAlpha = dt / (RC + dt);
-
         // The fractional read position carries across quanta, so consumption
         // averages exactly sampleRatio and the pitch never steps at a rounding
-        // boundary. source[0] is the last input sample of the previous quantum.
+        // boundary.
         const end = this._phase + channel.length * sampleRatio;
         const numInputSamples = Math.floor(end);
-        if (this._source.length <= numInputSamples) {
-            this._source = new Float32Array(numInputSamples * 2);
-            this._rendered = new Float32Array(numInputSamples * 2);
-        }
-        const source = this._source;
-        const rendered = this._rendered;
-        this._renderInput(rendered, numInputSamples);
-        source[0] = this._lastFilteredOutput;
-        let prevSample = this._lastFilteredOutput;
-        for (let i = 1; i <= numInputSamples; ++i) {
-            prevSample += filterAlpha * (rendered[i - 1] - prevSample);
-            source[i] = prevSample;
-        }
-        this._lastFilteredOutput = prevSample;
-        for (let i = 0; i < channel.length; i++) {
-            const pos = this._phase + i * sampleRatio;
-            const loc = Math.floor(pos);
-            const alpha = pos - loc;
-            channel[i] = source[loc] * (1 - alpha) + source[loc + 1] * alpha;
-        }
+        const resampler = this.resampler;
+        resampler.reserve(numInputSamples);
+        this._renderInput(resampler.buffer, resampler.inputOffset, numInputSamples);
+        this.outputFilter?.process(resampler.buffer, resampler.inputOffset, numInputSamples);
+        resampler.read(channel, this._phase, sampleRatio);
+        resampler.commit();
         this._phase = end - numInputSamples;
         this.minLeadMs = Math.min(this.minLeadMs, this.leadMs());
         this.stats(sampleRatio);