@tmustier/pi-nes 0.2.25 → 0.2.26

package/README.md

@@ -20,7 +20,7 @@ pi install git:github.com/tmustier/pi-nes
 /nes ~/roms/smb.nes   # Load a specific ROM
 ```
 
-On first run, you'll be prompted to set your ROM directory and display quality.
+On first run, you'll be prompted to set your ROM directory and display quality. When launching `/nes` without a path, type to filter the ROM list while you navigate.
 
 ## Controls
 
@@ -62,6 +62,7 @@ Config is stored at `~/.pi/nes/config.json`. Use `/nes config` for quick setup.
   "saveDir": "/roms/nes/saves",
   "renderer": "image",
   "imageQuality": "balanced",
+  "videoFilter": "off",
   "pixelScale": 1.0,
   "keybindings": {
     "up": ["up", "w"],
@@ -84,8 +85,11 @@ Config is stored at `~/.pi/nes/config.json`. Use `/nes config` for quick setup.
 | `saveDir` | `/roms/nes/saves` | Where to store battery saves (defaults to `<romDir>/saves`) |
 | `renderer` | `"image"` | `"image"` (Kitty graphics) or `"text"` (ANSI) |
 | `imageQuality` | `"balanced"` | `"balanced"` (30 fps) or `"high"` (60 fps) |
+| `videoFilter` | `"off"` | `"off"`, `"ntsc-composite"`, `"ntsc-svideo"`, `"ntsc-rgb"` |
 | `pixelScale` | `1.0` | Display scale (0.5–4.0) |
 
+`videoFilter` applies a lightweight CRT/NTSC-inspired pass (horizontal bleed + scanlines). It runs in the native core and is optional.
+
 ## Saves
 
 Battery-backed SRAM is saved to `<saveDir>/<rom-name>-<hash>.sav` where the hash is derived from the full ROM path to avoid collisions. Old `<rom-name>.sav` files are ignored.

package/extensions/nes/config.ts

@@ -6,6 +6,7 @@ import { normalizePath } from "./paths.js";
 
 export type RendererMode = "image" | "text";
 export type ImageQuality = "balanced" | "high";
+export type VideoFilter = "off" | "ntsc-composite" | "ntsc-svideo" | "ntsc-rgb";
 
 export interface NesConfig {
 	romDir: string;
@@ -13,6 +14,7 @@ export interface NesConfig {
 	enableAudio: boolean;
 	renderer: RendererMode;
 	imageQuality: ImageQuality;
+	videoFilter: VideoFilter;
 	pixelScale: number;
 	keybindings: InputMapping;
 }
@@ -29,6 +31,7 @@ export const DEFAULT_CONFIG: NesConfig = {
 	enableAudio: false,
 	renderer: "image",
 	imageQuality: "balanced",
+	videoFilter: "off",
 	pixelScale: 1.0,
 	keybindings: cloneMapping(DEFAULT_INPUT_MAPPING),
 };
@@ -39,6 +42,7 @@ interface RawConfig {
 	enableAudio?: unknown;
 	renderer?: unknown;
 	imageQuality?: unknown;
+	videoFilter?: unknown;
 	pixelScale?: unknown;
 	keybindings?: unknown;
 }
@@ -68,6 +72,7 @@ export function normalizeConfig(raw: unknown): NesConfig {
 			: saveDirFallback;
 	const saveDir = resolveConfigPath(normalizePath(saveDirInput, saveDirFallback));
 	const imageQuality = normalizeImageQuality(parsed.imageQuality);
+	const videoFilter = normalizeVideoFilter(parsed.videoFilter);
 	const pixelScale = normalizePixelScale(parsed.pixelScale);
 	return {
 		romDir,
@@ -75,6 +80,7 @@ export function normalizeConfig(raw: unknown): NesConfig {
 		enableAudio: typeof parsed.enableAudio === "boolean" ? parsed.enableAudio : DEFAULT_CONFIG.enableAudio,
 		renderer: parsed.renderer === "text" ? "text" : DEFAULT_CONFIG.renderer,
 		imageQuality,
+		videoFilter,
 		pixelScale,
 		keybindings: normalizeKeybindings(parsed.keybindings),
 	};
@@ -136,6 +142,17 @@ function normalizeImageQuality(raw: unknown): ImageQuality {
 	return raw === "high" ? "high" : "balanced";
 }
 
+function normalizeVideoFilter(raw: unknown): VideoFilter {
+	switch (raw) {
+		case "ntsc-composite":
+		case "ntsc-svideo":
+		case "ntsc-rgb":
+			return raw;
+		default:
+			return "off";
+	}
+}
+
 function normalizeKeybindings(raw: unknown): InputMapping {
 	const mapping = cloneMapping(DEFAULT_INPUT_MAPPING);
 	if (!raw || typeof raw !== "object") {

package/extensions/nes/index.ts

@@ -12,10 +12,12 @@ import {
 	loadConfig,
 	normalizeConfig,
 	saveConfig,
+	type VideoFilter,
 } from "./config.js";
 import { displayPath, resolvePathInput } from "./paths.js";
 import { NesSession } from "./nes-session.js";
 import { listRoms } from "./roms.js";
+import { selectRomWithFilter } from "./rom-selector.js";
 import { loadSram } from "./saves.js";
 
 const IMAGE_RENDER_INTERVAL_BALANCED_MS = 1000 / 30;
@@ -44,17 +46,8 @@ async function selectRom(
 			return null;
 		}
 
-		const options = roms.map((rom, index) => `${index + 1}. ${rom.name}`);
-		const selection = await ctx.ui.select("Select a ROM", options);
-		if (!selection) {
-			return null;
-		}
-		const index = options.indexOf(selection);
-		if (index < 0) {
-			ctx.ui.notify("ROM selection failed. Please try again.", "error");
-			return null;
-		}
-		return roms[index]?.path ?? null;
+		const selection = await selectRomWithFilter(ctx, roms);
+		return selection;
 	} catch {
 		ctx.ui.notify(`Failed to read ROM directory: ${romDir}. Update ${configPath} to set romDir.`, "error");
 		return null;
@@ -177,6 +170,21 @@ async function configureWithWizard(
 
 	const isHighQuality = qualityChoice.startsWith("High");
 	const imageQuality = isHighQuality ? "high" : "balanced";
+
+	const filterOptions: Array<{ label: string; value: VideoFilter }> = [
+		{ label: "Off (default) — raw RGB", value: "off" },
+		{ label: "NTSC Composite — strong bleed + scanlines", value: "ntsc-composite" },
+		{ label: "NTSC S-Video — balanced bleed", value: "ntsc-svideo" },
+		{ label: "NTSC RGB — subtle blur", value: "ntsc-rgb" },
+	];
+	const filterChoice = await ctx.ui.select(
+		"Video filter",
+		filterOptions.map((option) => option.label),
+	);
+	if (!filterChoice) {
+		return false;
+	}
+	const videoFilter = filterOptions.find((option) => option.label === filterChoice)?.value ?? "off";
 	const pixelScale = config.pixelScale;
 
 	const defaultSaveDir = getDefaultSaveDir(config.romDir);
@@ -187,6 +195,7 @@ async function configureWithWizard(
 		romDir,
 		saveDir,
 		imageQuality,
+		videoFilter,
 		pixelScale,
 	});
 	await saveConfig(normalized);
@@ -237,7 +246,7 @@ async function createSession(romPath: string, ctx: ExtensionCommandContext, conf
 
 	let core;
 	try {
-		core = createNesCore({ enableAudio: config.enableAudio });
+		core = createNesCore({ enableAudio: config.enableAudio, videoFilter: config.videoFilter });
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		ctx.ui.notify(`Failed to initialize NES core: ${message}`, "error");

package/extensions/nes/native/nes-core/index.d.ts

@@ -31,6 +31,7 @@ export class NativeNes {
   bootup(): void;
   stepFrame(): void;
   refreshFramebuffer(): void;
+  setVideoFilter(mode: number): void;
   pressButton(button: number): void;
   releaseButton(button: number): void;
   hasBatteryBackedRam(): boolean;

package/extensions/nes/native/nes-core/native.d.ts

@@ -33,6 +33,7 @@ export declare class NativeNes {
   bootup(): void
   stepFrame(): void
   refreshFramebuffer(): void
+  setVideoFilter(mode: number): void
   pressButton(button: number): void
   releaseButton(button: number): void
   hasBatteryBackedRam(): boolean

package/extensions/nes/native/nes-core/src/lib.rs

@@ -7,6 +7,23 @@ use nes_rust::display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH};
 use nes_rust::rom::Rom;
 use nes_rust::Nes;
 
+const FRAME_BYTE_LEN: usize = (SCREEN_WIDTH * SCREEN_HEIGHT * 3) as usize;
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum VideoFilterMode {
+	Off,
+	NtscComposite,
+	NtscSvideo,
+	NtscRgb,
+}
+
+struct VideoFilterConfig {
+	luma: [f32; 3],
+	chroma: [f32; 3],
+	scanline_dim: f32,
+	chroma_gain: f32,
+}
+
 struct NativeDisplay {
 	pixels: Vec<u8>,
 }
@@ -14,7 +31,7 @@ struct NativeDisplay {
 impl NativeDisplay {
 	fn new() -> Self {
 		Self {
-			pixels: vec![0; (SCREEN_WIDTH * SCREEN_HEIGHT * 3) as usize],
+			pixels: vec![0; FRAME_BYTE_LEN],
 		}
 	}
 }
@@ -77,6 +94,8 @@ pub struct NesDebugState {
 pub struct NativeNes {
 	nes: Nes,
 	framebuffer: Vec<u8>,
+	filter_buffer: Vec<u8>,
+	video_filter: VideoFilterMode,
 }
 
 #[napi]
@@ -89,7 +108,9 @@ impl NativeNes {
 		let nes = Nes::new(input, display, audio);
 		Self {
 			nes,
-			framebuffer: vec![0; (SCREEN_WIDTH * SCREEN_HEIGHT * 3) as usize],
+			framebuffer: vec![0; FRAME_BYTE_LEN],
+			filter_buffer: vec![0; FRAME_BYTE_LEN],
+			video_filter: VideoFilterMode::Off,
 		}
 	}
 
@@ -112,6 +133,20 @@ impl NativeNes {
 	#[napi]
 	pub fn refresh_framebuffer(&mut self) {
 		self.nes.copy_pixels(&mut self.framebuffer);
+		if let Some(config) = video_filter_config(self.video_filter) {
+			self.filter_buffer.copy_from_slice(&self.framebuffer);
+			apply_video_filter(&self.filter_buffer, &mut self.framebuffer, &config);
+		}
+	}
+
+	#[napi]
+	pub fn set_video_filter(&mut self, mode: u8) {
+		self.video_filter = match mode {
+			1 => VideoFilterMode::NtscComposite,
+			2 => VideoFilterMode::NtscSvideo,
+			3 => VideoFilterMode::NtscRgb,
+			_ => VideoFilterMode::Off,
+		};
 	}
 
 	#[napi]
@@ -201,3 +236,81 @@ fn map_button(button: u8) -> Option<Button> {
 		_ => None,
 	}
 }
+
+fn video_filter_config(mode: VideoFilterMode) -> Option<VideoFilterConfig> {
+	match mode {
+		VideoFilterMode::Off => None,
+		VideoFilterMode::NtscComposite => Some(VideoFilterConfig {
+			luma: [0.2, 0.6, 0.2],
+			chroma: [0.25, 0.5, 0.25],
+			scanline_dim: 0.85,
+			chroma_gain: 0.9,
+		}),
+		VideoFilterMode::NtscSvideo => Some(VideoFilterConfig {
+			luma: [0.15, 0.7, 0.15],
+			chroma: [0.2, 0.6, 0.2],
+			scanline_dim: 0.9,
+			chroma_gain: 0.95,
+		}),
+		VideoFilterMode::NtscRgb => Some(VideoFilterConfig {
+			luma: [0.1, 0.8, 0.1],
+			chroma: [0.1, 0.8, 0.1],
+			scanline_dim: 0.95,
+			chroma_gain: 1.0,
+		}),
+	}
+}
+
+fn apply_video_filter(source: &[u8], target: &mut [u8], config: &VideoFilterConfig) {
+	let width = SCREEN_WIDTH as usize;
+	let height = SCREEN_HEIGHT as usize;
+	if source.len() < FRAME_BYTE_LEN || target.len() < FRAME_BYTE_LEN {
+		return;
+	}
+	for y in 0..height {
+		let scanline = if y % 2 == 0 { 1.0 } else { config.scanline_dim };
+		for x in 0..width {
+			let left_x = if x == 0 { 0 } else { x - 1 };
+			let right_x = if x + 1 >= width { width - 1 } else { x + 1 };
+			let center_x = x;
+
+			let left_idx = (y * width + left_x) * 3;
+			let center_idx = (y * width + center_x) * 3;
+			let right_idx = (y * width + right_x) * 3;
+
+			let (y0, i0, q0) = rgb_to_yiq(source[left_idx], source[left_idx + 1], source[left_idx + 2]);
+			let (y1, i1, q1) = rgb_to_yiq(source[center_idx], source[center_idx + 1], source[center_idx + 2]);
+			let (y2, i2, q2) = rgb_to_yiq(source[right_idx], source[right_idx + 1], source[right_idx + 2]);
+
+			let luma = config.luma[0] * y0 + config.luma[1] * y1 + config.luma[2] * y2;
+			let chroma_i = config.chroma_gain * (config.chroma[0] * i0 + config.chroma[1] * i1 + config.chroma[2] * i2);
+			let chroma_q = config.chroma_gain * (config.chroma[0] * q0 + config.chroma[1] * q1 + config.chroma[2] * q2);
+
+			let (r, g, b) = yiq_to_rgb(luma, chroma_i, chroma_q);
+			target[center_idx] = clamp_u8(r * scanline);
+			target[center_idx + 1] = clamp_u8(g * scanline);
+			target[center_idx + 2] = clamp_u8(b * scanline);
+		}
+	}
+}
+
+fn rgb_to_yiq(r: u8, g: u8, b: u8) -> (f32, f32, f32) {
+	let r = r as f32;
+	let g = g as f32;
+	let b = b as f32;
+	let y = 0.299 * r + 0.587 * g + 0.114 * b;
+	let i = 0.596 * r - 0.274 * g - 0.322 * b;
+	let q = 0.211 * r - 0.523 * g + 0.312 * b;
+	(y, i, q)
+}
+
+fn yiq_to_rgb(y: f32, i: f32, q: f32) -> (f32, f32, f32) {
+	let r = y + 0.956 * i + 0.621 * q;
+	let g = y - 0.272 * i - 0.647 * q;
+	let b = y - 1.106 * i + 1.703 * q;
+	(r, g, b)
+}
+
+fn clamp_u8(value: f32) -> u8 {
+	value.max(0.0).min(255.0).round() as u8
+}

package/extensions/nes/nes-core.ts

@@ -3,6 +3,7 @@ import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 
 export type NesButton = "up" | "down" | "left" | "right" | "a" | "b" | "start" | "select";
+export type VideoFilterMode = "off" | "ntsc-composite" | "ntsc-svideo" | "ntsc-rgb";
 
 export interface FrameBuffer {
 	data: Uint8Array;
@@ -51,6 +52,7 @@ export interface NesCore {
 
 export interface CreateNesCoreOptions {
 	enableAudio?: boolean;
+	videoFilter?: VideoFilterMode;
 }
 
 interface NativeNesInstance {
@@ -58,6 +60,7 @@ interface NativeNesInstance {
 	bootup(): void;
 	stepFrame(): void;
 	refreshFramebuffer(): void;
+	setVideoFilter(mode: number): void;
 	pressButton(button: number): void;
 	releaseButton(button: number): void;
 	hasBatteryBackedRam(): boolean;
@@ -101,13 +104,20 @@ const NATIVE_BUTTON_MAP: Record<NesButton, number> = {
 	right: 7,
 };
 
+const NATIVE_VIDEO_FILTER_MAP: Record<VideoFilterMode, number> = {
+	off: 0,
+	"ntsc-composite": 1,
+	"ntsc-svideo": 2,
+	"ntsc-rgb": 3,
+};
+
 class NativeNesCore implements NesCore {
 	private readonly nes: NativeNesInstance;
 	private readonly audioWarning: string | null;
 	private readonly frameBuffer: Uint8Array;
 	private hasSram = false;
 
-	constructor(enableAudio: boolean) {
+	constructor(enableAudio: boolean, videoFilter: VideoFilterMode) {
 		this.audioWarning = enableAudio
 			? "Audio output is disabled (no safe dependency available)."
 			: null;
@@ -116,6 +126,7 @@ class NativeNesCore implements NesCore {
 			throw new Error("Native NES core addon is not available.");
 		}
 		this.nes = new module.NativeNes();
+		this.nes.setVideoFilter(NATIVE_VIDEO_FILTER_MAP[videoFilter]);
 		this.frameBuffer = this.nes.getFramebuffer();
 	}
 
@@ -186,5 +197,5 @@ class NativeNesCore implements NesCore {
 }
 
 export function createNesCore(options: CreateNesCoreOptions = {}): NesCore {
-	return new NativeNesCore(options.enableAudio ?? false);
+	return new NativeNesCore(options.enableAudio ?? false, options.videoFilter ?? "off");
 }

package/extensions/nes/rom-selector.ts

@@ -0,0 +1,142 @@
+import type { ExtensionCommandContext, Theme } from "@mariozechner/pi-coding-agent";
+import { DynamicBorder, getSelectListTheme } from "@mariozechner/pi-coding-agent";
+import {
+	Container,
+	Input,
+	SelectList,
+	Spacer,
+	Text,
+	TUI,
+	type Component,
+	type Focusable,
+	type SelectItem,
+	getEditorKeybindings,
+} from "@mariozechner/pi-tui";
+import type { RomEntry } from "./roms.js";
+
+const MAX_VISIBLE_ROMS = 10;
+
+class RomSelectorDialog extends Container implements Focusable {
+	private readonly tui: TUI;
+	private readonly theme: Theme;
+	private readonly items: SelectItem[];
+	private readonly filterInput: Input;
+	private listComponent: Component;
+	private selectList: SelectList | null = null;
+	private onSelect: (value: string) => void;
+	private onCancel: () => void;
+	private _focused = false;
+
+	constructor(
+		roms: RomEntry[],
+		tui: TUI,
+		theme: Theme,
+		onSelect: (value: string) => void,
+		onCancel: () => void,
+	) {
+		super();
+		this.tui = tui;
+		this.theme = theme;
+		this.items = roms.map((rom) => ({ value: rom.path, label: rom.name }));
+		this.onSelect = onSelect;
+		this.onCancel = onCancel;
+		this.filterInput = new Input();
+		this.filterInput.setValue("");
+		this.listComponent = new Text("", 0, 0);
+		this.updateList();
+		this.buildLayout();
+	}
+
+	get focused(): boolean {
+		return this._focused;
+	}
+
+	set focused(value: boolean) {
+		this._focused = value;
+		this.filterInput.focused = value;
+	}
+
+	invalidate(): void {
+		super.invalidate();
+		this.buildLayout();
+	}
+
+	handleInput(data: string): void {
+		const kb = getEditorKeybindings();
+		if (
+			kb.matches(data, "selectUp") ||
+			kb.matches(data, "selectDown") ||
+			kb.matches(data, "selectConfirm") ||
+			kb.matches(data, "selectCancel") ||
+			kb.matches(data, "pageUp") ||
+			kb.matches(data, "pageDown")
+		) {
+			if (this.selectList) {
+				this.selectList.handleInput(data);
+			} else if (kb.matches(data, "selectCancel")) {
+				this.onCancel();
+			}
+			this.tui.requestRender();
+			return;
+		}
+
+		const before = this.filterInput.getValue();
+		this.filterInput.handleInput(data);
+		const after = this.filterInput.getValue();
+		if (after !== before) {
+			this.updateList();
+			this.buildLayout();
+		}
+		this.tui.requestRender();
+	}
+
+	private updateList(): void {
+		const filter = this.filterInput.getValue().trim().toLowerCase();
+		const filteredItems = filter.length
+			? this.items.filter((item) => (item.label ?? item.value).toLowerCase().includes(filter))
+			: this.items;
+
+		if (filteredItems.length === 0) {
+			this.selectList = null;
+			this.listComponent = new Text(this.theme.fg("warning", "  No matching ROMs"), 1, 0);
+			return;
+		}
+
+		const list = new SelectList(filteredItems, Math.min(filteredItems.length, MAX_VISIBLE_ROMS), getSelectListTheme());
+		list.onSelect = (item) => this.onSelect(item.value);
+		list.onCancel = () => this.onCancel();
+		this.selectList = list;
+		this.listComponent = list;
+	}
+
+	private buildLayout(): void {
+		this.clear();
+		this.addChild(new DynamicBorder((line) => this.theme.fg("accent", line)));
+		this.addChild(new Text(this.theme.fg("accent", this.theme.bold("Select a ROM")), 1, 0));
+		this.addChild(new Text(this.theme.fg("dim", "Type to filter · ↑↓ navigate · Enter select · Esc cancel"), 1, 0));
+		this.addChild(new Spacer(1));
+		this.addChild(new Text(this.theme.fg("muted", "Filter:"), 1, 0));
+		this.addChild(this.filterInput);
+		this.addChild(new Spacer(1));
+		this.addChild(this.listComponent);
+		this.addChild(new Spacer(1));
+		this.addChild(new DynamicBorder((line) => this.theme.fg("accent", line)));
+	}
+}
+
+export async function selectRomWithFilter(
+	ctx: ExtensionCommandContext,
+	roms: RomEntry[],
+): Promise<string | null> {
+	const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+		const dialog = new RomSelectorDialog(
+			roms,
+			tui,
+			theme,
+			(value) => done(value),
+			() => done(null),
+		);
+		return dialog;
+	});
+	return result ?? null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmustier/pi-nes",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "NES emulator extension for pi",
   "keywords": [
     "pi-package",

package/spec.md

@@ -72,6 +72,7 @@ pi-nes/
   - `enableAudio`
   - `renderer` ("image" or "text")
   - `imageQuality` ("balanced" or "high", controls render fps)
+  - `videoFilter` ("off", "ntsc-composite", "ntsc-svideo", "ntsc-rgb")
   - `pixelScale` (float, e.g. 1.0)
   - `keybindings` (button-to-keys map, e.g. `{ "a": ["z"] }`)
 
@@ -91,5 +92,6 @@ Note: audio output is currently disabled; setting `enableAudio` will show a warn
 - Default ROM dir: `/roms/nes` (configurable).
 - Default core: `native`.
 - Default image quality: `balanced` (30 fps).
+- Default video filter: `off`.
 - Default pixel scale: `1.0`.
 - Default save dir: `/roms/nes/saves` (configurable).

package/tests/config.test.ts

@@ -9,6 +9,7 @@ describe("config", () => {
 			assert.strictEqual(config.enableAudio, DEFAULT_CONFIG.enableAudio);
 			assert.strictEqual(config.renderer, DEFAULT_CONFIG.renderer);
 			assert.strictEqual(config.imageQuality, DEFAULT_CONFIG.imageQuality);
+			assert.strictEqual(config.videoFilter, DEFAULT_CONFIG.videoFilter);
 			assert.strictEqual(config.pixelScale, DEFAULT_CONFIG.pixelScale);
 		});
 
@@ -42,6 +43,16 @@ describe("config", () => {
 			assert.strictEqual(config.imageQuality, "balanced");
 		});
 
+		test("accepts valid videoFilter", () => {
+			const config = normalizeConfig({ videoFilter: "ntsc-composite" });
+			assert.strictEqual(config.videoFilter, "ntsc-composite");
+		});
+
+		test("defaults invalid videoFilter to off", () => {
+			const config = normalizeConfig({ videoFilter: "crt" });
+			assert.strictEqual(config.videoFilter, "off");
+		});
+
 		test("clamps pixelScale to valid range", () => {
 			assert.strictEqual(normalizeConfig({ pixelScale: 0.1 }).pixelScale, 0.5);
 			assert.strictEqual(normalizeConfig({ pixelScale: 10 }).pixelScale, 4);