@tmustier/pi-nes 0.2.3 → 0.2.5

package/extensions/nes/native/nes-core/vendor/nes_rust/src/rom.rs

@@ -0,0 +1,231 @@
+use memory::Memory;
+use mapper::{Mapper, MapperFactory};
+
+pub struct Rom {
+	header: RomHeader,
+	memory: Memory,
+	mapper: Box<dyn Mapper>
+}
+
+pub static HEADER_SIZE: usize = 16;
+
+pub enum Mirrorings {
+	SingleScreen,
+	Horizontal,
+	Vertical,
+	FourScreen
+}
+
+impl Rom {
+	pub fn new(data: Vec<u8>) -> Self {
+		let header = RomHeader::new(data[0..HEADER_SIZE].to_vec());
+		let mapper = MapperFactory::create(&header);
+		Rom {
+			header: header,
+			memory: Memory::new(data[HEADER_SIZE..].to_vec()),
+			mapper: mapper
+		}
+	}
+
+	/**
+	 * CPU memory address:
+	 * 0x0000 - 0x1FFF: Character ROM access
+	 * 0x8000 - 0xFFFF: Program ROM access
+	 *
+	 * To access wide range ROM data with limited CPU memory address space
+	 * Mapper maps CPU memory address to ROM's.
+	 * In general writing control registers in Mapper via .store() switches bank.
+	 */
+	pub fn load(&self, address: u32) -> u8 {
+		let mut address_in_rom = 0 as u32;
+		if address < 0x2000 {
+			// load from character rom
+			address_in_rom += self.header.prg_rom_bank_num() as u32 * 0x4000;
+			address_in_rom += self.mapper.map_for_chr_rom(address);
+		} else {
+			address_in_rom += self.mapper.map(address);
+		}
+		self.memory.load(address_in_rom)
+	}
+
+	pub fn load_without_mapping(&self, address: u32) -> u8 {
+		self.memory.load(address)
+	}
+
+	/**
+	 * In general writing with ROM address space updates control registers in Mapper.
+	 */
+	pub fn store(&mut self, address: u32, value: u8) {
+		self.mapper.store(address, value);
+	}
+
+	pub fn valid(&self) -> bool {
+		self.header.is_nes()
+	}
+
+	pub fn has_chr_rom(&self) -> bool {
+		self.header.has_chr_rom()
+	}
+
+	pub fn has_battery_backed_ram(&self) -> bool {
+		self.header.has_battery_backed_ram()
+	}
+
+	pub fn mirroring_type(&self) -> Mirrorings {
+		match self.mapper.has_mirroring_type() {
+			true => self.mapper.mirroring_type(),
+			false => self.header.mirroring_type()
+		}
+	}
+
+	// @TODO: MMC3Mapper specific. Should this method be here?
+	pub fn irq_interrupted(&mut self) -> bool {
+		self.mapper.drive_irq_counter()
+	}
+}
+
+// @TODO: Cache
+pub struct RomHeader {
+	data: Vec<u8>
+}
+
+impl RomHeader {
+	fn new(vec: Vec<u8>) -> Self {
+		let mut header = RomHeader {
+			data: Vec::new()
+		};
+		for i in 0..HEADER_SIZE {
+			header.data.push(vec[i]);
+		}
+		header
+	}
+
+	fn load(&self, address: u32) -> u8 {
+		self.data[address as usize]
+	}
+
+	fn is_nes(&self) -> bool {
+		if self.signature() == "NES" && self.magic_number() == 0x1a {
+			return true;
+		}
+		false
+	}
+
+	fn signature(&self) -> String {
+		let mut vec = Vec::new();
+		for i in 0..3 as u32 {
+			vec.push(self.load(i));
+		}
+		String::from_utf8(vec).unwrap()
+	}
+
+	fn magic_number(&self) -> u8 {
+		self.load(3)
+	}
+
+	pub fn prg_rom_bank_num(&self) -> u8 {
+		self.load(4)
+	}
+
+	pub fn chr_rom_bank_num(&self) -> u8 {
+		self.load(5)
+	}
+
+	fn has_chr_rom(&self) -> bool {
+		self.chr_rom_bank_num() > 0
+	}
+
+	fn control_byte1(&self) -> u8 {
+		self.load(6)
+	}
+
+	fn control_byte2(&self) -> u8 {
+		self.load(7)
+	}
+
+	fn _ram_bank_num(&self) -> u8 {
+		self.load(8)
+	}
+
+	fn _unused_field(&self) -> u64 {
+		let mut value = 0 as u64;
+		for i in 0..7 as u32 {
+			value = (value << 8) | self.load(9 + i) as u64;
+		}
+		value
+	}
+
+	fn extract_bits(&self, value: u8, offset: u8, size: u8) -> u8 {
+		(value >> offset) & ((1 << size) - 1)
+	}
+
+	fn mirroring_type(&self) -> Mirrorings {
+		match self.four_screen_mirroring() {
+			true => Mirrorings::FourScreen,
+			false => match self.extract_bits(self.control_byte1(), 0, 1) {
+				0 => Mirrorings::Horizontal,
+				_ /* 1 */ => Mirrorings::Vertical
+			}
+		}
+	}
+
+	fn _is_horizontal_mirroring(&self) -> bool {
+		match self.mirroring_type() {
+			Mirrorings::Horizontal => true,
+			_ => false
+		}
+	}
+
+	pub fn has_battery_backed_ram(&self) -> bool {
+		self.extract_bits(self.control_byte1(), 1, 1) == 1
+	}
+
+	fn _trainer_512_bytes(&self) -> u8 {
+		self.extract_bits(self.control_byte1(), 2, 1)
+	}
+
+	fn four_screen_mirroring(&self) -> bool {
+		self.extract_bits(self.control_byte1(), 3, 1) == 1
+	}
+
+	pub fn mapper_num(&self) -> u8 {
+		let lower_bits = self.extract_bits(self.control_byte1(), 4, 4);
+		let higher_bits = self.extract_bits(self.control_byte2(), 4, 4);
+		(higher_bits << 4) | lower_bits
+	}
+}
+
+#[cfg(test)]
+mod tests_rom {
+	use super::*;
+
+	#[test]
+	fn initialize() {
+		let r = Rom::new(vec![0; 17]);
+	}
+
+	#[test]
+	fn load() {
+		let r = Rom::new(vec![0; 17]);
+		assert_eq!(0, r.load(0));
+	}
+
+	#[test]
+	fn store() {
+		let mut r = Rom::new(vec![0; 17]);
+		r.store(0, 0);
+	}
+
+	#[test]
+	fn valid() {
+		let r = Rom::new(vec![0; 64]);
+		assert_eq!(false, r.valid());
+		let mut v = vec![0; 64];
+		v[0] = 0x4e; // N
+		v[1] = 0x45; // E
+		v[2] = 0x53; // S
+		v[3] = 0x1a; // magic number
+		let r2 = Rom::new(v);
+		assert_eq!(true, r2.valid());
+	}
+}

package/extensions/nes/nes-component.ts

@@ -11,14 +11,9 @@ const FRAME_WIDTH = 256;
 const FRAME_HEIGHT = 240;
 
 function readRgb(frameBuffer: FrameBuffer, index: number): [number, number, number] {
-	if (frameBuffer.format === "rgb") {
-		const data = frameBuffer.data as ReadonlyArray<number>;
-		const base = index * 3;
-		return [data[base] ?? 0, data[base + 1] ?? 0, data[base + 2] ?? 0];
-	}
-	const data = frameBuffer.data as ReadonlyArray<number>;
-	const color = data[index] ?? 0;
-	return [color & 0xff, (color >> 8) & 0xff, (color >> 16) & 0xff];
+	const data = frameBuffer.data;
+	const base = index * 3;
+	return [data[base] ?? 0, data[base + 1] ?? 0, data[base + 2] ?? 0];
 }
 
 function renderHalfBlock(

package/extensions/nes/nes-core.ts

@@ -4,11 +4,8 @@ const require = createRequire(import.meta.url);
 
 export type NesButton = "up" | "down" | "left" | "right" | "a" | "b" | "start" | "select";
 
-export type FrameBufferFormat = "packed" | "rgb";
-
 export interface FrameBuffer {
-	format: FrameBufferFormat;
-	data: ReadonlyArray<number> | Uint8Array;
+	data: Uint8Array;
 }
 
 export interface NesCore {
@@ -37,6 +34,11 @@ interface NativeNesInstance {
 	reset(): void;
 	pressButton(button: number): void;
 	releaseButton(button: number): void;
+	hasBatteryBackedRam(): boolean;
+	getSram(): Uint8Array;
+	setSram(data: Uint8Array): void;
+	isSramDirty(): boolean;
+	markSramSaved(): void;
 	getFramebuffer(): Uint8Array;
 }
 
@@ -76,6 +78,7 @@ class NativeNesCore implements NesCore {
 	private readonly nes: NativeNesInstance;
 	private readonly audioWarning: string | null;
 	private readonly frameBuffer: Uint8Array;
+	private hasSram = false;
 
 	constructor(enableAudio: boolean) {
 		this.audioWarning = enableAudio
@@ -91,6 +94,7 @@ class NativeNesCore implements NesCore {
 
 	loadRom(rom: Uint8Array): void {
 		this.nes.setRom(rom);
+		this.hasSram = this.nes.hasBatteryBackedRam();
 		this.nes.bootup();
 	}
 
@@ -100,7 +104,7 @@ class NativeNesCore implements NesCore {
 	}
 
 	getFrameBuffer(): FrameBuffer {
-		return { format: "rgb", data: this.frameBuffer };
+		return { data: this.frameBuffer };
 	}
 
 	setButton(button: NesButton, pressed: boolean): void {
@@ -113,16 +117,32 @@ class NativeNesCore implements NesCore {
 	}
 
 	getSram(): Uint8Array | null {
-		return null;
+		if (!this.hasSram) {
+			return null;
+		}
+		return this.nes.getSram();
 	}
 
-	setSram(_sram: Uint8Array): void {}
+	setSram(sram: Uint8Array): void {
+		if (!this.hasSram) {
+			return;
+		}
+		this.nes.setSram(sram);
+	}
 
 	isSramDirty(): boolean {
-		return false;
+		if (!this.hasSram) {
+			return false;
+		}
+		return this.nes.isSramDirty();
 	}
 
-	markSramSaved(): void {}
+	markSramSaved(): void {
+		if (!this.hasSram) {
+			return;
+		}
+		this.nes.markSramSaved();
+	}
 
 	getAudioWarning(): string | null {
 		return this.audioWarning;

package/extensions/nes/paths.ts

@@ -0,0 +1,40 @@
+import os from "node:os";
+import path from "node:path";
+
+export function displayPath(value: string): string {
+	const home = os.homedir();
+	if (value.startsWith(home)) {
+		return `~${value.slice(home.length)}`;
+	}
+	return value;
+}
+
+export function expandHomePath(value: string): string {
+	if (value === "~") {
+		return os.homedir();
+	}
+	if (value.startsWith("~/") || value.startsWith("~\\")) {
+		return path.join(os.homedir(), value.slice(2));
+	}
+	return value;
+}
+
+export function normalizePath(value: string, fallback: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) {
+		return fallback;
+	}
+	return expandHomePath(trimmed);
+}
+
+export function resolvePathInput(input: string, cwd: string): string {
+	const trimmed = input.trim();
+	if (!trimmed) {
+		return cwd;
+	}
+	const expanded = expandHomePath(trimmed);
+	if (path.isAbsolute(expanded)) {
+		return expanded;
+	}
+	return path.resolve(cwd, expanded);
+}

package/extensions/nes/renderer.ts

@@ -131,21 +131,8 @@ export class NesImageRenderer {
 			return null;
 		}
 
-		const availableRows = getAvailableRows(tui, footerRows);
-		const maxRows = getMaxImageRows(tui, footerRows);
-		const cell = getCellDimensions();
-		const maxWidthByRows = Math.floor(
-			(maxRows * cell.heightPx * FRAME_WIDTH) / (FRAME_HEIGHT * cell.widthPx),
-		);
-		const maxWidthCells = Math.max(1, Math.min(widthCells, maxWidthByRows));
-		const maxWidthPx = Math.max(1, maxWidthCells * cell.widthPx);
-		const maxHeightPx = Math.max(1, maxRows * cell.heightPx);
-		const maxScale = Math.min(maxWidthPx / FRAME_WIDTH, maxHeightPx / FRAME_HEIGHT);
-		const requestedScale = Math.max(0.5, pixelScale) * maxScale;
-		const scale = Math.min(maxScale, requestedScale);
-		const columns = Math.max(1, Math.min(maxWidthCells, Math.floor((FRAME_WIDTH * scale) / cell.widthPx)));
-		const rows = Math.max(1, Math.min(maxRows, Math.floor((FRAME_HEIGHT * scale) / cell.heightPx)));
-		const padLeft = getHorizontalPadding(widthCells, columns);
+		const layout = computeKittyLayout(tui, widthCells, footerRows, pixelScale);
+		const { availableRows, columns, rows, padLeft } = layout;
 
 		this.fillRawBufferTarget(frameBuffer, shared.buffer);
 		const base64Name = Buffer.from(shared.name).toString("base64");
@@ -178,21 +165,8 @@ export class NesImageRenderer {
 		footerRows: number,
 		pixelScale: number,
 	): string[] {
-		const availableRows = getAvailableRows(tui, footerRows);
-		const maxRows = getMaxImageRows(tui, footerRows);
-		const cell = getCellDimensions();
-		const maxWidthByRows = Math.floor(
-			(maxRows * cell.heightPx * FRAME_WIDTH) / (FRAME_HEIGHT * cell.widthPx),
-		);
-		const maxWidthCells = Math.max(1, Math.min(widthCells, maxWidthByRows));
-		const maxWidthPx = Math.max(1, maxWidthCells * cell.widthPx);
-		const maxHeightPx = Math.max(1, maxRows * cell.heightPx);
-		const maxScale = Math.min(maxWidthPx / FRAME_WIDTH, maxHeightPx / FRAME_HEIGHT);
-		const requestedScale = Math.max(0.5, pixelScale) * maxScale;
-		const scale = Math.min(maxScale, requestedScale);
-		const columns = Math.max(1, Math.min(maxWidthCells, Math.floor((FRAME_WIDTH * scale) / cell.widthPx)));
-		const rows = Math.max(1, Math.min(maxRows, Math.floor((FRAME_HEIGHT * scale) / cell.heightPx)));
-		const padLeft = getHorizontalPadding(widthCells, columns);
+		const layout = computeKittyLayout(tui, widthCells, footerRows, pixelScale);
+		const { availableRows, columns, rows, padLeft } = layout;
 
 		this.fillRawBuffer(frameBuffer);
 		const fd = this.ensureRawFile();
@@ -235,23 +209,8 @@ export class NesImageRenderer {
 		footerRows: number,
 		pixelScale: number,
 	): string[] {
-		const availableRows = getAvailableRows(tui, footerRows);
-		const maxRows = getMaxImageRows(tui, footerRows);
-		const cell = getCellDimensions();
-		const maxWidthByRows = Math.floor(
-			(maxRows * cell.heightPx * FRAME_WIDTH) / (FRAME_HEIGHT * cell.widthPx),
-		);
-		const maxWidthCells = Math.max(1, Math.min(widthCells, maxWidthByRows));
-		const maxWidthPx = Math.max(1, maxWidthCells * cell.widthPx);
-		const maxHeightPx = Math.max(1, maxRows * cell.heightPx);
-		const scale = Math.min(
-			maxWidthPx / FRAME_WIDTH,
-			maxHeightPx / FRAME_HEIGHT,
-		) * pixelScale;
-		const targetWidth = Math.max(1, Math.floor(FRAME_WIDTH * scale));
-		const targetHeight = Math.max(1, Math.floor(FRAME_HEIGHT * scale));
-		const columns = Math.max(1, Math.min(maxWidthCells, Math.floor(targetWidth / cell.widthPx)));
-		const padLeft = getHorizontalPadding(widthCells, columns);
+		const layout = computePngLayout(tui, widthCells, footerRows, pixelScale);
+		const { availableRows, maxWidthCells, padLeft, targetHeight, targetWidth } = layout;
 
 		const hash = hashFrame(frameBuffer, targetWidth, targetHeight);
 		if (!this.cachedImage || this.lastFrameHash !== hash) {
@@ -293,28 +252,13 @@ export class NesImageRenderer {
 	}
 
 	private fillRawBufferTarget(frameBuffer: FrameBuffer, target: Uint8Array): void {
-		if (frameBuffer.format === "rgb") {
-			const source = frameBuffer.data as ReadonlyArray<number>;
-			if (source instanceof Uint8Array) {
-				target.set(source.subarray(0, RAW_FRAME_BYTES));
-				return;
-			}
-			const max = Math.min(source.length, RAW_FRAME_BYTES);
-			for (let i = 0; i < max; i += 1) {
-				target[i] = source[i] ?? 0;
-			}
+		const source = frameBuffer.data;
+		if (source.length >= RAW_FRAME_BYTES) {
+			target.set(source.subarray(0, RAW_FRAME_BYTES));
 			return;
 		}
-
-		let offset = 0;
-		const source = frameBuffer.data as ReadonlyArray<number>;
-		for (let i = 0; i < FRAME_WIDTH * FRAME_HEIGHT; i += 1) {
-			const color = source[i] ?? 0;
-			target[offset] = color & 0xff;
-			target[offset + 1] = (color >> 8) & 0xff;
-			target[offset + 2] = (color >> 16) & 0xff;
-			offset += 3;
-		}
+		target.set(source);
+		target.fill(0, source.length, RAW_FRAME_BYTES);
 	}
 
 	private getSharedMemoryModule(): KittyShmModule | null {
@@ -459,6 +403,40 @@ function getMaxImageRows(tui: TUI, footerRows: number): number {
 	return Math.max(1, Math.floor(availableRows * IMAGE_HEIGHT_RATIO));
 }
 
+function computeLayoutBase(tui: TUI, widthCells: number, footerRows: number) {
+	const availableRows = getAvailableRows(tui, footerRows);
+	const maxRows = getMaxImageRows(tui, footerRows);
+	const cell = getCellDimensions();
+	const maxWidthByRows = Math.floor(
+		(maxRows * cell.heightPx * FRAME_WIDTH) / (FRAME_HEIGHT * cell.widthPx),
+	);
+	const maxWidthCells = Math.max(1, Math.min(widthCells, maxWidthByRows));
+	const maxWidthPx = Math.max(1, maxWidthCells * cell.widthPx);
+	const maxHeightPx = Math.max(1, maxRows * cell.heightPx);
+	return { availableRows, maxRows, cell, maxWidthCells, maxWidthPx, maxHeightPx };
+}
+
+function computeKittyLayout(tui: TUI, widthCells: number, footerRows: number, pixelScale: number) {
+	const base = computeLayoutBase(tui, widthCells, footerRows);
+	const maxScale = Math.min(base.maxWidthPx / FRAME_WIDTH, base.maxHeightPx / FRAME_HEIGHT);
+	const requestedScale = Math.max(0.5, pixelScale) * maxScale;
+	const scale = Math.min(maxScale, requestedScale);
+	const columns = Math.max(1, Math.min(base.maxWidthCells, Math.floor((FRAME_WIDTH * scale) / base.cell.widthPx)));
+	const rows = Math.max(1, Math.min(base.maxRows, Math.floor((FRAME_HEIGHT * scale) / base.cell.heightPx)));
+	const padLeft = getHorizontalPadding(widthCells, columns);
+	return { ...base, columns, rows, padLeft };
+}
+
+function computePngLayout(tui: TUI, widthCells: number, footerRows: number, pixelScale: number) {
+	const base = computeLayoutBase(tui, widthCells, footerRows);
+	const scale = Math.min(base.maxWidthPx / FRAME_WIDTH, base.maxHeightPx / FRAME_HEIGHT) * pixelScale;
+	const targetWidth = Math.max(1, Math.floor(FRAME_WIDTH * scale));
+	const targetHeight = Math.max(1, Math.floor(FRAME_HEIGHT * scale));
+	const columns = Math.max(1, Math.min(base.maxWidthCells, Math.floor(targetWidth / base.cell.widthPx)));
+	const padLeft = getHorizontalPadding(widthCells, columns);
+	return { ...base, targetWidth, targetHeight, padLeft };
+}
+
 function centerLines(lines: string[], totalRows: number): string[] {
 	if (lines.length >= totalRows) {
 		return lines;
@@ -495,37 +473,24 @@ function insertPaddingAfterMoveUp(line: string, padLeft: number): string {
 }
 
 function readRgb(frameBuffer: FrameBuffer, index: number): [number, number, number] {
-	if (frameBuffer.format === "rgb") {
-		const data = frameBuffer.data as ReadonlyArray<number>;
-		const base = index * 3;
-		return [data[base] ?? 0, data[base + 1] ?? 0, data[base + 2] ?? 0];
-	}
-	const data = frameBuffer.data as ReadonlyArray<number>;
-	const color = data[index] ?? 0;
-	return [color & 0xff, (color >> 8) & 0xff, (color >> 16) & 0xff];
-}
-
-function readPacked(frameBuffer: FrameBuffer, index: number): number {
-	if (frameBuffer.format === "packed") {
-		const data = frameBuffer.data as ReadonlyArray<number>;
-		return data[index] ?? 0;
-	}
-	const data = frameBuffer.data as ReadonlyArray<number>;
+	const data = frameBuffer.data;
 	const base = index * 3;
-	const r = data[base] ?? 0;
-	const g = data[base + 1] ?? 0;
-	const b = data[base + 2] ?? 0;
-	return r | (g << 8) | (b << 16);
+	return [data[base] ?? 0, data[base + 1] ?? 0, data[base + 2] ?? 0];
 }
 
 function hashFrame(frameBuffer: FrameBuffer, width: number, height: number): number {
 	let hash = width ^ (height << 16);
 	const stepX = Math.max(1, Math.floor(FRAME_WIDTH / 64));
 	const stepY = Math.max(1, Math.floor(FRAME_HEIGHT / 64));
+	const data = frameBuffer.data;
 	for (let y = 0; y < FRAME_HEIGHT; y += stepY) {
 		const rowOffset = y * FRAME_WIDTH;
 		for (let x = 0; x < FRAME_WIDTH; x += stepX) {
-			const color = readPacked(frameBuffer, rowOffset + x);
+			const base = (rowOffset + x) * 3;
+			const r = data[base] ?? 0;
+			const g = data[base + 1] ?? 0;
+			const b = data[base + 2] ?? 0;
+			const color = r | (g << 8) | (b << 16);
 			hash = ((hash << 5) - hash + color) | 0;
 		}
 	}

package/package.json

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