discstation 0.1.8 → 0.1.10

package/install-macos.sh

@@ -27,7 +27,8 @@ if ! command -v brew >/dev/null 2>&1; then
   exit 1
 fi
 
-brew install python ffmpeg cdrdao dvdauthor node yt-dlp xorriso mpv libdiscid handbrake
+brew install python ffmpeg cdrdao dvdauthor node yt-dlp xorriso mpv libdiscid handbrake \
+  libdvdcss dvdbackup libcdio-paranoia
 mkdir -p "$APP_DIR" "$VENV_DIR" "$CONFIG_DIR"
 cp -R "$ROOT_DIR/src/." "$APP_DIR/"
 python3 -m venv "$VENV_DIR"

package/package.json

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

package/src/discstation.py

@@ -1461,8 +1461,6 @@ def disc_title(device):
                     if t:
                         return t
     elif kind == "audio_cd":
-        if discstation_host.system_name() == "darwin":
-            return "Apple Music"
         try:
             toc = audio_cd_toc(device)
             if toc and toc.get("track_count"):
@@ -1533,8 +1531,6 @@ def menu_items_for_disc(device):
         had = discstation_burn.WORK.rglob("movie.mpg")
         if any(True for _ in had):
             items.append("BURN MPG")
-    elif kind == "audio_cd" and discstation_host.system_name() == "darwin":
-        items = ["APPLE MUSIC"]
     elif kind in ("dvd_video", "audio_cd", "vcd", "svcd", "video_data", "data_disc", "data_cd"):
         items = ["PLAY", "RIP"]
     else:
@@ -1612,47 +1608,38 @@ def disc_video_files(mount_dir):
 
 def audio_cd_toc(device):
     if discstation_host.system_name() == "darwin":
-        toc_path = discstation_burn.WORK / "mac_audio_read.toc"
+        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)")
         result = subprocess.run(
-            [discstation_burn.tool("cdrdao"), "read-toc", "--fast-toc",
-             "--device", discstation_host.cdrdao_device(device), str(toc_path)],
+            [paranoia, "-Q", "-d", rip_device(device)],
             capture_output=True, text=True, timeout=30,
         )
         text = ensure_text(result.stdout) + ensure_text(result.stderr)
-        toc_text = toc_path.read_text(errors="replace") if toc_path.exists() else ""
-        toc_path.unlink(missing_ok=True)
-        if result.returncode != 0:
-            detail = next((line.strip() for line in reversed(text.splitlines()) if line.strip()), "cdrdao failed")
+        # "  1.    18288 [04:03.63]        0 [00:00.00]    no   no  2"
+        begins, lengths = [], []
+        for line in text.splitlines():
+            match = re.match(r"\s*(\d+)\.\s+(\d+)\s+\[[\d:.]+\]\s+(\d+)\s+\[", line)
+            if match:
+                lengths.append(int(match.group(2)))
+                begins.append(int(match.group(3)))
+        if not begins:
+            detail = next((l.strip() for l in reversed(text.splitlines()) if l.strip()), "cd-paranoia -Q failed")
             raise RuntimeError(f"Could not read macOS CD TOC: {detail[:100]}")
-
-        durations = []
-        for block in re.split(r"(?m)^\s*//\s*Track\s+\d+\s*$", toc_text)[1:]:
-            file_lines = re.findall(r"(?m)^\s*FILE\b.*$", block)
-            file_times = re.findall(r"\d+:\d+:\d+", file_lines[-1]) if file_lines else []
-            pregap_times = re.findall(r"(?m)^\s*SILENCE\s+(\d+:\d+:\d+)", block)
-            if file_times:
-                duration = _msf_frames(file_times[-1])
-                duration += sum(_msf_frames(value) for value in pregap_times)
-                durations.append(duration)
-        if not durations:
-            for line in text.splitlines():
-                match = re.match(r"\s*(\d+)\s+AUDIO.*?\((\d+)\).*?\((\d+)\)", line)
-                if match:
-                    durations.append(int(match.group(3)) - int(match.group(2)))
-        if not durations:
-            raise RuntimeError("Could not read macOS CD TOC")
-        tracks = []
-        position = 150
-        for duration in durations:
-            tracks.append(position)
-            position += duration
-        leadout = position
+        tracks = [begin + 150 for begin in begins]           # LBA -> MB frame offset
+        leadout = begins[-1] + lengths[-1] + 150
         return {
             "first_track": 1,
-            "track_count": len(durations),
+            "track_count": len(tracks),
             "leadout": leadout,
             "tracks": tracks,
-            "toc": "+".join(map(str, [1, len(durations), leadout, *tracks])),
+            "toc": "+".join(map(str, [1, len(tracks), leadout, *tracks])),
         }
     if _libdiscid is not None:
         try:
@@ -1698,11 +1685,6 @@ def audio_cd_toc(device):
     }
 
 
-def _msf_frames(value):
-    minutes, seconds, frames = (int(part) for part in value.split(":"))
-    return (minutes * 60 + seconds) * 75 + frames
-
-
 def audio_cd_chapters(device):
     if discstation_host.system_name() == "darwin":
         toc = audio_cd_toc(device)
@@ -2319,7 +2301,19 @@ def iter_process_events(proc, idle_seconds=1.0, ser=None):
     reader.join(timeout=1)
 
 
+def rip_device(device):
+    """The node a ripper should read. macOS libdvdread/HandBrake/cd-paranoia
+    want the raw char node (/dev/rdiskN); Linux and others use `device` as-is."""
+    if device and discstation_host.system_name() == "darwin":
+        name = Path(device).name
+        if name.startswith("disk"):
+            return f"/dev/r{name}"
+    return device
+
+
 def device_size_bytes(device):
+    if discstation_host.system_name() != "linux":
+        return discstation_host.media_capacity_bytes(device) or 0
     result = run_probe(["blockdev", "--getsize64", device], timeout=3)
     try:
         return int(ensure_text(result.stdout).strip() or "0")
@@ -2939,15 +2933,16 @@ def _run_mpv(ser, cmd, label, kind=None, track_titles=None, track_starts=None):
         pass
 
     env = os.environ.copy()
-    if "DISPLAY" not in env:
-        env["DISPLAY"] = ":0"
-    try:
-        uid = os.getuid()
-        home_xauth = Path.home() / ".Xauthority"
-        env.setdefault("XAUTHORITY", str(home_xauth) if home_xauth.exists() else f"/run/user/{uid}/.Xauthority")
-        env.setdefault("XDG_RUNTIME_DIR", f"/run/user/{uid}")
-    except Exception:
-        pass
+    if discstation_host.system_name() == "linux":
+        if "DISPLAY" not in env:
+            env["DISPLAY"] = ":0"
+        try:
+            uid = os.getuid()
+            home_xauth = Path.home() / ".Xauthority"
+            env.setdefault("XAUTHORITY", str(home_xauth) if home_xauth.exists() else f"/run/user/{uid}/.Xauthority")
+            env.setdefault("XDG_RUNTIME_DIR", f"/run/user/{uid}")
+        except Exception:
+            pass
 
     proc = subprocess.Popen(run_as_desktop_user(cmd), env=env)
 
@@ -3083,30 +3078,41 @@ def play_flow(ser):
     kind = disc_kind(device)
     print(f"Disc type: {kind}")
 
-    if kind == "audio_cd" and discstation_host.system_name() == "darwin":
-        raise RuntimeError("Apple Music handles audio CD playback on macOS")
     if not shutil.which("mpv"):
         raise RuntimeError("mpv not found")
 
     if kind == "dvd_video":
         if discstation_host.system_name() == "darwin":
-            with mounted_disc(device) as mount_dir:
-                video_ts = mount_dir / "VIDEO_TS"
-                files = sorted(
-                    path for path in video_ts.glob("VTS_01_*.VOB")
-                    if re.search(r"_\d+\.VOB$", path.name, re.IGNORECASE)
-                    and not path.name.upper().endswith("_0.VOB")
-                )
-                if not files:
-                    raise RuntimeError("No playable DVD title found")
+            try:
                 cmd = [
                     "mpv",
                     "--input-ipc-server=" + MPV_SOCKET,
                     "--force-window=yes",
                     "--idle=no",
-                    *[str(path) for path in files],
+                    "--dvd-device=" + rip_device(device),
+                    "dvdnav://",
                 ]
                 _run_mpv(ser, cmd, "Playing DVD", kind)
+            except RuntimeError:
+                # libdvdnav couldn't open the disc — fall back to playing the
+                # main title's VOBs off the mounted volume (no menus).
+                with mounted_disc(device) as mount_dir:
+                    video_ts = mount_dir / "VIDEO_TS"
+                    files = sorted(
+                        path for path in video_ts.glob("VTS_01_*.VOB")
+                        if re.search(r"_\d+\.VOB$", path.name, re.IGNORECASE)
+                        and not path.name.upper().endswith("_0.VOB")
+                    )
+                    if not files:
+                        raise RuntimeError("No playable DVD title found")
+                    cmd = [
+                        "mpv",
+                        "--input-ipc-server=" + MPV_SOCKET,
+                        "--force-window=yes",
+                        "--idle=no",
+                        *[str(path) for path in files],
+                    ]
+                    _run_mpv(ser, cmd, "Playing DVD", kind)
         else:
             cmd = [
                 "mpv",
@@ -3125,7 +3131,7 @@ def play_flow(ser):
             "--input-ipc-server=" + MPV_SOCKET,
             "--force-window=no",
             "--idle=no",
-            "--cdrom-device=" + device,
+            "--cdrom-device=" + rip_device(device),
             "--cdda-cdtext=yes",
             "cdda://",
         ]
@@ -3294,8 +3300,6 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
     device = discstation_burn.disc_device()
     kind = disc_kind(device)
 
-    if kind == "audio_cd" and discstation_host.system_name() == "darwin":
-        raise RuntimeError("Apple Music handles audio CD ripping on macOS")
     if kind == "audio_cd":
         rip_audio_cd(ser, device, artist_hint, album_hint)
         return
@@ -3304,13 +3308,14 @@ def rip_flow(ser, artist_hint=None, album_hint=None):
         rip_video_disc(ser, device, kind)
         return
 
-    if kind == "dvd_video" and discstation_host.system_name() == "darwin":
-        rip_dvd_video_macos(ser, device)
-        return
-
     if kind != "dvd_video":
         raise RuntimeError(f"Unsupported disc: {kind}")
 
+    # libdvdread / HandBrake / dvdbackup want the raw node on macOS and the
+    # auto-mounted UDF/ISO volume released first (no-ops on Linux).
+    device = rip_device(device)
+    discstation_host.unmount_device(device)
+
     out_dir = RIP_ROOT / time.strftime("rip_%Y%m%d_%H%M%S")
     out_dir.mkdir(parents=True, exist_ok=True)
 
@@ -3404,45 +3409,6 @@ def remux_or_copy_video(src, dest):
         shutil.copy2(src, dest.with_suffix(src.suffix.lower()))
 
 
-def rip_dvd_video_macos(ser, device):
-    out_dir = RIP_ROOT / f"dvd_video_{time.strftime('%Y%m%d_%H%M%S')}"
-    out_dir.mkdir(parents=True, exist_ok=True)
-    send(ser, "STATUS:Ripping DVD")
-    send(ser, "INFO:Copying VIDEO_TS")
-    send(ser, "PROGRESS:0%")
-
-    with mounted_disc(device) as mount_dir:
-        source_dir = mount_dir / "VIDEO_TS"
-        if not source_dir.is_dir():
-            raise RuntimeError("VIDEO_TS directory not found")
-        files = sorted(path for path in source_dir.rglob("*") if path.is_file())
-        total_bytes = sum(path.stat().st_size for path in files)
-        copied_bytes = 0
-        for source in files:
-            relative = source.relative_to(source_dir)
-            destination = out_dir / "VIDEO_TS" / relative
-            destination.parent.mkdir(parents=True, exist_ok=True)
-            span = (source.stat().st_size / total_bytes * 100) if total_bytes else 0
-            discstation_burn.copy_with_keepalive(
-                ser,
-                source,
-                destination,
-                base_pct=(copied_bytes / total_bytes * 100) if total_bytes else 0,
-                pct_span=span,
-            )
-            copied_bytes += source.stat().st_size
-
-    (out_dir / "disc_info.json").write_text(
-        json.dumps({"kind": "dvd_video", "files": [str(path.relative_to(out_dir)) for path in (out_dir / "VIDEO_TS").rglob("*") if path.is_file()]}, indent=2),
-    )
-    safe_send(ser, "PROGRESS:100%")
-    safe_send(ser, "DONE:Rip complete!")
-    print(f"DVD rip complete: {out_dir}")
-    out_dir = _finalize_video_rip(ser, out_dir, device, "dvd_video")
-    chown_to_sudo_user(out_dir)
-    time.sleep(3)
-
-
 def rip_video_disc(ser, device, kind):
     out_dir = RIP_ROOT / f"{kind}_{time.strftime('%Y%m%d_%H%M%S')}"
     out_dir.mkdir(parents=True, exist_ok=True)
@@ -3477,10 +3443,17 @@ def _rip_audio_cd_macos(ser, device, chapters, metadata, cover_path, out_dir):
         raise RuntimeError("No audio CD tracks found")
     wav_dir = out_dir / ".wav"
     wav_dir.mkdir(parents=True, exist_ok=True)
-    command = [
-        discstation_burn.tool("cdda2wav"), "-D",
-        discstation_host.cdrdao_device(device), "-B", "-O", "wav", "-x",
-    ]
+    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)")
+    # -B batch mode writes track01.cdda.wav, track02.cdda.wav, ... in cwd.
+    command = [paranoia, "-B", "-d", rip_device(device), "1-"]
     send(ser, "STATUS:RIPPING AUDIO CD")
     send(ser, "PROGRESS:0%")
     proc = subprocess.Popen(
@@ -3502,7 +3475,7 @@ def _rip_audio_cd_macos(ser, device, chapters, metadata, cover_path, out_dir):
         raise
     proc.wait()
     if proc.returncode != 0:
-        detail = next((line.strip() for line in reversed(output) if line.strip()), "cdda2wav failed")
+        detail = next((line.strip() for line in reversed(output) if line.strip()), "cd-paranoia failed")
         raise RuntimeError(f"Audio CD rip failed: {detail[:80]}")
 
     wav_files = sorted(wav_dir.glob("*.wav"))
@@ -3882,9 +3855,6 @@ def station_loop(ser, url, artist_hint=None, album_hint=None):
                 _last_burn_result = "Burn complete"
             elif mode == "PLAY":
                 play_flow(ser)
-            elif mode == "APPLE MUSIC":
-                safe_send(ser, "STATUS:Apple Music handles this audio CD")
-                time.sleep(2)
             elif mode == "RIP":
                 rip_flow(ser, artist_hint, album_hint)
                 _last_burn_result = "Rip complete"
@@ -3924,10 +3894,16 @@ def check_pidfile():
                 old_pid = int(f.read().strip())
             try:
                 os.kill(old_pid, 0)
-                with open(f"/proc/{old_pid}/cmdline") as f:
-                    if "discstation" in f.read():
-                        print(f"Already running (PID {old_pid}), exiting")
-                        sys.exit(0)
+                if sys.platform == "linux":
+                    with open(f"/proc/{old_pid}/cmdline") as f:
+                        alive = "discstation" in f.read()
+                else:
+                    ps = subprocess.run(["ps", "-p", str(old_pid), "-o", "command="],
+                                        capture_output=True, text=True)
+                    alive = "discstation" in ps.stdout
+                if alive:
+                    print(f"Already running (PID {old_pid}), exiting")
+                    sys.exit(0)
             except (OSError, IOError):
                 pass
     except (ValueError, OSError):

package/src/discstation_burn.py

@@ -121,6 +121,12 @@ def reset_drive(device=None):
     """Power-cycle the USB optical enclosure by toggling its sysfs 'authorized'
     flag (or via DISCSTATION_USB_RESET_CMD). Best-effort; returns True on a
     completed toggle/hook, False otherwise."""
+    if discstation_host.system_name() == "darwin":
+        # ponytail: no USB re-enumeration on macOS; an eject/reload is the only
+        # soft reset available and it drops whatever disc is loaded.
+        for cmd in (["/usr/bin/drutil", "eject"], ["/usr/bin/drutil", "tray", "close"]):
+            subprocess.run(cmd, capture_output=True, timeout=15, check=False)
+        return True
     if discstation_host.system_name() != "linux":
         return False
     if not device:
@@ -1251,6 +1257,38 @@ def _run_growisofs(ser, growisofs_cmd, log_path, device=None):
         print(f"Disc eject skipped: {e}")
 
 
+def _run_hdiutil_burn(ser, image_path, device=None):
+    """Burn a pre-built ISO on macOS via `hdiutil burn -puppetstrings`, streaming
+    its PERCENT: lines to the ESP32."""
+    send(ser, "STATUS:Burning image...")
+    send(ser, "PROGRESS:0%")
+    cmd = discstation_host.iso_burn_command(device or disc_device(), image_path)
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+    out_lines = []
+    last_pct = -1
+    try:
+        for line in iter_proc_or_cancel(proc, ser):
+            out_lines.append(line)
+            m = re.search(r"PERCENT:([\d.]+)", line)
+            if m:
+                pct = int(float(m.group(1)))
+                if 0 <= pct <= 100 and pct != last_pct:
+                    last_pct = pct
+                    send(ser, f"PROGRESS:{min(pct, 99)}%")
+    except (KeyboardInterrupt, SystemExit):
+        stop_process(proc)
+        raise
+    rc = proc.wait()
+    if rc != 0:
+        detail = next((l for l in reversed(out_lines) if l.strip()), "hdiutil burn failed")
+        raise RuntimeError(f"Disc burn failed: {detail[:120]}")
+    safe_send(ser, "PROGRESS:100%")
+    try:
+        discstation_host.eject_device(device or disc_device())
+    except Exception as e:
+        print(f"Disc eject skipped: {e}")
+
+
 def burn(ser, dvd_dir, disc_label, speed=None, is_dual_layer=False):
     if discstation_host.system_name() != "linux":
         WORK.mkdir(parents=True, exist_ok=True)
@@ -1403,8 +1441,15 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
     # 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).
+    try:
+        cdrdao_write_dev = discstation_host.cdrdao_device(disc_device())
+    except RuntimeError:
+        if discstation_host.system_name() == "darwin":
+            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', discstation_host.cdrdao_device(disc_device())]
+                  '--device', cdrdao_write_dev]
     driver = os.environ.get("DISCSTATION_CDRDAO_DRIVER", "generic-mmc-raw")
     if driver:
         cdrdao_cmd += ['--driver', driver]
@@ -1454,6 +1499,9 @@ def burn_audio_cd(ser, audio_files, disc_label, speed=None):
 
 def burn_iso(ser, iso_path, speed=None, is_dual_layer=False):
     """Burn a pre-built ISO directly to disc — no filesystem building."""
+    if discstation_host.system_name() == "darwin":
+        _run_hdiutil_burn(ser, iso_path)
+        return
     if discstation_host.system_name() != "linux":
         send(ser, "STATUS:Burning image...")
         _run_growisofs(ser, discstation_host.iso_burn_command(disc_device(), iso_path), iso_path.parent / "discstation-burn.log")
@@ -1493,8 +1541,9 @@ def remux_and_author(ser, mpg, disc_label, disc_capacity, dvd_aspect=None):
     send(ser, f"INFO:Burning {mpg.parent.name}")
 
     send(ser, "STATUS:Remuxing to fix timestamps...")
-    v_es = Path(f"/tmp/video_{os.getpid()}.m2v")
-    a_es = Path(f"/tmp/audio_{os.getpid()}.ac3")
+    WORK.mkdir(parents=True, exist_ok=True)
+    v_es = WORK / f"video_{os.getpid()}.m2v"
+    a_es = WORK / f"audio_{os.getpid()}.ac3"
     fixed = mpg.parent / "movie_fixed.mpg"
     if fixed.exists():
         fixed.unlink()

package/src/discstation_host.py

@@ -295,12 +295,16 @@ def can_use_linux_optical_backend():
 
 def build_data_image(source_paths, output_path, label, video=False):
     system = system_name()
-    if system == "darwin":
-        command = [tool("hdiutil"), "makehybrid", "-o", str(output_path), "-iso", "-joliet", "-udf"]
-        command += ["-default-volume-name", label, *[str(path) for path in source_paths]]
-    elif system == "windows":
-        command = [tool("xorriso"), "-as", "mkisofs", "-iso-level", "3", "-J", "-R", "-V", label, "-o", str(output_path)]
-        command += [str(path) for path in source_paths]
+    if system in ("darwin", "windows"):
+        # xorriso's mkisofs emulation is the same lineage as Linux's
+        # genisoimage/growisofs; -dvd-video gives a set-top-compatible
+        # VIDEO_TS layout (the arg is the dir *containing* VIDEO_TS).
+        command = [tool("xorriso"), "-as", "mkisofs", "-V", label, "-o", str(output_path)]
+        if video:
+            command += ["-dvd-video", "-udf", str(source_paths[0])]
+        else:
+            command += ["-iso-level", "3", "-J", "-R", "-udf",
+                        *[str(path) for path in source_paths]]
     else:
         raise RuntimeError("Image building is only used by non-Linux optical backends")
     subprocess.run(command, check=True, capture_output=True, text=True)
@@ -310,7 +314,8 @@ def build_data_image(source_paths, output_path, label, video=False):
 def iso_burn_command(device, image_path):
     system = system_name()
     if system == "darwin":
-        return [tool("hdiutil"), "burn", str(image_path)]
+        # -puppetstrings emits machine-readable PERCENT: / MESSAGE: lines.
+        return [tool("hdiutil"), "burn", "-puppetstrings", str(image_path)]
     if system == "windows":
         return [tool("isoburn.exe"), "/Q", device, str(image_path)]
     raise RuntimeError("ISO command requested on Linux; use growisofs backend")
@@ -353,8 +358,20 @@ def cdrdao_device(device):
 
 
 def unmount_device(device):
-    """Unmount Linux optical media before handing the device to a writer."""
-    if system_name() != "linux" or not device:
+    """Release an auto-mounted optical volume before handing the raw device to a
+    writer or ripper. Media stays loaded."""
+    if not device:
+        return True
+
+    if system_name() == "darwin":
+        disk = re.sub(r"^/dev/r", "/dev/", device)  # diskutil wants the block node
+        subprocess.run(
+            ["/usr/sbin/diskutil", "unmountDisk", "force", disk],
+            capture_output=True, text=True, check=False, timeout=30,
+        )
+        return True
+
+    if system_name() != "linux":
         return True
 
     udisksctl = shutil.which("udisksctl")