discstation 0.1.33 → 0.1.34

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.33",
+  "version": "0.1.34",
   "description": "DiscStation optical-media appliance host — one cross-OS installer",
   "bin": {
     "discstation-setup": "scripts/setup.mjs",

package/src/discstation_burn.py

@@ -1567,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%")
@@ -1607,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:
@@ -1617,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:]: