retroemu 0.1.0

package/src/video/VideoOutput.js

@@ -0,0 +1,207 @@
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import {
+  RETRO_PIXEL_FORMAT_0RGB1555,
+  RETRO_PIXEL_FORMAT_XRGB8888,
+  RETRO_PIXEL_FORMAT_RGB565,
+} from '../constants/libretro.js';
+
+// Pre-computed lookup tables for RGB565 → RGB8 conversion
+const RGB5_TO_8 = new Uint8Array(32);
+const RGB6_TO_8 = new Uint8Array(64);
+for (let i = 0; i < 32; i++) RGB5_TO_8[i] = (i * 255 / 31 + 0.5) | 0;
+for (let i = 0; i < 64; i++) RGB6_TO_8[i] = (i * 255 / 63 + 0.5) | 0;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class VideoOutput {
+  constructor() {
+    this.worker = null;
+    this.workerReady = false;
+    this.frameCount = 0;
+    this.renderEveryN = 2; // Render every Nth frame to terminal
+    this.rgbaBuffer = null;
+    this.pendingFrame = false;
+    this.displayAspectRatio = 4 / 3; // Default to 4:3, can be set by core
+    this.contrast = 1.0; // 1.0 = no change, >1 = more contrast
+    this.renderMode = 'detailed'; // 'detailed' or 'fast' (half blocks)
+  }
+
+  async init() {
+    return new Promise((resolve, reject) => {
+      this.worker = new Worker(join(__dirname, 'videoWorker.js'));
+
+      this.worker.on('message', (msg) => {
+        if (msg.type === 'ready') {
+          this.workerReady = true;
+          resolve();
+        } else if (msg.type === 'frame') {
+          this.pendingFrame = false;
+          process.stdout.write(`\x1b[H${msg.ansi}`);
+        } else if (msg.type === 'error') {
+          if (!this.workerReady) {
+            reject(new Error(msg.message));
+          } else {
+            console.error('Video worker error:', msg.message);
+          }
+        }
+      });
+
+      this.worker.on('error', (err) => {
+        if (!this.workerReady) {
+          reject(err);
+        } else {
+          console.error('Video worker error:', err.message);
+        }
+      });
+    });
+  }
+
+  setFrameSkip(n) {
+    this.renderEveryN = Math.max(1, n | 0);
+  }
+
+  setAspectRatio(ratio) {
+    this.displayAspectRatio = ratio > 0 ? ratio : 4 / 3;
+  }
+
+  setContrast(value) {
+    this.contrast = Math.max(0.5, Math.min(3.0, value));
+  }
+
+  setRenderMode(mode) {
+    const validModes = ['fast', 'ascii', 'braille', 'braille-dither'];
+    if (validModes.includes(mode)) {
+      this.renderMode = mode;
+    } else {
+      this.renderMode = 'detailed';
+    }
+  }
+
+  onFrame(wasmModule, dataPtr, width, height, pitch, pixelFormat) {
+    this.frameCount++;
+
+    if (this.frameCount % this.renderEveryN !== 0) return;
+    if (this.pendingFrame || !this.workerReady) return;
+
+    // Convert to RGBA on main thread (known working)
+    const rgbaData = this._convertToRGBA(wasmModule, dataPtr, width, height, pitch, pixelFormat);
+
+    const termCols = process.stdout.columns || 80;
+    const termRows = (process.stdout.rows || 24) - 4;
+
+    // Calculate dimensions that preserve display aspect ratio (4:3 for most retro consoles)
+    // Terminal chars are ~2:1 (height:width), so multiply width by 2
+    const sourceAspect = this.displayAspectRatio;
+    const termCharAspect = 2.0;
+
+    let usedCols, usedRows;
+    const rowsNeededForWidth = termCols / (sourceAspect * termCharAspect);
+
+    if (rowsNeededForWidth <= termRows) {
+      // Width-constrained: use full width, calculate height
+      usedCols = termCols;
+      usedRows = Math.floor(rowsNeededForWidth);
+    } else {
+      // Height-constrained: use full height, calculate width
+      usedRows = termRows;
+      usedCols = Math.floor(termRows * sourceAspect * termCharAspect);
+    }
+
+    this.pendingFrame = true;
+    this.worker.postMessage({
+      type: 'render',
+      rgbaData: rgbaData.buffer,
+      width,
+      height,
+      termCols: usedCols,
+      termRows: usedRows,
+      contrast: this.contrast,
+      renderMode: this.renderMode
+    }, [rgbaData.buffer]);
+
+    this.rgbaBuffer = null; // Need new buffer since we transferred
+  }
+
+  _convertToRGBA(wasmModule, dataPtr, width, height, pitch, pixelFormat) {
+    const totalPixels = width * height;
+
+    if (!this.rgbaBuffer || this.rgbaBuffer.length !== totalPixels * 4) {
+      this.rgbaBuffer = new Uint8ClampedArray(totalPixels * 4);
+    }
+
+    const rgba = this.rgbaBuffer;
+
+    switch (pixelFormat) {
+      case RETRO_PIXEL_FORMAT_XRGB8888:
+        this._convertXRGB8888(wasmModule, dataPtr, width, height, pitch, rgba);
+        break;
+      case RETRO_PIXEL_FORMAT_RGB565:
+        this._convertRGB565(wasmModule, dataPtr, width, height, pitch, rgba);
+        break;
+      case RETRO_PIXEL_FORMAT_0RGB1555:
+        this._convert0RGB1555(wasmModule, dataPtr, width, height, pitch, rgba);
+        break;
+    }
+
+    return rgba;
+  }
+
+  _convertXRGB8888(mod, dataPtr, width, height, pitch, rgba) {
+    for (let y = 0; y < height; y++) {
+      const srcRowByteOffset = dataPtr + y * pitch;
+      const dstRowOffset = y * width * 4;
+
+      for (let x = 0; x < width; x++) {
+        const pixel = mod.HEAPU32[(srcRowByteOffset >> 2) + x];
+        const dst = dstRowOffset + x * 4;
+        rgba[dst]     = (pixel >> 16) & 0xFF;
+        rgba[dst + 1] = (pixel >> 8) & 0xFF;
+        rgba[dst + 2] = pixel & 0xFF;
+        rgba[dst + 3] = 255;
+      }
+    }
+  }
+
+  _convertRGB565(mod, dataPtr, width, height, pitch, rgba) {
+    for (let y = 0; y < height; y++) {
+      const srcRowByteOffset = dataPtr + y * pitch;
+      const dstRowOffset = y * width * 4;
+
+      for (let x = 0; x < width; x++) {
+        const pixel = mod.HEAPU16[(srcRowByteOffset >> 1) + x];
+        const dst = dstRowOffset + x * 4;
+        rgba[dst]     = RGB5_TO_8[(pixel >> 11) & 0x1F];
+        rgba[dst + 1] = RGB6_TO_8[(pixel >> 5) & 0x3F];
+        rgba[dst + 2] = RGB5_TO_8[pixel & 0x1F];
+        rgba[dst + 3] = 255;
+      }
+    }
+  }
+
+  _convert0RGB1555(mod, dataPtr, width, height, pitch, rgba) {
+    for (let y = 0; y < height; y++) {
+      const srcRowByteOffset = dataPtr + y * pitch;
+      const dstRowOffset = y * width * 4;
+
+      for (let x = 0; x < width; x++) {
+        const pixel = mod.HEAPU16[(srcRowByteOffset >> 1) + x];
+        const dst = dstRowOffset + x * 4;
+        rgba[dst]     = RGB5_TO_8[(pixel >> 10) & 0x1F];
+        rgba[dst + 1] = RGB5_TO_8[(pixel >> 5) & 0x1F];
+        rgba[dst + 2] = RGB5_TO_8[pixel & 0x1F];
+        rgba[dst + 3] = 255;
+      }
+    }
+  }
+
+  destroy() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+    }
+    this.workerReady = false;
+  }
+}

package/src/video/videoWorker.js

@@ -0,0 +1,164 @@
+import { parentPort } from 'worker_threads';
+
+// Chafa constants
+const CHAFA_CANVAS_MODE_TRUECOLOR = 0;
+const CHAFA_SYMBOL_TAG_SPACE = 0x1;
+const CHAFA_SYMBOL_TAG_BLOCK = 0x8;
+const CHAFA_SYMBOL_TAG_BORDER = 0x10;
+const CHAFA_SYMBOL_TAG_VHALF = 0x200; // Vertical half blocks (▀▄) - fastest mode
+const CHAFA_SYMBOL_TAG_BRAILLE = 0x800; // Braille characters
+const CHAFA_SYMBOL_TAG_ASCII = 0x4000; // ASCII characters
+
+const CHAFA_CANVAS_MODE_FGBG = 5; // 2-color mode (foreground/background)
+const CHAFA_DITHER_MODE_NONE = 0;
+const CHAFA_DITHER_MODE_DIFFUSION = 2; // Floyd-Steinberg dithering
+
+let chafa = null;
+let canvasConfig = 0;
+let symbolMap = 0;
+let canvas = 0;
+let lastWidth = 0;
+let lastHeight = 0;
+let lastRenderMode = 'detailed';
+let currentCanvasMode = CHAFA_CANVAS_MODE_TRUECOLOR;
+let currentDitherMode = CHAFA_DITHER_MODE_NONE;
+
+function applyContrast(rgbaData, contrast) {
+  if (contrast === 1.0) return rgbaData;
+
+  const result = new Uint8ClampedArray(rgbaData.length);
+  for (let i = 0; i < rgbaData.length; i += 4) {
+    // Apply contrast to RGB, leave alpha unchanged
+    result[i]     = Math.min(255, Math.max(0, ((rgbaData[i] - 128) * contrast) + 128));
+    result[i + 1] = Math.min(255, Math.max(0, ((rgbaData[i + 1] - 128) * contrast) + 128));
+    result[i + 2] = Math.min(255, Math.max(0, ((rgbaData[i + 2] - 128) * contrast) + 128));
+    result[i + 3] = rgbaData[i + 3];
+  }
+  return result;
+}
+
+function createSymbolMap(mode) {
+  if (symbolMap) {
+    chafa._chafa_symbol_map_unref(symbolMap);
+  }
+  symbolMap = chafa._chafa_symbol_map_new();
+
+  // Reset to defaults
+  currentCanvasMode = CHAFA_CANVAS_MODE_TRUECOLOR;
+  currentDitherMode = CHAFA_DITHER_MODE_NONE;
+
+  if (mode === 'fast') {
+    // Use only vertical half blocks - fastest possible rendering
+    chafa._chafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_SPACE | CHAFA_SYMBOL_TAG_VHALF);
+  } else if (mode === 'ascii') {
+    // ASCII characters only
+    chafa._chafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_SPACE | CHAFA_SYMBOL_TAG_ASCII);
+  } else if (mode === 'braille') {
+    // Braille characters, black and white
+    chafa._chafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_BRAILLE);
+    currentCanvasMode = CHAFA_CANVAS_MODE_FGBG;
+  } else if (mode === 'braille-dither') {
+    // Braille characters with dithering for better grayscale
+    chafa._chafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_BRAILLE);
+    currentCanvasMode = CHAFA_CANVAS_MODE_FGBG;
+    currentDitherMode = CHAFA_DITHER_MODE_DIFFUSION;
+  } else {
+    // Detailed mode - block symbols for better quality
+    chafa._chafa_symbol_map_add_by_tags(symbolMap, CHAFA_SYMBOL_TAG_SPACE | CHAFA_SYMBOL_TAG_BLOCK | CHAFA_SYMBOL_TAG_BORDER);
+  }
+}
+
+async function initChafa() {
+  const chafaModule = await import('chafa-wasm');
+  chafa = chafaModule.default || chafaModule;
+  if (typeof chafa === 'function') {
+    chafa = await chafa();
+  }
+
+  createSymbolMap('detailed');
+
+  parentPort.postMessage({ type: 'ready' });
+}
+
+function renderFrame(rgbaData, width, height, termCols, termRows, contrast, renderMode = 'detailed') {
+  if (!chafa) return null;
+
+  // Apply contrast boost if needed
+  if (contrast && contrast !== 1.0) {
+    rgbaData = applyContrast(rgbaData, contrast);
+  }
+
+  // Recreate symbol map if render mode changed
+  if (lastRenderMode !== renderMode) {
+    createSymbolMap(renderMode);
+    lastRenderMode = renderMode;
+    // Force canvas config recreation
+    lastWidth = 0;
+    lastHeight = 0;
+  }
+
+  // Recreate canvas config if terminal size changed
+  if (lastWidth !== termCols || lastHeight !== termRows) {
+    if (canvasConfig) {
+      chafa._chafa_canvas_config_unref(canvasConfig);
+    }
+    if (canvas) {
+      chafa._chafa_canvas_unref(canvas);
+      canvas = 0;
+    }
+
+    canvasConfig = chafa._chafa_canvas_config_new();
+    chafa._chafa_canvas_config_set_geometry(canvasConfig, termCols, termRows);
+    chafa._chafa_canvas_config_set_canvas_mode(canvasConfig, currentCanvasMode);
+    chafa._chafa_canvas_config_set_symbol_map(canvasConfig, symbolMap);
+    if (currentDitherMode !== CHAFA_DITHER_MODE_NONE) {
+      chafa._chafa_canvas_config_set_dither_mode(canvasConfig, currentDitherMode);
+    }
+
+    lastWidth = termCols;
+    lastHeight = termRows;
+  }
+
+  if (!canvas) {
+    canvas = chafa._chafa_canvas_new(canvasConfig);
+  }
+
+  // Allocate and copy RGBA data to chafa's heap
+  const dataPtr = chafa._malloc(rgbaData.length);
+  chafa.HEAPU8.set(rgbaData, dataPtr);
+
+  // Draw pixels
+  chafa._chafa_canvas_set_contents_rgba8(canvas, dataPtr, width, height, width * 4);
+  chafa._free(dataPtr);
+
+  // Build ANSI output
+  const gsPtr = chafa._chafa_canvas_build_ansi(canvas);
+  if (!gsPtr) return null;
+
+  const strPtr = chafa._g_string_free_and_steal(gsPtr);
+  const ansi = chafa.UTF8ToString(strPtr);
+  chafa._free(strPtr);
+
+  return ansi;
+}
+
+parentPort.on('message', (msg) => {
+  if (msg.type === 'render') {
+    const ansi = renderFrame(
+      new Uint8ClampedArray(msg.rgbaData),
+      msg.width,
+      msg.height,
+      msg.termCols,
+      msg.termRows,
+      msg.contrast || 1.0,
+      msg.renderMode || 'detailed'
+    );
+    if (ansi) {
+      parentPort.postMessage({ type: 'frame', ansi });
+    }
+  }
+});
+
+initChafa().catch(err => {
+  parentPort.postMessage({ type: 'error', message: err.message });
+});