michael/ripster
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bugfix and Docs

Browse Source
This commit is contained in:
mboehmlaender
2026-03-10 13:12:57 +00:00
parent 3516ff8486
commit ac4d77dddf
75 changed files with 3511 additions and 5142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

129
docs/getting-started/configuration.md
View File

@@ -1,118 +1,99 @@
# Konfiguration
Alle Einstellungen werden über die Web-Oberfläche unter **Einstellungen** verwaltet und in der SQLite-Datenbank gespeichert.
Die Hauptkonfiguration erfolgt über die UI (`Settings`) und wird in SQLite gespeichert.
---
## Pflichteinstellungen
## Pflichteinstellungen vor dem ersten Rip
Diese Einstellungen müssen vor dem ersten Rip konfiguriert werden:
### Pfade
### 1) Pfade
| Einstellung | Beschreibung | Beispiel |
|------------|-------------|---------|
| `raw_dir` | Verzeichnis für rohe MKV-Dateien | `/mnt/nas/raw` |
| `movie_dir` | Ausgabeverzeichnis für kodierte Filme | `/mnt/nas/movies` |
| `log_dir` | Verzeichnis für Log-Dateien | `/var/log/ripster` |
| `raw_dir` | Basisverzeichnis für RAW-Rips | `/mnt/ripster/raw` |
| `movie_dir` | Basisverzeichnis für finale Encodes | `/mnt/ripster/movies` |
| `log_dir` | Verzeichnis für Prozess-/Backend-Logs | `/mnt/ripster/logs` |
!!! warning "Berechtigungen"
Der Ripster-Prozess benötigt **Schreibrechte** auf alle konfigurierten Verzeichnisse.
Optional profilspezifisch:
```bash
# Verzeichnisse erstellen und Berechtigungen setzen
sudo mkdir -p /mnt/nas/{raw,movies}
sudo chown $USER:$USER /mnt/nas/{raw,movies}
```
- `raw_dir_bluray`, `raw_dir_dvd`, `raw_dir_other`
- `movie_dir_bluray`, `movie_dir_dvd`, `movie_dir_other`
### OMDb API
### 2) Tools
| Einstellung | Standard |
|------------|---------|
| `makemkv_command` | `makemkvcon` |
| `handbrake_command` | `HandBrakeCLI` |
| `mediainfo_command` | `mediainfo` |
### 3) OMDb
| Einstellung | Beschreibung |
|------------|-------------|
| `omdb_api_key` | API-Key von omdbapi.com |
| `omdb_default_type` | Standard-Suchtyp: `movie` oder `series` |
| `omdb_default_type` | `movie`, `series`, `episode` |
---
## Tool-Konfiguration
## Encode-Konfiguration (wichtig)
| Einstellung | Standard | Beschreibung |
|------------|---------|-------------|
| `makemkv_command` | `makemkvcon` | Pfad oder Befehl für MakeMKV |
| `handbrake_command` | `HandBrakeCLI` | Pfad oder Befehl für HandBrake |
| `mediainfo_command` | `mediainfo` | Pfad oder Befehl für MediaInfo |
Ripster arbeitet profilspezifisch, typischerweise über:
!!! tip "Absolute Pfade"
Falls die Tools nicht im `PATH` sind, verwende absolute Pfade:
```
/usr/local/bin/HandBrakeCLI
```
- Blu-ray: `handbrake_preset_bluray`, `handbrake_extra_args_bluray`, `output_extension_bluray`, `filename_template_bluray`
- DVD: `handbrake_preset_dvd`, `handbrake_extra_args_dvd`, `output_extension_dvd`, `filename_template_dvd`
---
### Template-Platzhalter
## Encoding-Konfiguration
Verfügbar in `filename_template_*` und `output_folder_template_*`:
| Einstellung | Standard | Beschreibung |
|------------|---------|-------------|
| `handbrake_preset` | `H.265 MKV 1080p30` | HandBrake-Preset-Name |
| `handbrake_extra_args` | _(leer)_ | Zusätzliche HandBrake-Argumente |
| `output_extension` | `mkv` | Dateiendung der Ausgabedatei |
| `filename_template` | `{title} ({year})` | Template für Dateinamen |
- `${title}`
- `${year}`
- `${imdbId}`
### Dateiname-Template
Beispiel:
Das Template unterstützt folgende Platzhalter:
| Platzhalter | Beschreibung | Beispiel |
|------------|-------------|---------|
| `{title}` | Filmtitel | `Inception` |
| `{year}` | Erscheinungsjahr | `2010` |
| `{imdb_id}` | IMDb-ID | `tt1375666` |
| `{type}` | `movie` oder `series` | `movie` |
**Beispiel-Template:**
```
{title} ({year})
→ Inception (2010).mkv
```text
${title} (${year})
-> Inception (2010).mkv
```
---
## Laufwerk-Konfiguration
## MakeMKV-spezifisch
| Einstellung | Standard | Beschreibung |
|------------|---------|-------------|
| `drive_mode` | `auto` | `auto` (automatisch erkennen) oder `explicit` (festes Gerät) |
| `drive_device` | `/dev/sr0` | Geräte-Pfad (nur bei `explicit`) |
| `disc_poll_interval_ms` | `4000` | Polling-Intervall in Millisekunden |
| Einstellung | Standard | Hinweis |
|------------|---------|--------|
| `makemkv_min_length_minutes` | `60` | Kandidaten-Filter |
| `makemkv_rip_mode_bluray` | `backup` | `mkv` oder `backup` |
| `makemkv_rip_mode_dvd` | `mkv` | `mkv` oder `backup` |
| `makemkv_registration_key` | leer | optional, wird via `makemkvcon reg` gesetzt |
---
## MakeMKV-Konfiguration
## Monitoring & Queue
| Einstellung | Standard | Beschreibung |
|------------|---------|-------------|
| `makemkv_min_length_minutes` | `15` | Mindestlänge für Titel in Minuten |
| `makemkv_backup_mode` | `false` | Backup-Modus statt MKV-Modus |
!!! info "Backup-Modus"
Im Backup-Modus erstellt MakeMKV eine vollständige Kopie der Disc (inkl. Menüs). Der Standardmodus erstellt direkt MKV-Dateien.
| Einstellung | Standard |
|------------|---------|
| `hardware_monitoring_enabled` | `true` |
| `hardware_monitoring_interval_ms` | `5000` |
| `pipeline_max_parallel_jobs` | `1` |
---
## Benachrichtigungen (PushOver)
## PushOver (optional)
| Einstellung | Beschreibung |
|------------|-------------|
| `pushover_user_key` | Dein PushOver User-Key |
| `pushover_api_token` | API-Token deiner PushOver-App |
Basis:
Nach der Eingabe kann die Verbindung mit dem **Test-Button** geprüft werden.
- `pushover_enabled`
- `pushover_token`
- `pushover_user`
Zusätzlich pro Event ein/aus (z. B. `pushover_notify_job_finished`).
---
## Vollständige Einstellungsreferenz
## Verwandte Doku
Eine vollständige Liste aller Einstellungen mit Typen, Validierung und Standardwerten findest du unter:
[:octicons-arrow-right-24: Einstellungsreferenz](../configuration/settings-reference.md)
- [Einstellungsreferenz](../configuration/settings-reference.md)
- [Umgebungsvariablen](../configuration/environment.md)

109
docs/getting-started/installation.md
View File

@@ -11,50 +11,46 @@ cd ripster
---
## Automatischer Start
Ripster enthält ein `start.sh`-Skript, das alle Abhängigkeiten installiert und Backend + Frontend gleichzeitig startet:
## Dev-Start (empfohlen)
```bash
./start.sh
```
Das Skript führt automatisch folgende Schritte durch:
`start.sh`:
1. **Node.js-Versionscheck** – prüft ob >= 20.19.0 verfügbar ist (mit nvm/npx-Fallback)
2. **Abhängigkeiten installieren** – `npm install` für Root, Backend und Frontend
3. **Dienste starten** – Backend und Frontend werden parallel gestartet
1. prüft Node-Version (`>= 20.19.0`)
2. installiert Dependencies (Root/Backend/Frontend)
3. startet Backend + Frontend parallel
!!! success "Erfolgreich gestartet"
- Backend läuft auf `http://localhost:3001`
- Frontend läuft auf `http://localhost:5173`
Danach:
- Backend: `http://localhost:3001`
- Frontend: `http://localhost:5173`
Stoppen: mit `Ctrl+C` im laufenden Terminal.
---
## Manuelle Installation
Falls du mehr Kontrolle benötigst:
## Manuell starten
```bash
# Root-Abhängigkeiten
npm install
npm --prefix backend install
npm --prefix frontend install
npm run dev
```
# Backend-Abhängigkeiten
cd backend && npm install && cd ..
Oder getrennt:
# Frontend-Abhängigkeiten
cd frontend && npm install && cd ..
# Backend starten (Terminal 1)
cd backend && npm run dev
# Frontend starten (Terminal 2)
cd frontend && npm run dev
```bash
npm run dev:backend
npm run dev:frontend
```
---
## Umgebungsvariablen konfigurieren
## Optional: .env-Dateien anlegen
### Backend
@@ -62,13 +58,13 @@ cd frontend && npm run dev
cp backend/.env.example backend/.env
```
Bearbeite `backend/.env`:
Beispiel:
```env
PORT=3001
DB_PATH=./data/ripster.db
CORS_ORIGIN=http://localhost:5173
LOG_DIR=./logs
CORS_ORIGIN=http://localhost:5173
LOG_LEVEL=info
```
@@ -78,63 +74,30 @@ LOG_LEVEL=info
cp frontend/.env.example frontend/.env
```
Bearbeite `frontend/.env`:
Beispiel:
```env
VITE_API_BASE=http://localhost:3001
VITE_WS_URL=ws://localhost:3001
```
!!! tip "Alle Umgebungsvariablen"
Eine vollständige Übersicht aller Umgebungsvariablen findest du unter [Umgebungsvariablen](../configuration/environment.md).
---
## Datenbank initialisieren
Die SQLite-Datenbank wird **automatisch** beim ersten Start erstellt und mit dem Schema aus `db/schema.sql` initialisiert. Es sind keine manuellen Datenbankschritte erforderlich.
```
backend/data/
└── ripster.db ← Wird automatisch angelegt
VITE_API_BASE=/api
# optional:
# VITE_WS_URL=ws://localhost:3001/ws
```
---
## Stoppen
## Datenbank
```bash
./kill.sh
SQLite wird automatisch beim Backend-Start initialisiert:
```text
backend/data/ripster.db
```
Das Skript beendet Backend- und Frontend-Prozesse graceful.
---
## Verzeichnisstruktur nach Installation
```
ripster/
├── backend/
│ ├── data/ ← SQLite-Datenbank (nach erstem Start)
│ ├── logs/ ← Log-Dateien
│ ├── node_modules/ ← Backend-Abhängigkeiten
│ └── .env ← Backend-Konfiguration
├── frontend/
│ ├── node_modules/ ← Frontend-Abhängigkeiten
│ ├── dist/ ← Production-Build (nach npm run build)
│ └── .env ← Frontend-Konfiguration
└── node_modules/ ← Root-Abhängigkeiten (concurrently etc.)
```
Schema-Quelle: `db/schema.sql`
---
## Nächste Schritte
Nach erfolgreicher Installation:
1. Öffne [http://localhost:5173](http://localhost:5173)
2. Navigiere zu **Einstellungen**
3. Konfiguriere Pfade, API-Keys und Encoding-Presets
[:octicons-arrow-right-24: Zur Konfiguration](configuration.md)
1. Browser öffnen: `http://localhost:5173`
2. In `Settings` Pfade/Tools/API-Keys prüfen
3. Erste Disc einlegen und Workflow starten

9
docs/getting-started/prerequisites.md
View File

@@ -145,15 +145,6 @@ Für mobile Push-Benachrichtigungen bei Fertigstellung oder Fehlern:
- App kaufen auf [pushover.net](https://pushover.net) (~5 USD einmalig)
- **User Key** und **API Token** notieren
### SSH-Zugang (Deployment)
Für Remote-Deployment via `deploy-ripster.sh`:
```bash
# sshpass installieren
sudo apt-get install sshpass
```
---
## Checkliste

481
docs/getting-started/quickstart.md
View File

@@ -1,411 +1,114 @@
# Schnellstart – Vollständiger Workflow
# Schnellstart – Erster kompletter Job
Nach der [Installation](installation.md) und [Konfiguration](configuration.md) führt diese Seite Schritt für Schritt durch den ersten Rip – mit allen Details aus dem Code.
Diese Seite führt durch den typischen ersten Lauf.
---
## Übersicht: Pipeline-Ablauf
<div class="pipeline-steps">
<div class="pipeline-step">
<div class="pipeline-step-badge step-idle">●</div>
<div class="pipeline-step-label">IDLE</div>
<div class="pipeline-step-sub">Warten</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-idle">1</div>
<div class="pipeline-step-label">DISC_DETECTED</div>
<div class="pipeline-step-sub">Disc erkannt</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-running">2</div>
<div class="pipeline-step-label">METADATA_SELECTION</div>
<div class="pipeline-step-sub">OMDb &amp; Dialog</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-wait">⚠</div>
<div class="pipeline-step-label">WAITING_FOR_USER_DECISION</div>
<div class="pipeline-step-sub">Playlist wählen<br><em>(nur bei Obfusk.)</em></div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-user">3</div>
<div class="pipeline-step-label">READY_TO_START</div>
<div class="pipeline-step-sub">Bereit</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-running">4</div>
<div class="pipeline-step-label">RIPPING</div>
<div class="pipeline-step-sub">MakeMKV</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-running">5</div>
<div class="pipeline-step-label">MEDIAINFO_CHECK</div>
<div class="pipeline-step-sub">HandBrake-Scan</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-user">6</div>
<div class="pipeline-step-label">READY_TO_ENCODE</div>
<div class="pipeline-step-sub">Track-Review</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-encode">7</div>
<div class="pipeline-step-label">ENCODING</div>
<div class="pipeline-step-sub">HandBrake</div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-encode">8*</div>
<div class="pipeline-step-label">POST-ENCODE</div>
<div class="pipeline-step-sub">Skripte<br><em>(innerhalb ENCODING)</em></div>
</div>
<div class="pipeline-step">
<div class="pipeline-step-badge step-done">✓</div>
<div class="pipeline-step-label">FINISHED</div>
<div class="pipeline-step-sub">Fertig</div>
</div>
</div>
**Legende:** <span style="color:#546e7a">● Warten</span> &nbsp;|&nbsp; <span style="color:#1565c0">■ Läuft automatisch</span> &nbsp;|&nbsp; <span style="color:#3949ab">■ Benutzeraktion</span> &nbsp;|&nbsp; <span style="color:#e65100">⚠ Optional</span> &nbsp;|&nbsp; <span style="color:#6a1b9a">■ Encodierung</span> &nbsp;|&nbsp; <span style="color:#2e7d32">✓ Fertig</span>
??? note "Vollständiges Zustandsdiagramm (inkl. Fehler- &amp; Alternativpfade)"
<div class="pipeline-diagram">
```mermaid
flowchart LR
START(( )) --> IDLE
IDLE -->|Disc erkannt| DD[DISC_DETECTED]
DD -->|Analyse starten| META[METADATA\nSELECTION]
META -->|Metadaten übernommen| RTS[READY_TO\nSTART]
META -->|vorhandenes RAW +\nPlaylist offen| WUD[WAITING_FOR\nUSER_DECISION]
RTS -->|Auto-Start| RIP[RIPPING]
RTS -->|Auto-Start mit RAW| MIC[MEDIAINFO\nCHECK]
RIP -->|MKV fertig| MIC
RIP -->|Fehler| ERR
MIC -->|Playlist offen (Backup)| WUD
WUD -->|Playlist bestätigt| MIC
WUD -->|Playlist bestätigt,\nnoch kein RAW| RTS
MIC --> RTE[READY_TO\nENCODE]
RTE -->|Encoding starten| ENC[ENCODING]
ENC -->|inkl. Post-Skripte| FIN([FINISHED])
ENC -->|Fehler| ERR
ERR([ERROR]) -->|Retry / Cancel| IDLE
style FIN fill:#e8f5e9,stroke:#66bb6a,color:#2e7d32
style ERR fill:#ffebee,stroke:#ef5350,color:#c62828
style WUD fill:#fff8e1,stroke:#ffa726,color:#e65100
style ENC fill:#f3e5f5,stroke:#ab47bc,color:#6a1b9a
```
</div>
---
## Schritt 1 – Ripster starten
## 1) Starten
```bash
cd ripster
./start.sh
```
Öffne [http://localhost:5173](http://localhost:5173) im Browser. Das Dashboard zeigt `IDLE`.
Öffne `http://localhost:5173`.
---
## Schritt 2 – Disc einlegen → `DISC_DETECTED`
## 2) Disc einlegen
Lege eine DVD oder Blu-ray ein. Der `diskDetectionService` pollt das Laufwerk alle `disc_poll_interval_ms` Millisekunden (Standard: 4 Sekunden).
Pipeline wechselt auf `DISC_DETECTED`.
**Was passiert im Code:**
- `diskDetectionService` emittiert `discInserted` mit Geräteinformationen
- `pipelineService.onDiscInserted()` wird aufgerufen
- Dashboard-Status-Badge zeigt **"Medium erkannt"**
- Status-Text zeigt **"Neue Disk erkannt"**
- Der **"Analyse starten"**-Button wird aktiv
!!! tip "Manuelle Auslösung"
Falls die automatische Erkennung nicht greift:
```bash
curl -X POST http://localhost:3001/api/pipeline/analyze
```
---
## Schritt 3 – Analyse starten → `METADATA_SELECTION`
Klicke auf **"Analyse starten"**.
**Was passiert im Code:**
1. Ein neuer Job-Datensatz wird in der Datenbank angelegt (`status: METADATA_SELECTION`)
2. Ripster versucht, den Titel automatisch aus dem Disc-Label/Modell zu ermitteln
3. Mit diesem erkannten Titel wird sofort eine **OMDb-Suche** ausgelöst
4. Der `MetadataSelectionDialog` öffnet sich im Frontend mit den vorgeladenen Suchergebnissen
**Erkannter Titel:** Der Disc-Label (z. B. `INCEPTION`) wird als Suchbegriff verwendet. Falls kein Label vorhanden, bleibt das Suchfeld leer.
---
## Schritt 4 – Metadaten auswählen (`MetadataSelectionDialog`)
Der Dialog zeigt vorgeladene OMDb-Suchergebnisse. Du kannst:
### 4a) OMDb-Suchergebnis wählen
```
┌─────────────────────────────────────────────────┐
│ Suche: [Inception ] 🔍 │
├─────────────────────────────────────────────────┤
│ ▶ Inception (2010) · Movie · tt1375666 │
│ Inception: ... · Series · ... │
├─────────────────────────────────────────────────┤
│ [Auswahl übernehmen] │
└─────────────────────────────────────────────────┘
```
- Suche durch Titel anpassen und Enter drücken
- Typ-Filter: `movie` / `series` umschalten möglich
- Einen Eintrag anklicken, dann **"Auswahl übernehmen"**
### 4b) Manuelle Eingabe (ohne OMDb)
Falls kein passendes Ergebnis gefunden wird:
- Titel, Jahr und IMDb-ID manuell eingeben
- OMDb-Poster wird übersprungen
**Was passiert nach Bestätigung:**
Ripster ruft `pipelineService.selectMetadata()` auf und startet den nächsten Schritt automatisch:
- Job wird auf `READY_TO_START` gesetzt (kurzer Übergangszustand)
- Falls bereits RAW vorhanden: direkter Sprung zu `MEDIAINFO_CHECK`
- Falls kein RAW vorhanden: automatischer Start von `RIPPING`
- Wenn bereits andere Jobs laufen, landet der Start stattdessen in der Queue
---
## Schritt 5 – Optional: Playlist-Auswahl → `WAITING_FOR_USER_DECISION`
Dieser Zustand erscheint nur bei mehrdeutigen Blu-ray-Playlists (typisch nach RAW-Analyse im Backup-Modus).
Der **Playlist-Auswahl-Dialog** erscheint **zusätzlich** (nach dem Metadaten-Dialog):
```
┌───────────────────────────────────────────────────────────────┐
│ Playlist-Auswahl │
│ Es wurden mehrere Titel mit ähnlicher Laufzeit gefunden. │
│ Bitte wähle die korrekte Playlist: │
├───────────┬──────────┬────────┬──────────────────────────────┤
│ Playlist │ Laufzeit │ Score │ Bewertung │
├───────────┼──────────┼────────┼──────────────────────────────┤
│ ● 00800 │ 2:28:05 │ +18 │ wahrscheinlich korrekt │
│ │ │ │ (lineare Segmentfolge) │
├───────────┼──────────┼────────┼──────────────────────────────┤
│ ○ 00801 │ 2:28:12 │ −4 │ Auffällige Segmentreihenfolge │
├───────────┼──────────┼────────┼──────────────────────────────┤
│ ○ 00900 │ 2:28:05 │ −32 │ Fake-Struktur │
│ │ │ │ (alternierendes Sprungmuster) │
└───────────┴──────────┴────────┴──────────────────────────────┘
847 Playlists insgesamt · 3 relevante Kandidaten (≥ 15 min)
Empfehlung: 00800 (vorausgewählt)
[Playlist übernehmen]
```
- Die empfohlene Playlist ist **vorausgewählt** (Checkbox)
- Score und Bewertungslabel helfen bei der Entscheidung
- Nach **"Playlist übernehmen"** setzt Ripster automatisch fort:
- mit vorhandenem RAW in `MEDIAINFO_CHECK`
- ohne RAW über `READY_TO_START` weiter Richtung `RIPPING`
!!! info "Scoring-Details"
Wie die Scores berechnet werden, erklärt die [Playlist-Analyse](../pipeline/playlist-analysis.md)-Seite.
---
## Schritt 6 – Ripping → `RIPPING`
**Vorher prüft Ripster:** Existiert bereits eine Raw-Datei für diesen Job?
- **Ja, Raw-Datei vorhanden** → Direkt zu Schritt 7 (Track-Review), kein erneutes Ripping
- **Nein** → MakeMKV-Ripping startet
Im Standardfall startet Ripster diesen Schritt automatisch nach der Metadaten-Auswahl.
Der Button **"Job starten"** ist hauptsächlich für Sonderfälle sichtbar (z. B. Fallback/Queue).
**Was MakeMKV ausführt (MKV-Modus):**
Falls nötig manuell neu scannen:
```bash
makemkvcon mkv disc:0 all /mnt/raw/Inception-2010/ \
--minlength=900 -r
curl -X POST http://localhost:3001/api/pipeline/rescan-disc
```
**Was MakeMKV ausführt (Backup-Modus):**
---
## 3) Analyse starten
Klicke im Dashboard auf `Analyse starten`.
Intern:
- Job wird angelegt
- MakeMKV-Analyse läuft (`ANALYZING`)
- UI wechselt in Metadatenauswahl (`METADATA_SELECTION`)
---
## 4) Metadaten bestätigen
Im Dialog:
- OMDb-Ergebnis wählen oder manuell eintragen
- bei Playlist-Abfrage ggf. `selectedPlaylist` wählen
Nach Bestätigung startet Ripster automatisch weiter.
---
## 5) Pipeline-Pfade
Abhängig von Job/RAW-Situation:
- **kein RAW vorhanden** -> `RIPPING`
- **RAW vorhanden** -> `MEDIAINFO_CHECK`
- **mehrdeutige Playlist** -> `WAITING_FOR_USER_DECISION`
Wenn Parallel-Limit erreicht ist, wird der Job in die Queue eingereiht.
---
## 6) Review (`READY_TO_ENCODE`)
Im Review-Panel:
- Titel auswählen (falls mehrere)
- Audio-/Subtitle-Tracks auswählen
- optional User-Preset anwenden
- optional Pre-/Post-Skripte und Ketten hinzufügen
Mit `Encoding starten` wird `confirm-encode` + Start ausgelöst.
---
## 7) Encoding (`ENCODING`)
Während Encoding:
- Live-Fortschritt/ETA über WebSocket
- Pre-Encode-Ausführungen laufen vor HandBrake
- Post-Encode-Ausführungen laufen nach HandBrake
Wichtig:
- Pre-Encode-Fehler -> Job endet in `ERROR`
- Post-Encode-Fehler -> Job kann `FINISHED` bleiben, aber mit Fehlerhinweis im Status/Log
---
## 8) Abschluss (`FINISHED`)
Ergebnis:
- Ausgabe in `movie_dir` (ggf. profilspezifisch)
- Job in Historie sichtbar
- Logs im konfigurierten `log_dir`
---
## Nützliche API-Shortcuts
```bash
makemkvcon backup disc:0 /mnt/raw/Inception-2010-backup/ \
--decrypt -r
# Pipeline-Snapshot
curl http://localhost:3001/api/pipeline/state
# Queue-Snapshot
curl http://localhost:3001/api/pipeline/queue
# Jobs
curl http://localhost:3001/api/history
```
**Live-Fortschritt** wird aus der MakeMKV-Ausgabe geparst:
```
PRGV:2048,0,65536 → Fortschritt wird berechnet und per WebSocket gesendet
PRGT:5011,0,"Sichern..." → Aktueller Task-Name
```
**Typische Dauer:**
- DVD: 20–45 Minuten
- Blu-ray: 45–120 Minuten
---
## Schritt 7 – Track-Review → `READY_TO_ENCODE`
Nach dem Ripping, nach Playlist-Übernahme oder direkt bei vorhandenem RAW startet der **HandBrake-Scan**:
```bash
HandBrakeCLI --scan -i <quelle> -t 0
```
Dieser Scan liest alle Tracks aus ohne zu encodieren. Ripster baut daraus den Encode-Plan mit automatischer Vorauswahl:
**Status: `MEDIAINFO_CHECK`** – läuft automatisch, kein Benutzereingriff
Danach öffnet sich das **Encode-Review-Panel** (`READY_TO_ENCODE`):
```
┌─────────────────────────────────────────────────────────────────┐
│ Encode-Review │
│ Titel: Disc Title 1 · Laufzeit: 2:28:05 · 28 Kapitel │
├─────────────────────────────────────────────────────────────────┤
│ Audio-Spuren │
├──────┬─────────────────────────────┬───────────────────────────┤
│ ☑ │ Track 1: English (AC3, 5.1) │ Copy (ac3) │
│ ☑ │ Track 2: Deutsch (DTS, 5.1) │ Fallback Transcode (av_aac)│
│ ☐ │ Track 3: Français (AC3, 2.0) │ Nicht übernommen │
├──────┴─────────────────────────────┴───────────────────────────┤
│ Untertitel-Spuren │
├──────┬─────────────────────────────┬────────┬──────┬──────────┤
│ ☑ │ Track 1: Deutsch │ Einbr.☐ │Forc.☐│Default☑ │
│ ☐ │ Track 2: English │ Einbr.☐ │Forc.☐│Default☐ │
├──────┴─────────────────────────────┴────────┴──────┴──────────┤
│ [Encoding starten] │
└─────────────────────────────────────────────────────────────────┘
```
### Audio-Track-Aktionen verstehen
| Symbol/Text | Bedeutung |
|------------|-----------|
| `Copy (ac3)` | Track wird **verlustfrei** direkt übernommen |
| `Copy (truehd)` | TrueHD-Track wird direkt übernommen |
| `Transcode (av_aac)` | Track wird zu AAC umgewandelt |
| `Fallback Transcode (av_aac)` | Copy nicht möglich → automatisch zu AAC |
| `Preset-Default (HandBrake)` | HandBrake-Preset entscheidet |
| `Nicht übernommen` | Track ist nicht ausgewählt |
### Untertitel-Flags
| Flag | Bedeutung |
|------|-----------|
| **Einbrennen** | Untertitel werden fest ins Video gebrannt (nur ein Track möglich) |
| **Forced** | Nur erzwungene Untertitel-Einblendungen übernehmen |
| **Default** | Diese Spur wird beim Abspielen automatisch aktiviert |
### Vorauswahl-Regeln
Die Tracks mit `☑` wurden nach der Regel aus den Einstellungen automatisch vorausgewählt (`selectedByRule: true`). Die Auswahl kann frei geändert werden.
Klicke **"Encoding starten"** (bzw. im Pre-Rip-Modus **"Backup + Encoding starten"**), um fortzufahren.
Falls die Auswahl noch nicht bestätigt wurde, übernimmt das Frontend die Bestätigung automatisch beim Start.
---
## Schritt 8 – Encoding → `ENCODING`
HandBrake startet mit dem finalisierten Plan:
```bash
HandBrakeCLI \
-i /dev/sr0 \
-o "/mnt/movies/Inception (2010).mkv" \
-t 1 \
--preset "H.265 MKV 1080p30" \
-a 1,2 \
-E copy:ac3,av_aac \
-s 1 \
--subtitle-default 1
```
**Live-Fortschritt** wird aus HandBrake-stderr geparst:
```
Encoding: task 1 of 1, 73.50 % (45.23 fps, avg 44.12 fps, ETA 00h12m34s)
```
Das Dashboard zeigt:
- Fortschrittsbalken (0–100 %)
- Aktuelle Encoding-Geschwindigkeit (FPS)
- Geschätzte Restzeit (ETA)
**Typische Dauer (abhängig von CPU/GPU und Preset):**
- Schnelles Preset (`fast`): 0.5× Echtzeit
- Standard-Preset: 1–3× Echtzeit
- Langsames Preset (`slow`): 5–10× Echtzeit
---
## Schritt 9 – Fertig! → `FINISHED`
```
/mnt/nas/movies/
└── Inception (2010).mkv ✓ Encodierung abgeschlossen
```
- Job-Status in der Datenbank: `FINISHED`
- PushOver-Benachrichtigung (falls konfiguriert)
- Eintrag in der [History](http://localhost:5173/history) mit vollständigen Logs
---
## Fehlerbehandlung
### Job im Status `ERROR`
1. **Dashboard**: Details-Button → Log-Ausgabe prüfen
2. **Retry**: Job vom Fehlerzustand neu starten (behält Metadaten)
3. **History**: Vollständige Logs und Fehlerdetails
### Häufige Fehlerursachen
| Fehler | Ursache | Lösung |
|-------|---------|--------|
| MakeMKV: Lizenzfehler | Abgelaufene Beta-Lizenz | Neue Lizenz im [MakeMKV-Forum](https://www.makemkv.com/forum/viewtopic.php?t=1053) |
| HandBrake: Preset nicht gefunden | Preset-Name falsch | `HandBrakeCLI --preset-list` prüfen |
| Keine Disc erkannt | Laufwerk-Berechtigungen | `sudo chmod a+rw /dev/sr0` |
| Falsches Video (zerstückelt) | Falsche Playlist | Job re-encodieren mit anderer Playlist |
| OMDb: Keine Ergebnisse | API-Key fehlt oder Titel nicht gefunden | Einstellungen prüfen; manuell eingeben |
---
## Kurzübersicht aller Schritte
| # | Status | Benutzeraktion | Was Ripster tut |
|--|--------|---------------|----------------|
| 1 | `IDLE` | Disc einlegen | Disc-Polling erkennt Disc |
| 2 | `DISC_DETECTED` | "Analyse starten" klicken | Job anlegen, OMDb vorsuchen |
| 3 | `METADATA_SELECTION` | Film im Dialog auswählen | Start automatisch einplanen/auslösen |
| 4 | `READY_TO_START` | meist keine | Übergangszustand vor Auto-Start |
| 5 | `RIPPING` | Warten | MakeMKV rippt, Fortschritt streamen |
| 6 | `MEDIAINFO_CHECK` | Warten | HandBrake-Scan, Encode-Plan bauen |
| 7 | `WAITING_FOR_USER_DECISION` (optional) | Playlist manuell wählen | Auf Bestätigung warten |
| 8 | `READY_TO_ENCODE` | Tracks prüfen + "Encoding starten" | Auswahl übernehmen, Start auslösen |
| 9 | `ENCODING` | Warten | HandBrake encodiert, inkl. Post-Skripte |
| 10 | `FINISHED` | — | Datei fertig, Benachrichtigung senden |