discstation 0.1.7 → 0.1.9

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

package/src/discstation.py

@@ -1046,6 +1046,9 @@ def is_rewritable_disc(device):
             "",
         )
         return "rw" in media_line
+    # Non-Linux: the RW signal comes from the ID_CDROM_MEDIA_*_RW keys above,
+    # which discstation_host.media_properties() tags from the drutil/diskutil
+    # media type.
     return False
 
 
@@ -1248,6 +1251,12 @@ def _classify_disc(device, props, failed, deadline):
                 print(f"Disc inspection failed: {e}")
             kind = kind or "data_disc"
             return _disc_info(True, kind, web_type=_web_type_for(kind, 0))
+        if props.get("ID_CDROM_MEDIA_STATE") == "blank":
+            try:
+                cap = discstation_burn.disc_capacity_bytes(device) or 0
+            except Exception:
+                cap = 0
+            return _disc_info(True, "blank", capacity_bytes=cap, web_type="BLANK")
         return _disc_info(True, "unknown", web_type="UNKNOWN", failed_probes=failed)
 
     # Fast path for a blank disc: cdrom_id reports this reliably in ~20ms, and
@@ -1452,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"):
@@ -1524,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:
@@ -1603,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:
@@ -1689,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)
@@ -2310,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")
@@ -3074,8 +3077,6 @@ 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")
 
@@ -3116,7 +3117,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://",
         ]
@@ -3285,8 +3286,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
@@ -3295,13 +3294,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)
 
@@ -3395,45 +3395,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)
@@ -3468,10 +3429,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(
@@ -3493,7 +3461,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"))
@@ -3873,9 +3841,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"

package/src/discstation_host.py

@@ -163,6 +163,19 @@ def drive_status():
     return "unknown"
 
 
+def _tag_rewritable(props, media_type):
+    """Set the ID_CDROM_MEDIA_*_RW key that discstation.is_rewritable_disc reads,
+    from a lowercased media-type string (drutil 'Type:' or diskutil 'Optical
+    Media Type'). ponytail: substring match — same heuristic as the rest of this
+    module."""
+    if "cd-rw" in media_type or "cdrw" in media_type:
+        props["ID_CDROM_MEDIA_CD_RW"] = "1"
+    elif "dvd-rw" in media_type or "dvd-ram" in media_type:
+        props["ID_CDROM_MEDIA_DVD_RW"] = "1"
+    elif "dvd+rw" in media_type or "bd-re" in media_type:
+        props["ID_CDROM_MEDIA_DVD_PLUS_RW"] = "1"
+
+
 def _drutil_media_properties():
     result = subprocess.run(["/usr/bin/drutil", "status"], capture_output=True, text=True, check=False, timeout=3)
     text = result.stdout + result.stderr
@@ -170,12 +183,16 @@ def _drutil_media_properties():
     if result.returncode != 0 or "no media" in lowered:
         return {}
     props = {"ID_CDROM": "1", "ID_CDROM_MEDIA": "1"}
-    if "space used:" in lowered and "00:00:00" in lowered.split("space used:", 1)[1][:24]:
+    blank = "space used:" in lowered and "00:00:00" in lowered.split("space used:", 1)[1][:24]
+    if blank:
         props["ID_CDROM_MEDIA_STATE"] = "blank"
-    if "type: cd" in lowered:
-        props["ID_CDROM_MEDIA_TYPE"] = "audio"
-    elif "type: dvd" in lowered:
+    match = re.search(r"type:\s*([a-z0-9+\-]+)", lowered)
+    media_type = match.group(1) if match else ""
+    if media_type.startswith("dvd") or media_type.startswith("bd"):
         props["ID_CDROM_MEDIA_TYPE"] = "dvd"
+    elif media_type.startswith("cd") and not blank and "-r" not in media_type:
+        props["ID_CDROM_MEDIA_TYPE"] = "audio"
+    _tag_rewritable(props, media_type)
     return props
 
 
@@ -187,7 +204,7 @@ def media_properties(device):
         except subprocess.TimeoutExpired:
             return _drutil_media_properties()
         if disk.returncode != 0:
-            return {}
+            return _drutil_media_properties()
         fields = {}
         for line in disk.stdout.splitlines():
             if ":" in line:
@@ -195,7 +212,7 @@ def media_properties(device):
                 fields[key.strip()] = value.strip()
         optical = fields.get("Optical Media Type", "")
         if not optical and not fields.get("Device / Media Name"):
-            return {}
+            return _drutil_media_properties()
         props = {"ID_CDROM": "1", "ID_CDROM_MEDIA": "1"}
         label = fields.get("Volume Name", "")
         filesystem = fields.get("Type (Bundle)") or fields.get("File System Personality")
@@ -223,8 +240,9 @@ def media_properties(device):
         optical = optical.lower()
         if "dvd+r dl" in optical or "dvd-r dl" in optical:
             props["ID_CDROM_MEDIA_DVD_PLUS_R_DL"] = "1"
-        elif "dvd+r" in optical or "dvd-r" in optical:
+        elif ("dvd+r" in optical or "dvd-r" in optical) and "rw" not in optical:
             props["ID_CDROM_MEDIA_DVD_PLUS_R"] = "1"
+        _tag_rewritable(props, optical)
         return props
     return {}
 
@@ -335,8 +353,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")