jellyburn 0.3.0__tar.gz

jellyburn-0.3.0/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+<<<<<<< HEAD
+Copyright (c) 2026 Ömer Akyüz
+=======
+Copyright (c) 2026 Ömer Hamzaoglu
+>>>>>>> bb5c7e10716ec4e038836f66b34c688a6a3adee9
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

jellyburn-0.3.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: jellyburn
+Version: 0.3.0
+Summary: A GTK music player for Jellyfin with CD burning support
+Author: Ömer Hamzaoğlu
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/oemerhamzaoglu/jellyburn
+Project-URL: Issues, https://github.com/oemerhamzaoglu/jellyburn/issues
+Keywords: jellyfin,music,cd,burning,gtk,linux
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: X11 Applications :: GTK
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Players
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Dynamic: license-file
+
+# jellyburn
+
+A GTK3 desktop app for Linux to browse your Jellyfin music library, build playlists, and burn them directly to audio CD.
+
+![Python](https://img.shields.io/badge/python-3.10+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Platform](https://img.shields.io/badge/platform-Linux-lightgrey)
+![Status](https://img.shields.io/badge/status-alpha-orange)
+
+## Features
+
+- Connects to any Jellyfin server via API key or username/password
+- iTunes-style column browser — filter by artist, then album, then tracks
+- Track number column, search by title, artist or album
+- Album art display fetched directly from Jellyfin
+- Playback via `mpv` with now-playing info, progress bar and scrubbing
+- Collapse to a compact mini player that stays on top while you use other apps
+- Playlist builder with drag-and-drop reordering, save/load as JSON
+- Delete tracks from playlist with the Delete key or right-click
+- Real-time CD capacity bar (green → yellow → red, max. 74 min)
+- Burn directly to audio CD in Disc At Once mode — no extra steps
+- Auto-detects optical drives, shown as a dropdown in settings
+- Library cached locally for instant startup, refreshed in the background
+- Checks for missing system dependencies on startup with clear instructions
+
+## Requirements
+
+**System packages** (Debian/Ubuntu/Mint):
+
+```bash
+sudo apt install python3-gi gir1.2-gtk-3.0 gir1.2-gdkpixbuf-2.0 mpv ffmpeg cdrskin
+```
+
+> `cdrskin` is the recommended burn backend. `wodim` is supported as a fallback but may require extra permissions on modern kernels:
+> ```bash
+> sudo setcap cap_ipc_lock+ep $(which wodim)
+> ```
+
+**Python:** 3.10 or newer. The only Python dependency (`requests`) is installed automatically via pip.
+
+**Your user must be in the `cdrom` group** to access the optical drive without root:
+
+```bash
+sudo usermod -aG cdrom $USER
+# log out and back in for the change to take effect
+```
+
+## Installation
+
+```bash
+pip install jellyburn
+```
+
+Or run from source:
+
+```bash
+git clone https://github.com/oemerhamzaoglu/jellyburn
+cd jellyburn
+pip install -e .
+jellyburn
+```
+
+## Setup
+
+1. Click the settings icon (⚙) in the top right
+2. Enter your Jellyfin server URL, e.g. `https://jellyfin.example.com`
+3. Enter an API key — Jellyfin Dashboard → Administration → API Keys → New Key
+4. Select your CD drive from the dropdown (auto-detected)
+5. Set burn speed (default: 4×)
+6. Save — the app connects and loads your library
+
+Config is stored in `~/.config/jellyburn.json`. Passwords are never saved — only the API token obtained after login.
+Library cache is stored in `~/.cache/jellyburn/`.
+
+## Usage
+
+| Action | How |
+|---|---|
+| Browse | Click an artist → albums update; click an album → tracks filter |
+| Search | Type in the search bar — filters title, artist and album live |
+| Play | Double-click a track, or select it and press Play |
+| Scrub | Click or drag the progress bar to seek within a track |
+| Mini player | Click the collapse button (⧉) in the header; click ⤢ to restore |
+| Add to playlist | Select tracks (Ctrl+click for multiple), then „+ Auswahl hinzufügen" |
+| Reorder playlist | Drag and drop rows |
+| Remove from playlist | Select rows and press Delete, or right-click → remove |
+| Save/load playlist | Use the save/open icons in the playlist header |
+| Burn | Click „● CD BRENNEN" — tracks are downloaded, converted and burned |
+
+The CD capacity bar turns yellow above 85 % and red when the playlist exceeds 74 minutes.
+
+## Burn process
+
+1. Tracks are downloaded from Jellyfin one by one
+2. Each track is converted to WAV (44100 Hz, 16-bit stereo) via `ffmpeg`
+3. All WAV files are written to CD as an audio disc in DAO mode via `cdrskin` (or `wodim`)
+
+Temporary files in `/tmp/jellyfin_burn_*/` are cleaned up automatically after burning.
+
+## Contributing
+
+Open an issue before starting larger changes. PRs welcome.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

jellyburn-0.3.0/README.md

@@ -0,0 +1,106 @@
+# jellyburn
+
+A GTK3 desktop app for Linux to browse your Jellyfin music library, build playlists, and burn them directly to audio CD.
+
+![Python](https://img.shields.io/badge/python-3.10+-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+![Platform](https://img.shields.io/badge/platform-Linux-lightgrey)
+![Status](https://img.shields.io/badge/status-alpha-orange)
+
+## Features
+
+- Connects to any Jellyfin server via API key or username/password
+- iTunes-style column browser — filter by artist, then album, then tracks
+- Track number column, search by title, artist or album
+- Album art display fetched directly from Jellyfin
+- Playback via `mpv` with now-playing info, progress bar and scrubbing
+- Collapse to a compact mini player that stays on top while you use other apps
+- Playlist builder with drag-and-drop reordering, save/load as JSON
+- Delete tracks from playlist with the Delete key or right-click
+- Real-time CD capacity bar (green → yellow → red, max. 74 min)
+- Burn directly to audio CD in Disc At Once mode — no extra steps
+- Auto-detects optical drives, shown as a dropdown in settings
+- Library cached locally for instant startup, refreshed in the background
+- Checks for missing system dependencies on startup with clear instructions
+
+## Requirements
+
+**System packages** (Debian/Ubuntu/Mint):
+
+```bash
+sudo apt install python3-gi gir1.2-gtk-3.0 gir1.2-gdkpixbuf-2.0 mpv ffmpeg cdrskin
+```
+
+> `cdrskin` is the recommended burn backend. `wodim` is supported as a fallback but may require extra permissions on modern kernels:
+> ```bash
+> sudo setcap cap_ipc_lock+ep $(which wodim)
+> ```
+
+**Python:** 3.10 or newer. The only Python dependency (`requests`) is installed automatically via pip.
+
+**Your user must be in the `cdrom` group** to access the optical drive without root:
+
+```bash
+sudo usermod -aG cdrom $USER
+# log out and back in for the change to take effect
+```
+
+## Installation
+
+```bash
+pip install jellyburn
+```
+
+Or run from source:
+
+```bash
+git clone https://github.com/oemerhamzaoglu/jellyburn
+cd jellyburn
+pip install -e .
+jellyburn
+```
+
+## Setup
+
+1. Click the settings icon (⚙) in the top right
+2. Enter your Jellyfin server URL, e.g. `https://jellyfin.example.com`
+3. Enter an API key — Jellyfin Dashboard → Administration → API Keys → New Key
+4. Select your CD drive from the dropdown (auto-detected)
+5. Set burn speed (default: 4×)
+6. Save — the app connects and loads your library
+
+Config is stored in `~/.config/jellyburn.json`. Passwords are never saved — only the API token obtained after login.
+Library cache is stored in `~/.cache/jellyburn/`.
+
+## Usage
+
+| Action | How |
+|---|---|
+| Browse | Click an artist → albums update; click an album → tracks filter |
+| Search | Type in the search bar — filters title, artist and album live |
+| Play | Double-click a track, or select it and press Play |
+| Scrub | Click or drag the progress bar to seek within a track |
+| Mini player | Click the collapse button (⧉) in the header; click ⤢ to restore |
+| Add to playlist | Select tracks (Ctrl+click for multiple), then „+ Auswahl hinzufügen" |
+| Reorder playlist | Drag and drop rows |
+| Remove from playlist | Select rows and press Delete, or right-click → remove |
+| Save/load playlist | Use the save/open icons in the playlist header |
+| Burn | Click „● CD BRENNEN" — tracks are downloaded, converted and burned |
+
+The CD capacity bar turns yellow above 85 % and red when the playlist exceeds 74 minutes.
+
+## Burn process
+
+1. Tracks are downloaded from Jellyfin one by one
+2. Each track is converted to WAV (44100 Hz, 16-bit stereo) via `ffmpeg`
+3. All WAV files are written to CD as an audio disc in DAO mode via `cdrskin` (or `wodim`)
+
+Temporary files in `/tmp/jellyfin_burn_*/` are cleaned up automatically after burning.
+
+## Contributing
+
+Open an issue before starting larger changes. PRs welcome.
+
+## License
+
+MIT — see [LICENSE](LICENSE)

jellyburn-0.3.0/jellyburn/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

jellyburn-0.3.0/jellyburn/__main__.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""
+Jellyburn – Jellyfin music player and CD burner.
+"""
+
+import sys
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk
+
+from .config import check_dependencies
+from .ui.main_window import MainWindow
+
+
+class JellyburnApp(Gtk.Application):
+    def __init__(self):
+        super().__init__(application_id="de.linumed.jellyfinburner")
+
+    def do_activate(self):
+        win = MainWindow(application=self)
+        win.show_all()
+        missing = check_dependencies()
+        if missing:
+            dlg = Gtk.MessageDialog(
+                transient_for=win, modal=True,
+                message_type=Gtk.MessageType.WARNING,
+                buttons=Gtk.ButtonsType.OK,
+                text="Fehlende Systemabhängigkeiten",
+            )
+            dlg.format_secondary_text(
+                "Folgende Programme wurden nicht gefunden:\n\n" +
+                "\n".join(f"  • {label}" for label in missing) +
+                "\n\nBitte installieren, damit alle Funktionen verfügbar sind."
+            )
+            dlg.run()
+            dlg.destroy()
+
+
+def main():
+    app = JellyburnApp()
+    app.run(sys.argv)
+
+
+if __name__ == "__main__":
+    main()

jellyburn-0.3.0/jellyburn/api.py

@@ -0,0 +1,140 @@
+import requests
+
+
+def track_artist(track):
+    return (track.get("AlbumArtist")
+            or (track.get("Artists") or [""])[0]
+            or "")
+
+
+class JellyfinClient:
+    TIMEOUT = 15
+
+    def __init__(self, server_url, api_key=None, username=None, password=None):
+        self.server_url = server_url.rstrip("/")
+        self.api_key = api_key
+        self.user_id = None
+        self.session = requests.Session()
+        self.session.headers.update({
+            "X-Emby-Authorization": (
+                'MediaBrowser Client="Jellyburn", Device="Linux",'
+                ' DeviceId="jellyburn-01", Version="1.0"'
+            ),
+            "Content-Type": "application/json",
+        })
+        self.session.request = lambda method, url, **kw: \
+            requests.Session.request(self.session, method, url,
+                                     timeout=kw.pop("timeout", self.TIMEOUT), **kw)
+        if api_key:
+            self.session.headers["X-MediaBrowser-Token"] = api_key
+        elif username and password:
+            self._login(username, password)
+
+    def _login(self, username, password):
+        url = f"{self.server_url}/Users/AuthenticateByName"
+        resp = self.session.post(url, json={"Username": username, "Pw": password})
+        resp.raise_for_status()
+        data = resp.json()
+        self.api_key = data["AccessToken"]
+        self.user_id = data["User"]["Id"]
+        self.session.headers["X-MediaBrowser-Token"] = self.api_key
+
+    def get_user_id(self):
+        if self.user_id:
+            return self.user_id
+        resp = self.session.get(f"{self.server_url}/Users/Me")
+        resp.raise_for_status()
+        self.user_id = resp.json()["Id"]
+        return self.user_id
+
+    def search_music(self, query="", on_page=None):
+        uid = self.get_user_id()
+        params = {
+            "IncludeItemTypes": "Audio",
+            "Recursive": "true",
+            "Fields": "RunTimeTicks,AlbumArtist,Album,Path,ParentId,ArtistIds",
+            "UserId": uid,
+            "Limit": 500,
+            "StartIndex": 0,
+        }
+        if query:
+            params["SearchTerm"] = query
+            resp = self.session.get(f"{self.server_url}/Items", params=params)
+            resp.raise_for_status()
+            return resp.json().get("Items", [])
+
+        all_items = []
+        total = None
+        while True:
+            params["StartIndex"] = len(all_items)
+            resp = self.session.get(f"{self.server_url}/Items", params=params)
+            resp.raise_for_status()
+            data = resp.json()
+            if total is None:
+                total = data.get("TotalRecordCount", 0)
+            page = data.get("Items", [])
+            all_items.extend(page)
+            if on_page:
+                on_page(page, len(all_items), total)
+            if len(all_items) >= total or not page:
+                break
+        return all_items
+
+    def get_artists(self):
+        uid = self.get_user_id()
+        resp = self.session.get(
+            f"{self.server_url}/Artists",
+            params={"UserId": uid, "Recursive": "true", "Limit": 500},
+        )
+        resp.raise_for_status()
+        return resp.json().get("Items", [])
+
+    def get_albums(self, artist_id=None):
+        uid = self.get_user_id()
+        params = {
+            "IncludeItemTypes": "MusicAlbum",
+            "Recursive": "true",
+            "UserId": uid,
+            "Limit": 500,
+            "Fields": "AlbumArtist,ChildCount,RunTimeTicks",
+        }
+        if artist_id:
+            params["AlbumArtistIds"] = artist_id
+        resp = self.session.get(f"{self.server_url}/Items", params=params)
+        resp.raise_for_status()
+        return resp.json().get("Items", [])
+
+    def get_tracks(self, album_id=None, artist_id=None):
+        uid = self.get_user_id()
+        params = {
+            "IncludeItemTypes": "Audio",
+            "Recursive": "true",
+            "UserId": uid,
+            "Limit": 500,
+            "Fields": "RunTimeTicks,AlbumArtist,Album,IndexNumber,ParentIndexNumber,Path",
+            "SortBy": "ParentIndexNumber,IndexNumber,SortName",
+        }
+        if album_id:
+            params["ParentId"] = album_id
+        if artist_id:
+            params["ArtistIds"] = artist_id
+        resp = self.session.get(f"{self.server_url}/Items", params=params)
+        resp.raise_for_status()
+        return resp.json().get("Items", [])
+
+    def get_stream_url(self, item_id):
+        uid = self.get_user_id()
+        return (
+            f"{self.server_url}/Audio/{item_id}/stream"
+            f"?UserId={uid}&api_key={self.api_key}&AudioCodec=flac&Container=flac"
+        )
+
+    def get_download_url(self, item_id):
+        return f"{self.server_url}/Items/{item_id}/Download?api_key={self.api_key}"
+
+    def ticks_to_seconds(self, ticks):
+        return ticks // 10_000_000 if ticks else 0
+
+    def format_duration(self, ticks):
+        s = self.ticks_to_seconds(ticks)
+        return f"{s // 60}:{s % 60:02d}"

jellyburn-0.3.0/jellyburn/burner.py

@@ -0,0 +1,216 @@
+import os
+import resource
+import subprocess
+import tempfile
+import threading
+
+
+def resolve_sg_device(sr_device):
+    """Löst /dev/srX in das passende /dev/sgX auf (für wodim nötig)."""
+    try:
+        name = os.path.basename(sr_device)  # z.B. "sr0"
+        sg_dir = f"/sys/block/{name}/device/scsi_generic"
+        sg_name = os.listdir(sg_dir)[0]     # z.B. "sg1"
+        return f"/dev/{sg_name}"
+    except Exception:
+        return sr_device  # Fallback: original behalten
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GLib
+
+from .api import track_artist
+from .config import check_dependencies, get_burn_tool
+
+
+class BurnDialog(Gtk.Dialog):
+    def __init__(self, parent, playlist, client, config):
+        super().__init__(title="CD brennen", transient_for=parent, modal=True)
+        self.set_default_size(500, 400)
+        self.playlist = playlist
+        self.client = client
+        self.config = config
+        self.cancelled = False
+        self._burning = False
+
+        box = self.get_content_area()
+        box.set_spacing(8)
+        box.set_margin_start(16)
+        box.set_margin_end(16)
+        box.set_margin_top(16)
+        box.set_margin_bottom(16)
+
+        box.pack_start(Gtk.Label(label="<b>Tracks auf CD:</b>", use_markup=True, xalign=0), False, False, 0)
+
+        sw = Gtk.ScrolledWindow()
+        sw.set_min_content_height(150)
+        tv = Gtk.TextView(editable=False, monospace=True)
+        buf = tv.get_buffer()
+        lines = "\n".join(
+            f"{i+1:2}. {track_artist(t) or '?'} - {t.get('Name','?')}"
+            f" ({client.format_duration(t.get('RunTimeTicks', 0))})"
+            for i, t in enumerate(playlist)
+        )
+        buf.set_text(lines)
+        sw.add(tv)
+        box.pack_start(sw, True, True, 0)
+
+        self.status_label = Gtk.Label(label="Bereit zum Brennen.", xalign=0)
+        self.status_label.set_line_wrap(True)
+        box.pack_start(self.status_label, False, False, 0)
+
+        self.progress = Gtk.ProgressBar()
+        self.progress.set_show_text(True)
+        box.pack_start(self.progress, False, False, 0)
+
+        btn_box = Gtk.Box(spacing=8, halign=Gtk.Align.END)
+        btn_box.set_margin_top(4)
+
+        self.cancel_btn = Gtk.Button(label="Abbrechen")
+        self.cancel_btn.connect("clicked", self._on_cancel)
+        btn_box.pack_start(self.cancel_btn, False, False, 0)
+
+        self.burn_btn = Gtk.Button(label="Jetzt brennen")
+        self.burn_btn.get_style_context().add_class("suggested-action")
+        self.burn_btn.connect("clicked", self._on_burn_clicked)
+        btn_box.pack_start(self.burn_btn, False, False, 0)
+
+        box.pack_start(btn_box, False, False, 0)
+        self.show_all()
+
+    def _on_burn_clicked(self, _):
+        missing = check_dependencies()
+        if missing:
+            self._set_status("Fehlende Programme: " + ", ".join(missing))
+            return
+        self.burn_btn.set_sensitive(False)
+        self.cancel_btn.set_sensitive(False)
+        self._burning = True
+        threading.Thread(target=self._burn_thread, daemon=True).start()
+
+    def _on_cancel(self, _):
+        if self._burning:
+            self.cancelled = True
+        else:
+            self.response(Gtk.ResponseType.CANCEL)
+
+    def _on_burn_done(self):
+        self._burning = False
+        self.cancel_btn.set_label("Schließen")
+        self.cancel_btn.set_sensitive(True)
+
+    def _set_status(self, text):
+        GLib.idle_add(self.status_label.set_text, text)
+
+    def _set_progress(self, fraction, text=""):
+        def _update():
+            self.progress.set_fraction(fraction)
+            if text:
+                self.progress.set_text(text)
+        GLib.idle_add(_update)
+
+    def _burn_thread(self):
+        tmpdir = tempfile.mkdtemp(prefix="jellyfin_burn_")
+        wav_files = []
+
+        try:
+            total = len(self.playlist)
+            for i, track in enumerate(self.playlist):
+                if self.cancelled:
+                    return
+                name = track.get("Name", f"track_{i+1}")
+                artist = track_artist(track)
+                self._set_status(f"Lade: {artist} - {name} ({i+1}/{total})")
+                self._set_progress(i / total / 2, f"Download {i+1}/{total}")
+
+                url = self.client.get_download_url(track["Id"])
+                resp = self.client.session.get(url, stream=True)
+                resp.raise_for_status()
+
+                src_path = os.path.join(tmpdir, f"track_{i+1:02d}_src")
+                with open(src_path, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=65536):
+                        f.write(chunk)
+
+                wav_path = os.path.join(tmpdir, f"track_{i+1:02d}.wav")
+                self._set_status(f"Konvertiere: {name}")
+                result = subprocess.run(
+                    ["ffmpeg", "-y", "-i", src_path,
+                     "-ar", "44100", "-ac", "2", "-f", "wav", wav_path],
+                    capture_output=True, text=True,
+                )
+                if result.returncode != 0:
+                    self._set_status(
+                        f"Konvertierung fehlgeschlagen: {name}\n{result.stderr.strip()[-400:]}"
+                    )
+                    return
+                wav_files.append(wav_path)
+                os.unlink(src_path)
+                self._set_progress((i + 1) / total / 2, f"Konvertiert {i+1}/{total}")
+
+            if self.cancelled:
+                return
+
+            self._set_status("Starte Brennvorgang – bitte nicht abbrechen...")
+            self._set_progress(0.5, "Brennen...")
+
+            device = resolve_sg_device(self.config.get("cd_device", "/dev/sr0"))
+            speed = self.config.get("burn_speed", 4)
+            burn_tool = get_burn_tool()
+            if not burn_tool:
+                self._set_status("Kein Brennprogramm gefunden.\nBitte installieren: sudo apt install cdrskin")
+                return
+            cmd = [burn_tool, f"dev={device}", f"speed={speed}", "-v", "-dao", "-audio", "-pad"] + wav_files
+
+            def _raise_memlock():
+                try:
+                    soft, hard = resource.getrlimit(resource.RLIMIT_MEMLOCK)
+                    if hard == resource.RLIM_INFINITY:
+                        resource.setrlimit(resource.RLIMIT_MEMLOCK,
+                                           (resource.RLIM_INFINITY, resource.RLIM_INFINITY))
+                    elif hard > soft:
+                        resource.setrlimit(resource.RLIMIT_MEMLOCK, (hard, hard))
+                except Exception:
+                    pass
+
+            proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+                                    text=True, preexec_fn=_raise_memlock)
+            output_lines = []
+            for line in proc.stdout:
+                line = line.strip()
+                output_lines.append(line)
+                if "%" in line or "Track" in line or "Writing" in line:
+                    self._set_status(line)
+
+            proc.wait()
+            if proc.returncode == 0:
+                self._set_status("CD erfolgreich gebrannt!")
+                self._set_progress(1.0, "Fertig!")
+            else:
+                full = "\n".join(output_lines[-20:])
+                if "RLIMIT_MEMLOCK" in full or "mmap" in full:
+                    hint = (
+                        f"Brenner-Fehler (Code {proc.returncode}) – Speicher-Lock-Problem.\n\n"
+                        "Lösung: cdrskin installieren (empfohlen):\n"
+                        "  sudo apt install cdrskin\n\n"
+                        "Oder Rechte für wodim setzen:\n"
+                        "  sudo setcap cap_ipc_lock+ep $(which wodim)\n\n"
+                        f"Ausgabe:\n{full}"
+                    )
+                    self._set_status(hint)
+                else:
+                    self._set_status(f"Brenner-Fehler (Code {proc.returncode}):\n{full}")
+
+        except Exception as e:
+            self._set_status(f"Fehler: {e}")
+        finally:
+            for f in wav_files:
+                try:
+                    os.unlink(f)
+                except OSError:
+                    pass
+            try:
+                os.rmdir(tmpdir)
+            except OSError:
+                pass
+            GLib.idle_add(self._on_burn_done)