romdevtools 0.13.0

package/src/host/c64-sid-state.js

@@ -0,0 +1,161 @@
+// C64 SID (6581/8580) state introspection.
+//
+// Gives C64 titles the same "what is each voice playing this frame?" decode
+// that getAudioState already gives the NES APU and SNES DSP. Before this, a
+// C64 music job had to reverse-engineer the game's private player RAM by hand;
+// now the hardware register file is decoded directly, player-independent.
+//
+// Data source: the `c64_sid_regs` region — a 29-byte snapshot of the SID
+// register file at $D400-$D41C. These are the *register* bytes (what the CPU
+// last wrote); the SID is write-only for $D400-$D414, so this is exactly the
+// pitch/waveform/ADSR layer you want for music transcription:
+//
+//   Voice N base = N*7  (N = 0,1,2)
+//     +0 freq lo          $D400/$D407/$D40E
+//     +1 freq hi          $D401/$D408/$D40F
+//     +2 PW lo            $D402/$D409/$D410
+//     +3 PW hi (bits 0-3) $D403/$D40A/$D411
+//     +4 control          $D404/$D40B/$D412 (gate/sync/ring/test/waveforms)
+//     +5 attack/decay     $D405/$D40C/$D413 (hi nibble attack, lo decay)
+//     +6 sustain/release  $D406/$D40D/$D414 (hi nibble sustain, lo release)
+//   $15 cutoff lo (bits 0-2)  $D415
+//   $16 cutoff hi             $D416
+//   $17 resonance / routing   $D417 (hi nibble resonance, lo = filter routing)
+//   $18 mode / volume         $D418 (lo nibble master vol, bits 4-6 mode, b7 v3off)
+
+// SID master clock. PAL C64 = 985248 Hz; the phase accumulator is 24-bit, so
+// freqHz = regValue16 * (clock / 2^24). NTSC differs (1022730) but PAL is the
+// default for European homebrew and the caller can recompute from `freqHz`.
+const SID_CLOCK_PAL = 985248;
+const SID_PHASE = 16777216; // 2^24
+
+// Control-register waveform bits (4-7). A voice can mix several; we list each
+// set bit so the caller sees combined-waveform tricks (e.g. tri+saw).
+const WAVEFORM_BITS = [
+  [0x10, "triangle"],
+  [0x20, "sawtooth"],
+  [0x40, "pulse"],
+  [0x80, "noise"],
+];
+
+// Filter mode bits ($D418 bits 4-6). A voice can route through several modes
+// at once on real hardware (notch = LP+HP), so we list each set bit.
+const FILTER_MODE_BITS = [
+  [0x10, "lowpass"],
+  [0x20, "bandpass"],
+  [0x40, "highpass"],
+];
+
+/**
+ * Convert a frequency in Hz to the nearest 12-TET note name (e.g. "C#4"),
+ * or null for 0 / invalid frequencies. A4 = 440 Hz.
+ * @param {number} hz
+ * @returns {string | null}
+ */
+export function freqToNote(hz) {
+  if (!hz || !Number.isFinite(hz) || hz <= 0) return null;
+  const NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+  // MIDI 69 = A4 = 440 Hz; octave number in scientific pitch notation is
+  // floor(midi/12) - 1 so that MIDI 60 = C4.
+  const midi = Math.round(69 + 12 * Math.log2(hz / 440));
+  const name = NAMES[((midi % 12) + 12) % 12];
+  const octave = Math.floor(midi / 12) - 1;
+  return name + octave;
+}
+
+/**
+ * Decode the SID register snapshot into per-voice musical state.
+ *
+ * @param {Uint8Array} regs the 29-byte `c64_sid_regs` region ($D400-$D41C)
+ * @returns {{
+ *   voices: VoiceState[],
+ *   filter: {
+ *     cutoff: number, resonance: number,
+ *     mode: string[], routedVoices: boolean[],
+ *   },
+ *   masterVolume: number,
+ *   voice3Off: boolean,
+ *   note: string,
+ * }}
+ *
+ * @typedef {{
+ *   freqHz: number, note: string|null, waveform: string[], pulseWidth: number,
+ *   gate: boolean, sync: boolean, ringMod: boolean, test: boolean,
+ *   adsr: { attack: number, decay: number, sustain: number, release: number },
+ * }} VoiceState
+ */
+export function decodeC64Sid(regs) {
+  const voices = [];
+  for (let v = 0; v < 3; v++) {
+    const base = v * 7;
+    const freqLo = regs[base + 0];
+    const freqHi = regs[base + 1];
+    const pwLo = regs[base + 2];
+    const pwHi = regs[base + 3] & 0x0f; // only low nibble is wired (12-bit PW)
+    const ctrl = regs[base + 4];
+    const ad = regs[base + 5];
+    const sr = regs[base + 6];
+
+    const reg16 = freqLo | (freqHi << 8);
+    const freqHz = reg16 * (SID_CLOCK_PAL / SID_PHASE);
+    const waveform = WAVEFORM_BITS
+      .filter(([bit]) => ctrl & bit)
+      .map(([, name]) => name);
+
+    voices.push({
+      freqHz: Math.round(freqHz * 100) / 100,
+      note: freqToNote(freqHz),
+      waveform,
+      pulseWidth: (pwHi << 8) | pwLo, // 12-bit, 0..4095
+      gate: !!(ctrl & 0x01),
+      sync: !!(ctrl & 0x02),
+      ringMod: !!(ctrl & 0x04),
+      test: !!(ctrl & 0x08),
+      adsr: {
+        attack: (ad >> 4) & 0x0f,
+        decay: ad & 0x0f,
+        sustain: (sr >> 4) & 0x0f,
+        release: sr & 0x0f,
+      },
+    });
+  }
+
+  const cutoffLo = regs[0x15] & 0x07; // only low 3 bits are wired
+  const cutoffHi = regs[0x16];
+  const res = regs[0x17];
+  const modeVol = regs[0x18];
+
+  const filter = {
+    // 11-bit cutoff: hi byte is the upper 8 bits, lo register the lowest 3.
+    cutoff: (cutoffHi << 3) | cutoffLo,
+    resonance: (res >> 4) & 0x0f,
+    mode: FILTER_MODE_BITS.filter(([bit]) => modeVol & bit).map(([, name]) => name),
+    // $D417 low nibble routes voices 1-3 (+ ext in, bit3) through the filter.
+    routedVoices: [!!(res & 0x01), !!(res & 0x02), !!(res & 0x04)],
+  };
+
+  return {
+    voices,
+    filter,
+    masterVolume: modeVol & 0x0f,
+    voice3Off: !!(modeVol & 0x80),
+    note:
+      "Decoded from the SID register file ($D400-$D41C) — the last values the " +
+      "CPU wrote (SID is write-only here), which is exactly the pitch/waveform/" +
+      "ADSR layer you want for music transcription. freqHz assumes PAL " +
+      "(clock 985248 Hz, 24-bit phase accumulator); for NTSC recompute with " +
+      "clock 1022730. pulseWidth is 12-bit (0-4095); ADSR fields are 0-15 rate " +
+      "indices, not seconds.",
+  };
+}
+
+/**
+ * @param {import("./LibretroHost.js").LibretroHost} host
+ * @param {string} platform
+ * @returns {ReturnType<typeof decodeC64Sid> | null}
+ */
+export function getC64SidState(host, platform) {
+  if (platform !== "c64") return null;
+  const regs = host.readMemory("c64_sid_regs", 0, 29);
+  return decodeC64Sid(regs);
+}

package/src/host/callbacks.js

@@ -0,0 +1,444 @@
+// libretro callback wiring.
+//
+// Registers the four required callbacks (env, video_refresh, input_poll,
+// input_state) plus audio sample + sample_batch. State lives on a plain
+// CallbackState object closed over by the addFunction handlers.
+//
+// Env handler patterns are mirrored from retroemu/src/core/LibretroHost.js —
+// many cores call log_cb / GET_VARIABLE / etc. inside retro_load_game, so we
+// must respond correctly to avoid WASM "null function / signature mismatch"
+// traps on cold load.
+//
+// See memory `libretro-wasm-patterns` for rationale.
+
+import { RETRO_HW_FRAME_BUFFER_VALID } from "./retroConstants.js";
+
+/**
+ * @typedef {Object} Frame
+ * @property {number} width
+ * @property {number} height
+ * @property {number} pitch
+ * @property {number} format one of RETRO_PIXEL_FORMAT_*
+ * @property {Uint8Array} pixels copy, safe to keep across calls
+ */
+
+/**
+ * @typedef {Object} CallbackState
+ * @property {number} pixelFormat negotiated pixel format
+ * @property {Frame | null} lastFrame
+ * @property {Int16Array[]} audioRing interleaved S16 stereo samples
+ * @property {boolean} supportsNoGame
+ * @property {Uint16Array[]} inputPorts joypad bitmask per port
+ * @property {Map<string, { description: string, options: string[], value: string }>} coreVariables
+ * @property {boolean} variablesUpdated
+ * @property {string} systemDir absolute path the core can ask about
+ * @property {string} saveDir absolute path the core can ask about
+ * @property {number[]} _allocatedPtrs heap pointers we keep alive for the core's lifetime
+ * @property {number | null} _logCbPtr cached log function pointer
+ */
+
+import {
+  RETRO_ENVIRONMENT_EXPERIMENTAL,
+  RETRO_PIXEL_FORMAT_0RGB1555,
+  RETRO_PIXEL_FORMAT_RGB565,
+  RETRO_PIXEL_FORMAT_XRGB8888,
+  RETRO_DEVICE_JOYPAD,
+} from "./retroConstants.js";
+
+// Env command IDs (extended set from retroemu)
+const E = {
+  GET_OVERSCAN: 2,
+  GET_CAN_DUPE: 3,
+  SET_MESSAGE: 6,
+  SHUTDOWN: 7,
+  SET_PERFORMANCE_LEVEL: 8,
+  GET_SYSTEM_DIRECTORY: 9,
+  SET_PIXEL_FORMAT: 10,
+  SET_INPUT_DESCRIPTORS: 11,
+  SET_KEYBOARD_CALLBACK: 12,
+  SET_DISK_CONTROL_INTERFACE: 13,
+  SET_HW_RENDER: 14,
+  GET_VARIABLE: 15,
+  SET_VARIABLES: 16,
+  GET_VARIABLE_UPDATE: 17,
+  SET_SUPPORT_NO_GAME: 18,
+  GET_LIBRETRO_PATH: 19,
+  SET_FRAME_TIME_CALLBACK: 21,
+  SET_AUDIO_CALLBACK: 22,
+  GET_RUMBLE_INTERFACE: 23,
+  GET_INPUT_DEVICE_CAPABILITIES: 24,
+  GET_SENSOR_INTERFACE: 25,
+  GET_CAMERA_INTERFACE: 26,
+  GET_LOG_INTERFACE: 27,
+  GET_PERF_INTERFACE: 28,
+  GET_LOCATION_INTERFACE: 29,
+  GET_CONTENT_DIRECTORY: 30,
+  GET_SAVE_DIRECTORY: 31,
+  SET_SYSTEM_AV_INFO: 32,
+  SET_PROC_ADDRESS_CALLBACK: 33,
+  SET_SUBSYSTEM_INFO: 34,
+  SET_CONTROLLER_INFO: 35,
+  SET_MEMORY_MAPS: 36,
+  SET_GEOMETRY: 37,
+  GET_USERNAME: 38,
+  GET_LANGUAGE: 39,
+  GET_CURRENT_SOFTWARE_FRAMEBUFFER: 40,
+  GET_HW_RENDER_INTERFACE: 41,
+  SET_SUPPORT_ACHIEVEMENTS: 42,
+  SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE: 43,
+  SET_SERIALIZATION_QUIRKS: 44,
+  SET_HW_SHARED_CONTEXT: 44 | 0x10000, // 0x1004C
+  GET_VFS_INTERFACE: 45,
+  GET_LED_INTERFACE: 46,
+  GET_AUDIO_VIDEO_ENABLE: 47,
+  GET_MIDI_INTERFACE: 48,
+  GET_FASTFORWARDING: 49,
+  GET_TARGET_REFRESH_RATE: 50,
+  GET_INPUT_BITMASKS: 51,
+  GET_CORE_OPTIONS_VERSION: 52,
+  SET_CORE_OPTIONS: 53,
+  SET_CORE_OPTIONS_INTL: 54,
+  SET_CORE_OPTIONS_DISPLAY: 55,
+  GET_PREFERRED_HW_RENDER: 56,
+  GET_DISK_CONTROL_INTERFACE_VERSION: 57,
+  SET_DISK_CONTROL_EXT_INTERFACE: 58,
+  GET_MESSAGE_INTERFACE_VERSION: 59,
+  SET_MESSAGE_EXT: 60,
+  GET_INPUT_MAX_USERS: 61,
+  SET_AUDIO_BUFFER_STATUS_CALLBACK: 62,
+  SET_MINIMUM_AUDIO_LATENCY: 63,
+  SET_FASTFORWARDING_OVERRIDE: 64,
+  SET_CONTENT_INFO_OVERRIDE: 65,
+  GET_GAME_INFO_EXT: 66,
+  SET_CORE_OPTIONS_V2: 67,
+  SET_CORE_OPTIONS_V2_INTL: 68,
+  SET_CORE_OPTIONS_UPDATE_DISPLAY_CALLBACK: 69,
+  SET_VARIABLE: 70,
+};
+
+/** @returns {CallbackState} */
+export function newCallbackState({ systemDir = "", saveDir = "" } = {}) {
+  return {
+    pixelFormat: RETRO_PIXEL_FORMAT_0RGB1555,
+    lastFrame: null,
+    audioRing: [],
+    supportsNoGame: false,
+    inputPorts: [new Uint16Array(1), new Uint16Array(1)],
+    // Keyboard state: a set of currently-pressed RETRO_KEY_* codes. The core
+    // polls via input_state(port, KEYBOARD, 0, keyCode) and gets 1 if pressed.
+    keysDown: new Set(),
+    coreVariables: new Map(),
+    variablesUpdated: false,
+    systemDir,
+    saveDir,
+    _allocatedPtrs: [],
+    _logCbPtr: null,
+  };
+}
+
+/**
+ * @param {number} format
+ * @returns {number}
+ */
+export function pixelBytes(format) {
+  if (format === RETRO_PIXEL_FORMAT_XRGB8888) return 4;
+  if (format === RETRO_PIXEL_FORMAT_RGB565) return 2;
+  if (format === RETRO_PIXEL_FORMAT_0RGB1555) return 2;
+  return 4;
+}
+
+/**
+ * Register all libretro callbacks on the module. Must be called BEFORE
+ * `_retro_init()`.
+ * @param {Object} args
+ * @param {any} args.mod Emscripten Module
+ * @param {CallbackState} args.state
+ * @param {(level: number, msg: string) => void} [args.log]
+ */
+export function registerCallbacks(args) {
+  const { mod, state, log } = args;
+
+  const envCb = mod.addFunction((cmd, dataPtr) => {
+    return handleEnv(mod, state, cmd, dataPtr, log) ? 1 : 0;
+  }, "iii");
+  mod._retro_set_environment(envCb);
+
+  const videoCb = mod.addFunction((dataPtr, w, h, pitch) => {
+    if (dataPtr === 0 || dataPtr === RETRO_HW_FRAME_BUFFER_VALID) return;
+    const bytes = h * pitch;
+    const view = mod.HEAPU8.subarray(dataPtr, dataPtr + bytes);
+    state.lastFrame = {
+      width: w,
+      height: h,
+      pitch,
+      format: state.pixelFormat,
+      pixels: new Uint8Array(view),
+    };
+  }, "viiii");
+  mod._retro_set_video_refresh(videoCb);
+
+  const audioBatchCb = mod.addFunction((dataPtr, frames) => {
+    if (dataPtr === 0 || frames === 0) return frames;
+    const byteLen = frames * 2 * 2;
+    const samples = new Int16Array(mod.HEAPU8.buffer, dataPtr, byteLen / 2).slice();
+    state.audioRing.push(samples);
+    return frames;
+  }, "iii");
+  mod._retro_set_audio_sample_batch(audioBatchCb);
+
+  const audioOneCb = mod.addFunction((left, right) => {
+    const buf = new Int16Array(2);
+    buf[0] = left;
+    buf[1] = right;
+    state.audioRing.push(buf);
+  }, "vii");
+  mod._retro_set_audio_sample(audioOneCb);
+
+  const inputPollCb = mod.addFunction(() => {
+    // input set explicitly by MCP callers — nothing to poll.
+  }, "v");
+  mod._retro_set_input_poll(inputPollCb);
+
+  const inputStateCb = mod.addFunction((port, device, _idx, id) => {
+    // device 3 = RETRO_DEVICE_KEYBOARD — id is the libretro keycode
+    if (device === 3) {
+      return state.keysDown.has(id) ? 1 : 0;
+    }
+    // Default: JOYPAD (device 1) and unknown devices fall through to bitfield.
+    const portBits = state.inputPorts[port];
+    if (!portBits) return 0;
+    const bits = portBits[0];
+    if (id === 256) return bits; // RETRO_DEVICE_ID_JOYPAD_MASK
+    return bits & (1 << id) ? 1 : 0;
+  }, "iiiii");
+  mod._retro_set_input_state(inputStateCb);
+}
+
+function allocString(mod, state, str) {
+  const bytes = Buffer.from(str + "\0", "utf-8");
+  const ptr = mod._malloc(bytes.length);
+  mod.HEAPU8.set(bytes, ptr);
+  state._allocatedPtrs.push(ptr);
+  return ptr;
+}
+
+function handleEnv(mod, state, rawCmd, dataPtr, log) {
+  const cmd = rawCmd & ~RETRO_ENVIRONMENT_EXPERIMENTAL;
+
+  switch (cmd) {
+    case E.GET_CAN_DUPE:
+      mod.setValue(dataPtr, 1, "i8");
+      return true;
+
+    case E.GET_OVERSCAN:
+      mod.setValue(dataPtr, 0, "i8");
+      return true;
+
+    case E.SET_MESSAGE:
+      return true; // accept, no UI to show it
+
+    case E.SET_PIXEL_FORMAT: {
+      const fmt = mod.getValue(dataPtr, "i32");
+      if (
+        fmt === RETRO_PIXEL_FORMAT_XRGB8888 ||
+        fmt === RETRO_PIXEL_FORMAT_RGB565 ||
+        fmt === RETRO_PIXEL_FORMAT_0RGB1555
+      ) {
+        state.pixelFormat = fmt;
+        return true;
+      }
+      return false;
+    }
+
+    case E.SET_SUPPORT_NO_GAME: {
+      const v = mod.getValue(dataPtr, "i8");
+      state.supportsNoGame = v !== 0;
+      return true;
+    }
+
+    case E.GET_SYSTEM_DIRECTORY: {
+      mod.setValue(dataPtr, allocString(mod, state, state.systemDir), "i32");
+      return true;
+    }
+
+    case E.GET_SAVE_DIRECTORY: {
+      mod.setValue(dataPtr, allocString(mod, state, state.saveDir), "i32");
+      return true;
+    }
+
+    case E.GET_CONTENT_DIRECTORY: {
+      mod.setValue(dataPtr, allocString(mod, state, state.saveDir), "i32");
+      return true;
+    }
+
+    case E.GET_LIBRETRO_PATH: {
+      mod.setValue(dataPtr, allocString(mod, state, state.systemDir), "i32");
+      return true;
+    }
+
+    case E.GET_LOG_INTERFACE: {
+      // retro_log_callback { retro_log_printf_t log }
+      // Signature: void(enum level, const char *fmt, ...). In Emscripten the
+      // vararg comes through as a pointer-to-stack; we declare 'viii' so the
+      // function-table entry has the right arity for the WASM caller.
+      //
+      // We don't implement full vsnprintf in JS, but the fmt string itself is
+      // already a useful diagnostic — most cores pass a fully-formed message
+      // (no varargs substitution needed) or a message + N args we can't decode.
+      // Read the fmt as-is so log output is actually readable.
+      if (!state._logCbPtr) {
+        state._logCbPtr = mod.addFunction((level, fmtPtr, _vaPtr) => {
+          if (!log) return;
+          let msg = "<unreadable>";
+          try { msg = mod.UTF8ToString(fmtPtr); } catch {}
+          log(level, msg);
+        }, "viii");
+      }
+      mod.setValue(dataPtr, state._logCbPtr, "i32");
+      return true;
+    }
+
+    case E.SET_VARIABLES: {
+      // retro_variable[]; { key*, value* } pairs, terminated by null key.
+      let ptr = dataPtr;
+      while (true) {
+        const keyPtr = mod.getValue(ptr, "i32");
+        const descPtr = mod.getValue(ptr + 4, "i32");
+        if (keyPtr === 0) break;
+        const key = mod.UTF8ToString(keyPtr);
+        const desc = descPtr ? mod.UTF8ToString(descPtr) : "";
+        const semi = desc.indexOf("; ");
+        if (semi >= 0) {
+          const options = desc.substring(semi + 2).split("|");
+          state.coreVariables.set(key, {
+            description: desc.substring(0, semi),
+            options,
+            value: options[0],
+          });
+        }
+        ptr += 8;
+      }
+      return true;
+    }
+
+    case E.SET_CORE_OPTIONS:
+    case E.SET_CORE_OPTIONS_INTL:
+    case E.SET_CORE_OPTIONS_V2:
+    case E.SET_CORE_OPTIONS_V2_INTL:
+      // We accept but don't parse v1/v2 core options yet; defaults are used.
+      return true;
+
+    case E.GET_VARIABLE: {
+      const keyPtr = mod.getValue(dataPtr, "i32");
+      if (keyPtr === 0) return false;
+      const key = mod.UTF8ToString(keyPtr);
+      const v = state.coreVariables.get(key);
+      if (!v) {
+        mod.setValue(dataPtr + 4, 0, "i32");
+        return false;
+      }
+      const valPtr = allocString(mod, state, v.value);
+      mod.setValue(dataPtr + 4, valPtr, "i32");
+      return true;
+    }
+
+    case E.GET_VARIABLE_UPDATE: {
+      mod.setValue(dataPtr, state.variablesUpdated ? 1 : 0, "i8");
+      state.variablesUpdated = false;
+      return true;
+    }
+
+    case E.GET_CORE_OPTIONS_VERSION:
+      mod.setValue(dataPtr, 0, "i32");
+      return true;
+
+    case E.GET_LANGUAGE:
+      mod.setValue(dataPtr, 0, "i32"); // English
+      return true;
+
+    case E.GET_USERNAME: {
+      mod.setValue(dataPtr, allocString(mod, state, "player"), "i32");
+      return true;
+    }
+
+    case E.GET_INPUT_DEVICE_CAPABILITIES:
+      mod.setValue(dataPtr, 1 << RETRO_DEVICE_JOYPAD, "i32");
+      return true;
+
+    case E.GET_INPUT_BITMASKS:
+      return true;
+
+    case E.GET_AUDIO_VIDEO_ENABLE:
+      mod.setValue(dataPtr, 7, "i32"); // audio + video + fast savestates
+      return true;
+
+    case E.GET_FASTFORWARDING:
+      mod.setValue(dataPtr, 0, "i8");
+      return true;
+
+    case E.GET_TARGET_REFRESH_RATE:
+      mod.setValue(dataPtr, 60.0, "double");
+      return true;
+
+    case E.GET_INPUT_MAX_USERS:
+      mod.setValue(dataPtr, 2, "i32");
+      return true;
+
+    case E.GET_MESSAGE_INTERFACE_VERSION:
+      mod.setValue(dataPtr, 0, "i32");
+      return true;
+
+    case E.GET_DISK_CONTROL_INTERFACE_VERSION:
+      mod.setValue(dataPtr, 0, "i32");
+      return true;
+
+    case E.SHUTDOWN:
+      return true;
+
+    // Accept-and-ignore set: core declares info we don't use right now.
+    case E.SET_INPUT_DESCRIPTORS:
+    case E.SET_CONTROLLER_INFO:
+    case E.SET_SUBSYSTEM_INFO:
+    case E.SET_MEMORY_MAPS:
+    case E.SET_PERFORMANCE_LEVEL:
+    case E.SET_GEOMETRY:
+    case E.SET_KEYBOARD_CALLBACK:
+    case E.SET_FRAME_TIME_CALLBACK:
+    case E.SET_AUDIO_CALLBACK:
+    case E.SET_AUDIO_BUFFER_STATUS_CALLBACK:
+    case E.SET_MINIMUM_AUDIO_LATENCY:
+    case E.SET_DISK_CONTROL_INTERFACE:
+    case E.SET_DISK_CONTROL_EXT_INTERFACE:
+    case E.SET_SUPPORT_ACHIEVEMENTS:
+    case E.SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE:
+    case E.SET_SERIALIZATION_QUIRKS:
+    case E.SET_CORE_OPTIONS_DISPLAY:
+    case E.SET_CORE_OPTIONS_UPDATE_DISPLAY_CALLBACK:
+    case E.SET_FASTFORWARDING_OVERRIDE:
+    case E.SET_CONTENT_INFO_OVERRIDE:
+    case E.SET_VARIABLE:
+    case E.SET_SYSTEM_AV_INFO:
+    case E.SET_PROC_ADDRESS_CALLBACK:
+      return true;
+
+    // Things we can't or don't want to support — reject so core falls back.
+    case E.SET_HW_RENDER: // no GL in headless mode
+    case E.GET_RUMBLE_INTERFACE:
+    case E.GET_SENSOR_INTERFACE:
+    case E.GET_CAMERA_INTERFACE:
+    case E.GET_PERF_INTERFACE:
+    case E.GET_LOCATION_INTERFACE:
+    case E.GET_VFS_INTERFACE:
+    case E.GET_LED_INTERFACE:
+    case E.GET_MIDI_INTERFACE:
+    case E.GET_HW_RENDER_INTERFACE:
+    case E.GET_PREFERRED_HW_RENDER:
+    case E.GET_CURRENT_SOFTWARE_FRAMEBUFFER:
+    case E.GET_GAME_INFO_EXT:
+      return false;
+
+    default:
+      if (log) log(0, `unhandled retro_environment cmd ${cmd}`);
+      return false;
+  }
+}