discstation 0.1.31 → 0.1.33

package/README.md

@@ -25,8 +25,8 @@ remote can talk to the host over Wi-Fi instead of a USB cable.
   the remote starts an open `DiscStation-XXXX` access point; join it from a
   phone, the captive portal (or `http://192.168.4.1`) lists nearby networks
   — pick yours, enter the password, done. It reconnects on every boot after
-  that. Change networks later: **hold SELECT for 10 s** on the home screen
-  to wipe the credentials and reopen the portal.
+  that. Change networks later: **hold HOME/BACK for 10 s** on the home
+  screen to wipe the credentials and reopen the portal.
   Power users can instead `cp arduino/<board>/secrets.h.example secrets.h`
   and set `WIFI_SSID` / `WIFI_PASS` at build time (git-ignored).
 - **Host side:** nothing to configure. With no USB cable present the host
@@ -47,7 +47,7 @@ remote can talk to the host over Wi-Fi instead of a USB cable.
 | **Burn Video DVD** | YouTube URL or local file → ffmpeg 2-pass → DVD-Video disc |
 | **Burn Data DVD** | Any files/folders → ISO/Joliet data disc (no quality loss) |
 | **Burn MPG** | Re-burn a previously converted movie.mpg |
-| **Play** | Playback via mpv (DVD-Video, Audio CD, VCD, SVCD) |
+| **Play** | Playback via mpv (DVD-Video, Audio CD, VCD, SVCD) — the OLED remote shows a live spectrum visualizer of the actual audio (Linux only for now; see `docs/PLATFORM_SUPPORT.md`) |
 | **Rip** | Audio CD → FLAC (MusicBrainz); DVD-Video → VIDEO_TS mirror or HandBrake MKV (TMDb naming) |
 
 ## Project Structure

package/arduino/DiscStation/DiscStation.ino

@@ -47,7 +47,7 @@
 #define VU_ENTRY_DELAY_MS  10000  // stay on the text status screen this long after entering PLAY
 #define VU_RESUME_DELAY_MS  7000  // ...and this long after any input while already in PLAY
 
-#define WIFI_RESET_HOLD_MS      10000  // hold SELECT this long on HOME to wipe Wi-Fi creds
+#define WIFI_RESET_HOLD_MS      10000  // hold HOME/BACK this long on HOME to wipe Wi-Fi creds
 #define WIFI_CONNECT_TIMEOUT_MS 18000  // give a stored-creds join this long before falling to the portal
 #define WIFI_RETRY_MS           15000  // if a live link drops, force a re-join after this
 
@@ -272,6 +272,13 @@ uint8_t vuLevel[VU_BARS];
 bool visualizerActive = false;
 unsigned long lastVuAt = 0;
 unsigned long vuSuppressUntil = 0;   // bars withheld (text screen shown instead) until millis() reaches this
+bool vuSeenReal = false;   // has this PLAY session ever gotten a VU: frame with a nonzero bar -
+                           // a session-level fact (macOS: never; Linux: within the first frame or
+                           // two), decided once and left alone. Deliberately separate from
+                           // visualizerActive/lastVuAt, which track "is the stream still alive"
+                           // per frame (including legitimate all-zero frames during quiet music) -
+                           // conflating the two into one gate previously caused the bars/screensaver
+                           // to flicker on Linux every time a frame happened to read all zero.
 int displayRotation = 0;
 
 // Indeterminate progress animation
@@ -642,7 +649,7 @@ bool wakeDisplay() {
     case UI_IP: drawIP(); break;
     case UI_BURN_READY: drawBurnReady(); break;
     case UI_PLAY:
-      if (visualizerActive && (long)(millis() - lastVuAt) < VU_TIMEOUT_MS &&
+      if (vuSeenReal && visualizerActive && (long)(millis() - lastVuAt) < VU_TIMEOUT_MS &&
           (long)(millis() - vuSuppressUntil) >= 0) drawPlayVisualizer();
       else drawPlay();
       break;
@@ -724,18 +731,39 @@ void parseMessage(String msg) {
     lastMsgTime = millis();
     String rest = msg.substring(3);
     for (int i = 0; i < VU_BARS; i++) vuLevel[i] = 0;
+    bool anyNonzero = false;
     for (int i = 0; i < VU_BARS && rest.length() > 0; i++) {
       int comma = rest.indexOf(',');
       String tok = (comma < 0) ? rest : rest.substring(0, comma);
       vuLevel[i] = (uint8_t)constrain(tok.toInt(), 0, 63);
+      if (vuLevel[i] > 0) anyNonzero = true;
       if (comma < 0) break;
       rest = rest.substring(comma + 1);
     }
+    if (anyNonzero) vuSeenReal = true;
+    // lastVuAt/visualizerActive/lastInputTime update on EVERY frame, zero or
+    // not - they track "is the stream still alive", and real music routinely
+    // produces a frame where every bar reads 0 (quiet moment right after a
+    // loud transient keeps the adaptive reference elevated for a beat). Only
+    // gating those three on anyNonzero previously made ordinary quiet frames
+    // look like "host stopped sending" to the unrelated VU_TIMEOUT_MS check
+    // below, flickering bars/screensaver during normal playback.
     visualizerActive = true;
     lastVuAt = millis();
     lastInputTime = millis();   // the visualizer's own continuous redraw already beats the
                                  // power-bank shutoff - no need for the screensaver too
-    if (uiState == UI_PLAY && (long)(millis() - vuSuppressUntil) >= 0) drawPlayVisualizer();
+    // Drawing bars (and reclaiming the screen from the disc-spinner screensaver,
+    // if it's up) is the one thing that DOES stay gated on vuSeenReal - a host
+    // that's technically capturing but getting only silence (e.g. macOS's
+    // blocked system-audio-capture - see docs/PLATFORM_SUPPORT.md) sends real
+    // VU: frames that are all zero forever. Without this gate, every one of
+    // those frames would re-draw a blank bars screen and set displayBlank =
+    // false, fighting the disc-spinner screensaver for the display every
+    // ~66ms instead of leaving it alone once chosen.
+    if (vuSeenReal && uiState == UI_PLAY && (long)(millis() - vuSuppressUntil) >= 0) {
+      displayBlank = false;
+      drawPlayVisualizer();
+    }
     return;
   }
 
@@ -796,6 +824,9 @@ void parseMessage(String msg) {
     line2 = "Playing disc";
     playSeekMode = false;          // always start in volume mode
     vuSuppressUntil = millis() + VU_ENTRY_DELAY_MS;   // text screen first, bars after a beat
+    lastVuAt = 0;                  // fresh session - unknown yet whether the host even sends VU: at all
+    visualizerActive = false;
+    vuSeenReal = false;            // unknown yet whether this session ever gets a real (nonzero) frame
     Out.print("POT:");             // push the last-used volume so playback starts at it
     Out.println(playVolume);
     drawPlay();
@@ -1326,9 +1357,20 @@ void loop() {
   // PLAY is included because a static "PLAYING" screen is just as low-current
   // as HOME/STANDBY were - the power bank doesn't care what's on screen, only
   // that the draw stays static this long.
+  //
+  // In PLAY specifically, if this session has never gotten a single REAL
+  // (nonzero) VU: frame (!vuSeenReal - the host/platform doesn't support the
+  // visualizer, e.g. macOS today), don't make the user wait out the full
+  // generic idle timer for an animation - drop into the spinning-disc
+  // screensaver as soon as the text-hold window (vuSuppressUntil) expires.
+  // vuSeenReal (not lastVuAt, which now updates on every frame including
+  // all-zero ones) is deliberately a session-level, decided-once fact, so
+  // this can't re-trigger mid-playback and flicker against the bars.
+  bool playSkippingToScreensaver = (uiState == UI_PLAY) && !vuSeenReal &&
+      (long)(millis() - vuSuppressUntil) >= 0;
   if (displayOk && !displayBlank &&
       (uiState == UI_HOME || uiState == UI_STANDBY || uiState == UI_PLAY) &&
-      (long)(millis() - lastInputTime) >= IDLE_BLANK_MS) {
+      ((long)(millis() - lastInputTime) >= IDLE_BLANK_MS || playSkippingToScreensaver)) {
     displayBlank = true;
     saverStep = 0;
     lastSaverFrame = 0;

package/docs/PLATFORM_SUPPORT.md

@@ -27,21 +27,49 @@ Set `DISC_DEVICE` if automatic drive detection fails. The one known limitation
 is **audio-CD *burning*** — `cdrdao` is the only option and often cannot claim
 the drive on recent macOS; DiscStation reports this clearly instead of hanging.
 
-### ESP32 remote: OLED spectrum visualizer
-
-The visualizer needs a one-time manual setup, since macOS has no built-in
-way to tap "whatever's currently playing" the way Linux's PulseAudio does:
-
-1. `brew install blackhole-2ch` (done automatically by `install-macos.sh`).
-2. Open **Audio MIDI Setup** (in Applications/Utilities), click **+** →
-   **Create Multi-Output Device**, and check both **BlackHole 2ch** and your
-   real output (speakers/headphones).
-3. In **System Settings → Sound**, set that Multi-Output Device as the
-   default output. Audio stays audible (routed to your real device) and is
-   simultaneously tapped (via BlackHole) for the visualizer's FFT.
-
-Without this setup the visualizer silently does nothing and PLAY just shows
-its normal text screen — nothing else is affected.
+### ESP32 remote: OLED spectrum visualizer — not currently working on macOS
+
+**Confirmed broken, not just a setup step.** The visualizer's macOS capture
+path (`ffmpeg -f avfoundation` reading the BlackHole loopback device) was
+built and the BlackHole/Multi-Output-Device routing was set up and verified
+correct on real hardware — but `ffmpeg`'s capture consistently returns
+silence (valid-looking output, zero errors, every sample exactly `0`) even
+with the native macOS Sound input level meter confirmed showing real,
+moving signal on BlackHole at the same moment. That combination — real
+signal present at the OS/driver level, silently zeroed once it reaches an
+app's capture buffer — is macOS's system-audio-capture privacy protection
+muting an untrusted capturer, not a permission checkbox that was missed:
+Microphone and Screen & System Audio Recording were both granted to
+`ffmpeg` with no change.
+
+The legitimate modern API for this (CoreAudio's Process Tap,
+`AudioHardwareCreateProcessTap`, macOS 14.2+) requires a properly
+code-signed app bundle requesting a specific entitlement, with its own
+dedicated system consent dialog — a bare ad-hoc-signed Homebrew CLI binary
+like `ffmpeg` structurally cannot satisfy that, regardless of which Privacy
+& Security toggles are flipped. Making the visualizer work on macOS would
+mean building a small signed helper app around that API — a real, separate
+project, not started.
+
+**Everything else works normally** — audio-CD/DVD/video playback, ripping,
+burning, and the web UI are all unaffected. PLAY just always shows the
+normal text status screen on macOS instead of ever switching to bars.
+
+If BlackHole is already installed from an earlier attempt at this, it's
+harmless to leave in place — it just won't do anything useful for
+DiscStation until/unless the above gets built.
+
+### Troubleshooting playback ("mpv not found" / play fails to start)
+
+- **`install-macos.sh` installs `mpv` via Homebrew** — if playback fails to
+  start, confirm it actually landed: `mpv --version` in Terminal. If that
+  fails, either the installer never ran to completion or was interrupted;
+  re-run `install-macos.sh` (or `discstation-setup`) rather than installing
+  `mpv` in isolation, since other steps may be incomplete too.
+- **Apple Music auto-opening on disc insert can hold the drive**, so
+  DiscStation's own `mpv` can fail or hang trying to claim it right after.
+  System Settings → **CDs & DVDs** (only shown with an optical drive
+  connected) → set "When you insert a music CD" to **Ignore**.
 
 ## Windows
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",

package/src/discstation.py

@@ -128,6 +128,13 @@ class TcpSerial:
             if p.isdigit():
                 port = int(p)
         self._sock = socket.create_connection((host, port), timeout=connect_timeout)
+        # Nagle's algorithm is on by default and holds back small writes hoping
+        # to coalesce them - the visualizer sends a ~30-50 byte VU: frame ~15x/sec,
+        # exactly the pattern that gets delayed (commonly ~200ms with delayed-ACK
+        # on the other end), which read as visualizer lag over Wi-Fi even though
+        # the visualizer itself was untouched. Never an issue on the USB path,
+        # which isn't TCP at all.
+        self._sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
         self._sock.settimeout(0.05)
         self._buf = b""
         self._lock = threading.Lock()
@@ -3056,7 +3063,7 @@ def burn_data_flow(ser):
         for d in files_to_burn:
             if d.is_dir():
                 total_bytes += sum(f.stat().st_size for f in d.rglob("*") if f.is_file())
-        label = "DVD5" if not dl_info["is_dual_layer"] else "DVD9"
+        label = "CD-R" if dl_info.get("is_cd") else ("DVD9" if dl_info["is_dual_layer"] else "DVD5")
         usable = discstation_burn.disc_output_limit_bytes(disc_bytes)
         if usable and total_bytes > usable:
             size_gb = total_bytes / 1e9
@@ -3448,7 +3455,29 @@ def start_vu_visualizer(ser):
     return stop_event, pause_event
 
 
-def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
+def _audio_cd_track_seek(delta, track_starts):
+    """Seek to the start of the next/previous track using the CD TOC's own
+    per-track offsets (already in seconds from track 1's start - see
+    audio_track_metadata) instead of mpv's own chapter list. Works whether
+    or not mpv has track chapters for this stream: macOS's piped
+    cd-paranoia audio has none, since mpv just sees one continuous stream,
+    not the disc itself - time-pos still works fine either way."""
+    if not track_starts:
+        mpv_command(["add", "chapter", delta])
+        return
+    track = mpv_query(["get_property", "chapter"])
+    if not isinstance(track, (int, float)):
+        position = mpv_query(["get_property", "time-pos"])
+        track = max((i for i, start in enumerate(track_starts) if start <= position), default=0) \
+            if isinstance(position, (int, float)) else 0
+    target = max(0, min(len(track_starts) - 1, int(track) + delta))
+    mpv_command(["seek", track_starts[target], "absolute"])
+
+
+def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None, stdin_proc=None):
+    """stdin_proc: an already-started subprocess whose stdout feeds mpv's
+    stdin (e.g. macOS's cd-paranoia-into-mpv audio CD pipe) - mpv reads `-`
+    as its input in cmd in that case. Stopped alongside mpv on cleanup."""
     try:
         os.unlink(MPV_SOCKET)
     except OSError:
@@ -3472,7 +3501,14 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
     # writes block, wedging the whole play loop. We drive mpv over the IPC
     # socket, so none of that output is wanted.
     proc = subprocess.Popen(run_as_desktop_user(cmd), env=env,
+                            stdin=(stdin_proc.stdout if stdin_proc else None),
                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    if stdin_proc:
+        # Close our own copy of the read end now that mpv's had it duped into
+        # its own stdin - otherwise we're also holding it open, so cd-paranoia
+        # never gets SIGPIPE (and just hangs writing into a full pipe buffer)
+        # if mpv exits first.
+        stdin_proc.stdout.close()
     vu_stop = None
 
     try:
@@ -3540,7 +3576,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
 
                 elif line == "FF:BIG":
                     if kind == "audio_cd":
-                        mpv_command(["add", "chapter", 1])
+                        _audio_cd_track_seek(1, track_starts)
                         send(ser, "PLAY_STATUS:Next track")
                     else:
                         mpv_command(["seek", 120])
@@ -3554,7 +3590,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
                     except ValueError:
                         continue
                     if kind == "audio_cd":
-                        mpv_command(["add", "chapter", 1])
+                        _audio_cd_track_seek(1, track_starts)
                         send(ser, "PLAY_STATUS:Next track")
                     else:
                         mpv_command(["seek", seek_sec])
@@ -3564,7 +3600,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
 
                 elif line == "REW:BIG":
                     if kind == "audio_cd":
-                        mpv_command(["add", "chapter", -1])
+                        _audio_cd_track_seek(-1, track_starts)
                         send(ser, "PLAY_STATUS:Prev track")
                     else:
                         mpv_command(["seek", -120])
@@ -3578,7 +3614,7 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
                     except ValueError:
                         continue
                     if kind == "audio_cd":
-                        mpv_command(["add", "chapter", -1])
+                        _audio_cd_track_seek(-1, track_starts)
                         send(ser, "PLAY_STATUS:Prev track")
                     else:
                         mpv_command(["seek", -seek_sec])
@@ -3604,6 +3640,8 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
             vu_stop.set()
         if proc.poll() is None:
             discstation_burn.stop_process(proc)
+        if stdin_proc and stdin_proc.poll() is None:
+            discstation_burn.stop_process(stdin_proc)
         try:
             os.unlink(MPV_SOCKET)
         except OSError:
@@ -3774,11 +3812,40 @@ def play_flow(ser):
 
     elif kind == "audio_cd":
         _, track_titles, track_starts = audio_track_metadata(device)
-        if discstation_host.system_name() == "windows":
+        system = discstation_host.system_name()
+        if system == "windows":
             # mpv on Windows has no libcdio - cdda:// is unavailable there
             # ("disabled at compile-time"). Windows Media Player's own COM
             # control plays it fine via Windows' native CD-audio support.
             _play_audio_cd_windows(ser, device, track_titles)
+        elif system == "darwin":
+            # Homebrew's mpv formula doesn't depend on libcdio either (no
+            # build option to add it) - confirmed live: `mpv cdda://` says
+            # "protocol ... disabled at compile-time" and --cdrom-device
+            # isn't even a recognized option. Same shape of gap as Windows,
+            # different fix: stream the disc via cd-paranoia (already used
+            # for ripping) into mpv's stdin instead of mpv opening the
+            # drive itself. mpv still does all actual playback + IPC
+            # control (pause/volume/stop), just fed a pipe instead of the
+            # disc directly.
+            paranoia = None
+            for name in ("cd-paranoia", "cdparanoia"):
+                try:
+                    paranoia = discstation_burn.tool(name)
+                    break
+                except FileNotFoundError:
+                    continue
+            if not paranoia:
+                raise RuntimeError("cd-paranoia not installed (brew install libcdio-paranoia)")
+            rip_proc = subprocess.Popen(
+                [paranoia, "-d", rip_device(device), "1-", "-"],
+                stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
+            audio_device = discstation_host.audio_output_device()
+            cmd = [mpv, "--input-ipc-server=" + MPV_SOCKET, "--force-window=no", "--idle=no", "-"]
+            if audio_device:
+                cmd.insert(1, "--audio-device=" + audio_device)
+                print(f"Audio CD output: {audio_device}")
+            _run_mpv(ser, cmd, "Playing audio CD", kind, track_titles, track_starts, stdin_proc=rip_proc)
         else:
             audio_device = discstation_host.audio_output_device()
             cmd = [

package/src/discstation_burn.py

@@ -242,6 +242,7 @@ DVD_DEVICE = os.environ.get("DISC_DEVICE") or os.environ.get("DVD_DEVICE")
 DISC_SPEED = os.environ.get("DISC_SPEED")
 DISC_DISC_BYTES = 4_700_000_000
 DVD_DL_BYTES = 8_500_000_000
+CD_R_BYTES = 700_000_000
 DISC_TARGET_BYTES = int(os.environ.get("DISC_TARGET_BYTES", "4300000000"))
 DVD_MUX_SAFETY = float(os.environ.get("DVD_MUX_SAFETY", "0.92"))
 AUDIO_BITRATE_K = int(os.environ.get("DVD_AUDIO_KBPS", "192"))
@@ -423,8 +424,17 @@ def disc_capacity_bytes(device):
         props.get("ID_CDROM_MEDIA_DVD_R_DL") == "1" or
         props.get("ID_CDROM_MEDIA_DVD_R_DL_SEQ") == "1"
     )
-    expected_min = 1_000_000_000
-    expected_max = DVD_DL_BYTES if is_dl else DISC_DISC_BYTES
+    # ID_CDROM_MEDIA_CD_R/CD_RW is the media actually loaded, not the drive's
+    # read/write capability (ID_CDROM_CD_R, set for any combo drive
+    # regardless of what's inserted) - checking the wrong one here is why a
+    # blank CD-R used to get treated as an unreadable DVD (capacity "unknown,
+    # assuming DVD5") instead of a ~700MB CD.
+    is_cd = (
+        props.get("ID_CDROM_MEDIA_CD_R") == "1" or
+        props.get("ID_CDROM_MEDIA_CD_RW") == "1"
+    )
+    expected_min = 100_000_000 if is_cd else 1_000_000_000
+    expected_max = CD_R_BYTES if is_cd else (DVD_DL_BYTES if is_dl else DISC_DISC_BYTES)
 
     mediainfo_timeout = _env_int("DISCSTATION_PROBE_TIMEOUT_MEDIAINFO", 12)
     best = None
@@ -465,14 +475,13 @@ def disc_capacity_bytes(device):
     if best is not None:
         return best
 
-    if props.get("ID_CDROM_MEDIA_STATE") == "blank":
-        if is_dl:
-            return DVD_DL_BYTES
     if is_dl:
         return DVD_DL_BYTES
     if props.get("ID_CDROM_MEDIA_DVD_PLUS_R") == "1" or \
        props.get("ID_CDROM_MEDIA_DVD_R") == "1":
         return DISC_DISC_BYTES
+    if is_cd:
+        return CD_R_BYTES
 
     # Last resort: a raw block size (works for finalized/pressed discs where
     # dvd+rw-mediainfo reports no free blocks; 0/absent for audio CDs).
@@ -498,6 +507,10 @@ def detect_disc_type(device):
         props.get("ID_CDROM_MEDIA_DVD_PLUS_R") == "1" or
         props.get("ID_CDROM_MEDIA_DVD_R") == "1"
     )
+    is_cd = (
+        props.get("ID_CDROM_MEDIA_CD_R") == "1" or
+        props.get("ID_CDROM_MEDIA_CD_RW") == "1"
+    )
     is_blank = props.get("ID_CDROM_MEDIA_STATE") == "blank"
     media_type = props.get("ID_CDROM_MEDIA", "")
 
@@ -505,11 +518,12 @@ def detect_disc_type(device):
 
     capacity = disc_capacity_bytes(device)
     if capacity is None:
-        capacity = DVD_DL_BYTES if is_dl else (DISC_DISC_BYTES if is_sl else None)
+        capacity = DVD_DL_BYTES if is_dl else (CD_R_BYTES if is_cd else (DISC_DISC_BYTES if is_sl else None))
 
     return {
         "is_dual_layer": is_dl,
         "is_single_layer": is_sl,
+        "is_cd": is_cd,
         "is_blank": is_blank,
         "status": status,
         "media_type": media_type,
@@ -1414,6 +1428,13 @@ def burn_data(ser, source_paths, disc_label, speed=None, is_dual_layer=False):
     send(ser, "PROGRESS:Starting")
     send(ser, f"INFO:Label {disc_label[:13]}")
     device = disc_device()
+    # growisofs (dvd+rw-tools) only writes DVD/BD media - it refuses CD-R/RW
+    # outright ("media is not recognized as recordable DVD"), so a blank CD-R
+    # needs the CD-specific tool (genisoimage build + wodim write) instead.
+    props = _udevadm_props(device)
+    if props.get("ID_CDROM_MEDIA_CD_R") == "1" or props.get("ID_CDROM_MEDIA_CD_RW") == "1":
+        _burn_data_cd(ser, source_paths, disc_label, speed, device)
+        return
     growisofs_cmd = [tool('growisofs'), '-dvd-compat', '-Z', device]
     speed = speed or DISC_SPEED
     if speed and speed.lower() != "auto":
@@ -1427,6 +1448,59 @@ def burn_data(ser, source_paths, disc_label, speed=None, is_dual_layer=False):
     growisofs_cmd += [str(p) for p in source_paths]
     _run_growisofs(ser, growisofs_cmd, source_paths[0].parent / "growisofs.log", device)
 
+def _burn_data_cd(ser, source_paths, disc_label, speed, device):
+    """Build an ISO9660/Joliet image with genisoimage and burn it with wodim -
+    the CD-R/RW equivalent of the growisofs path above (growisofs can't
+    write CD media at all)."""
+    WORK.mkdir(parents=True, exist_ok=True)
+    iso_path = WORK / f"data_{time.strftime('%Y%m%d_%H%M%S')}.iso"
+    mkisofs_cmd = [tool('genisoimage'), '-R', '-J', '-joliet-long', '-V', disc_label,
+                   '-o', str(iso_path)]
+    mkisofs_cmd += [str(p) for p in source_paths]
+    r = subprocess.run(mkisofs_cmd, capture_output=True, text=True)
+    if r.returncode != 0:
+        raise RuntimeError(f"ISO build failed: {r.stderr.strip()[-200:] or 'genisoimage error'}")
+
+    try:
+        discstation_host.unmount_device(device)
+        wodim_cmd = [tool('wodim'), '-v', f'dev={device}']
+        speed = speed or DISC_SPEED
+        if speed and speed.lower() != "auto":
+            wodim_cmd += [f"speed={re.sub(r'[^0-9]', '', speed) or '8'}"]
+        wodim_cmd.append(str(iso_path))
+
+        proc = subprocess.Popen(wodim_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        out_lines = []
+        last_prog = 0
+        try:
+            for line in iter_proc_or_cancel(proc, ser):
+                out_lines.append(line)
+                m = re.search(r'(\d+)%', line)
+                if m:
+                    now = time.time()
+                    if now - last_prog >= 0.2:
+                        send(ser, f"PROGRESS:{m.group(1)}%")
+                        last_prog = now
+        except (KeyboardInterrupt, SystemExit):
+            stop_process(proc)
+            raise
+        rc = proc.wait()
+        if rc != 0:
+            for line in out_lines[-10:]:
+                print(f"wodim: {line}")
+            if rc == -15:
+                safe_send(ser, "CANCELLED:Burn cancelled")
+                raise CancelError("Cancelled")
+            safe_send(ser, "INFO:Burn failed, check log")
+            raise RuntimeError("Disc burn failed")
+    finally:
+        iso_path.unlink(missing_ok=True)
+
+    try:
+        discstation_host.eject_device(device)
+    except Exception as e:
+        print(f"Disc eject skipped: {e}")
+
 def burn_audio_cd(ser, audio_files, disc_label, speed=None):
     """Convert audio files to CD-DA WAV and burn via cdrdao with CD-TEXT."""
     send(ser, "STATUS:Reading tags...")