discstation 0.1.32 → 0.1.33

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/package.json

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

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...")