discstation 0.1.32 → 0.1.34

package/arduino/DiscStation/DiscStation.ino

@@ -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;
   }
 
@@ -798,6 +826,7 @@ void parseMessage(String msg) {
     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();
@@ -1329,14 +1358,15 @@ void loop() {
   // 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 received a single VU:
-  // (lastVuAt == 0 - 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. Once any VU: does
-  // arrive this stops applying (lastVuAt is no longer 0) and PLAY behaves
-  // exactly as before, showing bars instead.
-  bool playSkippingToScreensaver = (uiState == UI_PLAY) && (lastVuAt == 0) &&
+  // 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) &&

package/install-macos.sh

@@ -50,7 +50,7 @@ if [[ -f "$ROOT_DIR/requirements-optional.txt" ]]; then
 fi
 
 DISC_DEVICE="${DISC_DEVICE:-}"
-DISC_PORT="${DISC_PORT:-$(ls /dev/cu.usbserial-* /dev/cu.usbmodem-* 2>/dev/null | head -1)}"
+DISC_PORT="${DISC_PORT:-$(ls /dev/cu.usbserial-* /dev/cu.usbmodem-* 2>/dev/null | head -1 || true)}"
 
 if [[ ! -f "$CONFIG_DIR/server.crt" || ! -f "$CONFIG_DIR/server.key" ]]; then
   openssl req -x509 -newkey rsa:2048 -nodes -days 3650 \

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discstation",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "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

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...")
@@ -1493,30 +1567,27 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
 
     album_t = _cdt(album_title) or "Audio CD"
     album_p = _cdt(album_artist) or "Unknown Artist"
-    toc_lines = ["CD_DA"]
-    toc_lines.append("CD_TEXT {")
-    toc_lines.append("  LANGUAGE_MAP { 0: EN }")
-    toc_lines.append("  LANGUAGE 0 {")
-    toc_lines.append(f'    TITLE "{album_t}"')
-    toc_lines.append(f'    PERFORMER "{album_p}"')
-    toc_lines.append("  }")
-    toc_lines.append("}")
-    toc_lines.append("")
-    for i, (artist, title) in enumerate(track_meta):
-        wav = tmp_dir / f"track_{i + 1:02d}.wav"
-        track_t = _cdt(title) or f"Track {i + 1:02d}"
-        track_p = _cdt(artist) or album_p
-        toc_lines.append("TRACK AUDIO")
-        toc_lines.append("CD_TEXT {")
-        toc_lines.append("  LANGUAGE 0 {")
-        toc_lines.append(f'    TITLE "{track_t}"')
-        toc_lines.append(f'    PERFORMER "{track_p}"')
-        toc_lines.append("  }")
-        toc_lines.append("}")
-        toc_lines.append(f'FILE "{wav}" 0')
-        toc_lines.append("")
     toc_path = tmp_dir / "disc.toc"
-    toc_path.write_text("\n".join(toc_lines) + "\n")
+
+    def _write_toc(include_cdtext):
+        toc_lines = ["CD_DA"]
+        if include_cdtext:
+            toc_lines += ["CD_TEXT {", "  LANGUAGE_MAP { 0: EN }", "  LANGUAGE 0 {",
+                          f'    TITLE "{album_t}"', f'    PERFORMER "{album_p}"',
+                          "  }", "}", ""]
+        for i, (artist, title) in enumerate(track_meta):
+            wav = tmp_dir / f"track_{i + 1:02d}.wav"
+            toc_lines.append("TRACK AUDIO")
+            if include_cdtext:
+                track_t = _cdt(title) or f"Track {i + 1:02d}"
+                track_p = _cdt(artist) or album_p
+                toc_lines += ["CD_TEXT {", "  LANGUAGE 0 {", f'    TITLE "{track_t}"',
+                              f'    PERFORMER "{track_p}"', "  }", "}"]
+            toc_lines.append(f'FILE "{wav}" 0')
+            toc_lines.append("")
+        toc_path.write_text("\n".join(toc_lines) + "\n")
+
+    _write_toc(include_cdtext=True)
     print(f"CD-TEXT: album={album_t!r} performer={album_p!r}, "
           f"{len(track_meta)} track titles")
     send(ser, "PROGRESS:35%")
@@ -1533,9 +1604,8 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
         return
 
     send(ser, "STATUS:Burning audio CD...")
-    # The cooked generic-mmc writer does NOT lay down the CD-TEXT lead-in on most
-    # ATAPI drives; the raw writer does. Override with DISCSTATION_CDRDAO_DRIVER
-    # (set it empty to let cdrdao auto-pick).
+    # DISCSTATION_CDRDAO_DRIVER forces one specific driver (set it empty for
+    # cdrdao to auto-pick) instead of the try-in-order fallback below.
     try:
         cdrdao_write_dev = discstation_host.cdrdao_device(disc_device())
     except RuntimeError:
@@ -1543,39 +1613,71 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
             raise RuntimeError("Audio CD burning is not supported on this Mac "
                                "(cdrdao cannot access the optical drive)")
         raise
-    cdrdao_cmd = [tool('cdrdao'), 'write', '--buffers', '64',
-                  '--device', cdrdao_write_dev]
-    driver = os.environ.get("DISCSTATION_CDRDAO_DRIVER", "generic-mmc-raw")
-    if driver:
-        cdrdao_cmd += ['--driver', driver]
-    speed_ = speed or DISC_SPEED
-    if speed_ and speed_.lower() != "auto":
-        cdrdao_cmd += ['--speed', speed_.rstrip('x')]
-    cdrdao_cmd.append(str(toc_path))  # toc-file must come after all options
-
-    proc = subprocess.Popen(cdrdao_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-    out_lines = []
+    def _run_cdrdao(driver):
+        cmd = [tool('cdrdao'), 'write', '--buffers', '64', '--device', cdrdao_write_dev]
+        if driver:
+            cmd += ['--driver', driver]
+        speed_ = speed or DISC_SPEED
+        if speed_ and speed_.lower() != "auto":
+            cmd += ['--speed', speed_.rstrip('x')]
+        cmd.append(str(toc_path))  # toc-file must come after all options
+        proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+        lines = []
+        last_prog = 0
+        try:
+            for line in iter_proc_or_cancel(proc, ser):
+                lines.append(line)
+                # "Wrote 12 of 650 MB (Buffers 99%  100%)." is the real write
+                # progress - matching on the first bare NN% instead (as this
+                # used to) grabs the *buffer fill* percentage, which BURN-Proof
+                # holds near 100% for virtually the whole burn, so the OLED
+                # jumped straight from "Converting" to 100% and sat there.
+                m = re.search(r'Wrote\s+(\d+)\s+of\s+(\d+)\s+MB', line)
+                if m and int(m.group(2)) > 0:
+                    frac = int(m.group(1)) / int(m.group(2))
+                    pct = 35 + int(frac * 65)
+                    now = time.time()
+                    if now - last_prog >= 0.2:
+                        send(ser, f"PROGRESS:{pct}%")
+                        last_prog = now
+        except (KeyboardInterrupt, SystemExit):
+            stop_process(proc)
+            raise
+        return proc.wait(), lines
+
     log_path = WORK / "cdrdao.log"
-    last_prog = 0
+    override = os.environ.get("DISCSTATION_CDRDAO_DRIVER")
+    # generic-mmc-raw (raw P-W sub-channel writing) is what guarantees CD-TEXT,
+    # but some drives reject raw sub-channel writing outright - confirmed live
+    # on this drive with --simulate: it fails at the lead-in even with CD-TEXT
+    # stripped out entirely, so it's the raw *driver* that's incompatible here,
+    # not CD-TEXT itself. generic-mmc (cooked) writes fine on the same drive
+    # (also confirmed with --simulate) and still carries the CD-TEXT blocks in
+    # the TOC, so it's worth trying with labels intact before dropping them -
+    # only the last resort actually removes CD-TEXT from the TOC.
+    drivers_to_try = [override] if override else ["generic-mmc-raw", "generic-mmc"]
     try:
-        for line in iter_proc_or_cancel(proc, ser):
-            out_lines.append(line)
-            m = re.search(r'(\d+)\s*%', line)
-            if m:
-                pct = 35 + int(int(m.group(1)) * 0.65)
-                now = time.time()
-                if now - last_prog >= 0.2:
-                    send(ser, f"PROGRESS:{pct}%")
-                    last_prog = now
-    except (KeyboardInterrupt, SystemExit):
-        stop_process(proc)
-        raise
+        rc, out_lines = -1, []
+        for i, driver in enumerate(drivers_to_try):
+            if i > 0:
+                print(f"cdrdao: write failed with previous driver - retrying with --driver {driver or 'auto'}")
+                send(ser, "STATUS:Retrying burn...")
+            rc, lines = _run_cdrdao(driver)
+            out_lines += ([f"--- driver {driver or 'auto'} ---"] if i else []) + lines
+            if rc == 0 or rc == -15:
+                break
+        if rc != 0 and rc != -15 and not override:
+            print("cdrdao: all driver modes failed - retrying without CD-TEXT")
+            send(ser, "STATUS:Retrying without CD-TEXT...")
+            _write_toc(include_cdtext=False)
+            rc2, lines2 = _run_cdrdao(None)
+            out_lines += ["--- retry without CD-TEXT ---"] + lines2
+            rc = rc2
     finally:
         for w in tmp_dir.glob("*.wav"):
             w.unlink(missing_ok=True)
         toc_path.unlink(missing_ok=True)
         shutil.rmtree(str(tmp_dir), ignore_errors=True)
-    rc = proc.wait()
     log_path.write_text("\n".join(out_lines) + "\n")
     if rc != 0:
         for line in out_lines[-10:]: