dschlueter a55bd8eabb initial commit

2026-02-15 01:00:12 +01:00

27 KiB

Raw Blame History

``` # Ein neues Programmier-Projekt: Ich möchte meine Musik-CD-Sammlung digitalisieren und sie für Jellyfin aufbereiten. Mit einem entsprechendem Programm kann ich die Audio-Tracks auslesen und in einem Verzeichnis speichern. Die Dateien heißen dann "Track_01.", Track_02., usw. , wobe für das Dateiformat und die dazu gehörende Endung steht ("wav", "mp3", "ogg", "flac", "opus", ...) steht. Diese Dateinamen sagen wenig aus. Deshalb möchte ich statt "Track" die Titel der Songs als Namen verwenden. Die zweistellige Nummer (mit eventuell führender 0) soll ganz vorn stehen. Aber ich will die Titel nicht von Hand eingeben. Diese Aufgabe sollen KI-Tools übernehmen. Ich will ein Foto vom Inhaltsverzeichnis oder der Cover-Rückseite machen und es mit OCR oder KI so auswerten lassen, dass am Ende ein Text mit CD-Namen und allen Titeln in der korrekten Reihenfolge herauskommt. Wenn das Objekt aus mehreren CDs besteht, soll das auch in der Verzeichnisstruktur abgebildet werden. Das Foto von der Titelseite soll als digitales Cover benutzt werden. Auch die Rückseite wird als Foto gespeichert. Bei diesem Workflow soll möglichst viel automatisch erfolgen. Input des Projektes ist ein Verzeichnis (oder mit mehreren Unterverzeichnissen für die einzelnen CDs) mit jeweils n Soundtracks, den Fotos vom Cover, der Rückseite und dem möglicherweise separat fotografierten Inhaltsverzeichnis. Output soll dieselbe Verzeichnisstruktur mit Namen für die CD , die Unterverzeichnisse ("CD1","CD2", ...) und für die Titel (mit entsprechenden Endungen) sein. Außerdem soll es noch einen Jellyfin-kompatible Playlist für die CDs, bzw. Alben geben. Denke gründlich nach und mach mir dann Vorschläge, wie ich das realisieren könnte. ```

Du kannst das ziemlich elegant automatisieren, wenn du drei Bausteine kombinierst: OCR/LLM für die Trackliste, ein kleines Rename-/Tagging-Skript und eine Playlist-Generierung.¹²³

Zielstruktur und Jellyfin-Besonderheiten

Für Jellyfin ist bei Musik vor allem die eingebettete Metadatenstruktur wichtig, Dateinamen sind zweitrangig, solange sie sauber sind (keine Sonderzeichen wie : ? * etc.).⁴¹ Empfehlenswerte Struktur:

Artist/Album (Year)/CD1/01 Titel.ext
Artist/Album (Year)/CD2/01 Titel.ext bei Mehrfach-CDs
Cover-Datei im Album-Ordner, z.B. cover.jpg (Front) und back.jpg (Rückseite); Jellyfin kann Cover aus Tags und aus Bilddateien im Ordner ziehen.¹

Pipeline grob skizziert

End-to-End-Workflow, wie du ihn skripten kannst:

Du ripst die CD(s) in ein temporäres Verzeichnis, z.B. rip/album_raw/CD1/Track_01.flac usw.
Du machst Fotos:
- Frontcover
- Rückseite (mit Trackliste)
- ggf. Innenseite/Buchlet, wenn die Rückseite unlesbar ist.
Skript-Pipeline:
- OCR auf die Tracklisten-Bilder → Rohtext.
- LLM-Prompting: Rohtext + Foto-Kontext → strukturiertes JSON mit album_title, artist, disc_number, track_number, track_title, year usw.
- Rename & Tagging:
  - Zuordnung Track_01.* → 01 Tracktitel.ext nach JSON.
  - Ordner umbenennen: Album (Year), CD1, CD2 usw.
  - Cover-Bilder in cover.jpg / back.jpg umbenennen und in Album-Root legen.
  - Audio-Tags setzen (Artist, Album, Track, TrackNr, DiscNr, Year, AlbumArtist).
- Playlist(s) erzeugen: Für jedes Album / jede CD eine Albumname.m3u im Album-Ordner mit relativen Pfaden.⁵

OCR + KI-Extraktion

Unter Linux bieten sich für OCR primär Tesseract und Calamari/Ocropus an.²³

OCR-Schritt:
- tesseract back.jpg ocr_out --psm 6 -l deu+eng → ocr_out.txt.²
LLM-Schritt:
- Prompt ungefähr: „Hier ist der OCR-Text der Rückseite einer Audio-CD. Extrahiere Artist, Albumtitel, Veröffentlichungsjahr (falls vorhanden) und für jede CD (CD1, CD2…) die Tracks in Reihenfolge. Gib reines JSON im Format … aus.“
- Dein Script ruft z.B. eine lokale LLM-API (oder OpenAI/Perplexity) an und bekommt parsebares JSON zurück.

Beispiel-Ziel-JSON (vereinfacht):

{
  "artist": "Example Artist",
  "album": "Example Album",
  "year": 1999,
  "discs": [
    {
      "disc_number": 1,
      "tracks": [
        { "track_number": 1, "title": "First Song" },
        { "track_number": 2, "title": "Second Song" }
      ]
    }
  ]
}

Benennung, Tagging und Mehrfach-CDs

Dateinamen

Regeln, die du im Script umsetzt:

Zuordnung nach Tracknummer:
- Sortiere die vorhandenen Dateien Track_01.ext numerisch.
- Mappe Track_01.ext → JSON-Eintrag track_number == 1.
Neuer Name: "{track_number:02d} {title}.{ext}".
Für Mehrfach-CD:
- Input-Struktur z.B. album_raw/CD1/*.flac, album_raw/CD2/*.flac.
- Pro Unterordner eigenes disc_number-JSON verwenden und Ausgabe in Album (Year)/CD1/…, Album (Year)/CD2/….

Tags schreiben

Für Jellyfin relevant sind saubere Audio-Tags; es liest bei Musik primär diese und nicht Dateinamen.⁴¹

Tools:
- ffmpeg / metaflac / eyeD3 / id3v2 / Python mit mutagen.
Pro Datei:
- artist / albumartist (z.B. Artist oder „Various Artists“)
- album
- title
- track (Nummer, optional /total)
- disc (bei Mehrfach-CD)
- date oder year
Cover als Embedded Art:
- ffmpeg -i "01 First Song.flac" -i cover.jpg -map 0 -map 1 -c copy -metadata:s:v title="Cover" -metadata:s:v comment="Front cover" out.flac (oder metaflac --import-picture-from=cover.jpg).⁶
- Zusätzlich cover.jpg im Ordner lassen, falls du nicht überall einbetten willst.¹

Playlists für Jellyfin

Jellyfin kann M3U-Playlists importieren; du kannst sie direkt im Album-Ordner ablegen.⁵

Format: simple m3u:

#EXTM3U
#EXTINF:0,First Song
CD1/01 First Song.flac
#EXTINF:0,Second Song
CD1/02 Second Song.flac

Für Mehrfach-CD:
- Entweder eine Playlist pro CD (Album (CD1).m3u, Album (CD2).m3u)
- Oder eine gemeinsame Album.m3u mit Tracks aus CD1, dann CD2 in Reihenfolge.
Wichtig: Relative Pfade zum Playlist-Standort benutzen, dann bleiben sie portabel, auch wenn du den gesamten Musikordner verschiebst.⁵

Konkrete Projekt-Architektur

Aufbau als Python-CLI-Tool bietet sich an, mit Subcommands:

rip-organizer ocr album_raw/ Läuft Tesseract über definierte Bilddateien (z.B. cover_back.jpg, inlay*.jpg) und speichert ocr.txt.
rip-organizer parse ocr.txt > album.json Ruft LLM-API, bekommt strukturiertes JSON.
rip-organizer apply album_raw/ album.json output_root/
- Legt Artist/Album (Year)/CDx/ an
- Verschiebt/benennt Tracks
- Schreibt Tags
- Kopiert cover_front.jpg → cover.jpg, cover_back.jpg → back.jpg
- Baut .m3u-Playlists.

Für deinen Use-Case könntest du auch alles in einem Durchlauf machen:

rip-organizer process \
  --input album_raw/ \
  --cover-front front.jpg \
  --cover-back back.jpg \
  --output /srv/media/Musik/

Ergänzung: MusicBrainz-Picard als Fallback

Falls OCR/LLM mal scheitert oder du keine Fotos machen willst, kannst du viele CDs auch einfach über MusicBrainz identifizieren lassen; Picard nutzt AcoustID-Fingerprints und kann Cover laden.⁷⁶

Idee: Dein Tool versucht zuerst, anhand der gerippten Dateien eine MusicBrainz-Match zu finden (über Picard-CLI oder eigene API-Nutzung).
Falls eindeutig → nimm diese Metadaten.
Falls nicht → fallback auf dein OCR/LLM-Verfahren.

So minimierst du manuelle Nacharbeit und bekommst häufig sogar bessere/standardisierte Tags und Cover.⁷⁶

Wenn du möchtest, kann ich dir im nächsten Schritt ein konkretes Python-Skelett mit mutagen (Tagging), Tesseract-Aufruf und einer einfachen JSON-Struktur skizzieren, an dem du weiterbauen kannst. ⁸⁹¹⁰¹¹¹²¹³¹⁴¹⁵

⁂

Vergiss MusicBrainz. Die CDs sind so alt, da findet man nichts in MusicBrains. Wir müssen uns auf OCR und LLMs verlassen.

Dann würde ich den ganzen Workflow konsequent um OCR + LLM herum designen und MusicBrainz komplett rauslassen.¹⁶¹⁷

1. Gesamtarchitektur

Du baust ein Python-CLI-Tool, das auf einem Ordner arbeitet:

Input pro Album:
- raw/ (oder CD1/, CD2/ …) mit Track_01.flac, Track_02.flac, …
- cover_front.jpg
- cover_back.jpg (mit Trackliste) und ggf. booklet_*.jpg
Output:
- /Artist/Album (Year)/CD1/01 Titel.ext
- /Artist/Album (Year)/CD2/01 Titel.ext
- cover.jpg, back.jpg im Album-Root
- Album.m3u bzw. Album (CD1).m3u etc.
- Alle Tags sauber gesetzt (Artist, Album, TrackNr, DiscNr, Year), damit Jellyfin alles über Tags bekommt.¹⁷¹⁶

CLI‑Beispiel:

cd-organizer process \
  --input /pfad/zum/rip \
  --output /srv/media/Musik \
  --front cover_front.jpg \
  --back cover_back.jpg

2. OCR-Schicht

Du verwendest Tesseract direkt von der CLI bzw. via subprocess.¹⁸¹⁹

Für jede relevante Bilddatei:

tesseract cover_back.jpg ocr_back -l deu+eng --dpi 300 --psm 6

Resultate zusammenführen:
- ocr_back.txt, ocr_booklet1.txt, … → alles in einen String.
- Optional Pre-Cleaning (z.B. doppelte Leerzeichen, Zeilen mit nur Trackzeiten/Bitraten filtern).

Für bessere Erkennung:

Auflösung: möglichst 300 dpi oder höher.
Kontrast/Schwarz-Weiß per convert (ImageMagick) verbessern, falls nötig.

3. LLM-Parsing in strukturierte Daten

Kern: Du erzeugst aus dem OCR-Text ein strikt parsebares JSON.

Prompt-Strategie

System/Instruktionsprompt (vereinfacht):

„Du bist ein Parser für CD-Rückseiten und Tracklisten.“
„Analysiere den OCR-Text, ignoriere Werbung/Kleingedrucktes.“
„Gib ausschließlich valid JSON zurück, kein anderes Format.“
„Struktur: { "artist": ..., "album": ..., "year": ..., "discs": [...]}“

User-Content:

Voller OCR-Text
Hinweis auf Mehrfach-CDs:
- „Wenn es Hinweise wie CD1, CD2, Disc 1, Disc 2, Seite A/B gibt, ordne Tracks entsprechend disc_number zu.“
Anweisung zum Umgang mit Unklarheiten:
- „Wenn du dir bei einem Feld unsicher bist, lass es weg oder setze null, errate nichts.“

Ziel-JSON:

{
  "artist": "Example Artist",
  "album": "Example Album",
  "year": 1987,
  "discs": [
    {
      "disc_number": 1,
      "name": "CD1",
      "tracks": [
        { "track_number": 1, "title": "Erster Song" },
        { "track_number": 2, "title": "Zweiter Song" }
      ]
    },
    {
      "disc_number": 2,
      "name": "CD2",
      "tracks": [
        { "track_number": 1, "title": "Dritter Song" }
      ]
    }
  ]
}

Das kannst du lokal (z.B. llamafile, vLLM, ollama) oder gegen einen externen API-Endpunkt machen – entscheidend ist nur, dass du 100 % JSON erzwingst (ggf. nachträglich mit json.loads() + Fehlerbehandlung und Retry).

4. Mapping auf die Audiodateien

Ausgangspunkt: Du hast pro Disc einen Ordner mit Dateien Track_01.ext … Track_nn.ext.

Schritte:

Alle Dateien der Disc sortieren:
- Numerisch nach der Zahl in Track_XX (RegEx Track_(\d+)).
Sicherstellen, dass Anzahl Dateien = Anzahl JSON-Tracks:
- Wenn nicht: Warnung ausgeben, entweder manuell fixen oder einfache Heuristik (z.B. letzte Bonus-Tracks ignorieren).
Map:
- i‑tes File ↔ Track mit track_number == i im JSON.
Neuer Name:
- "{track_number:02d} {title}.{ext}" → z.B. 01 In the Beginning.flac.

5. Ordner- und Dateistruktur bauen

Unter Berücksichtigung der Jellyfin-Empfehlungen: „ein Album pro Ordner, Dateinamen egal, Tags entscheidend“.¹⁶¹⁷

Zielpfad:

/root/Artist/Album (Year)/CD1/...
/root/Artist/Album (Year)/CD2/...

Artist aus JSON, unsichere/fehlende Felder kannst du auf „Unknown Artist“ / „Unknown Album“ mappen.
Year optional in Klammern anfügen.

Das Skript:

Legt Artist-Ordner an, wenn nicht vorhanden.
Legt Album-Ordner an.
Für jede Disc:
- Unterordner CD{disc_number}.
- Verschiebt/benennt Dateien hinein.
cover_front.jpg → cover.jpg, cover_back.jpg → back.jpg ins Album-Root.

6. Tags mit `mutagen` setzen

Mit mutagen kannst du viele Formate einheitlich bearbeiten.²⁰²¹

Pseudo-Python:

from mutagen import File

def tag_file(path, artist, album, albumartist, title, track_no, total_tracks, disc_no, year):
    audio = File(path, easy=True)
    audio["artist"] = artist
    audio["album"] = album
    audio["albumartist"] = albumartist or artist
    audio["title"] = title
    audio["tracknumber"] = f"{track_no}/{total_tracks}"
    if disc_no is not None:
        audio["discnumber"] = str(disc_no)
    if year:
        audio["date"] = str(year)
    audio.save()

Format-Spezifika (kurz):

FLAC/OGG: Vorbis Comments (Mutagen setzt das automatisch).²⁰
MP3: ID3v2 (EasyID3), ggf. explizite Klassen verwenden, falls du Cover einbetten willst.
WAV: Tags sind tricky; wenn möglich lieber FLAC/OGG/MP3 verwenden.

Optional: Cover einbetten (nur nötig, wenn du zusätzlich zu cover.jpg im Ordner embedded Artwork willst):

Für MP3 mit ID3 APIC; FLAC mit PICTURE-Block (mutagen.flac.FLAC.add_picture()).

7. Playlists generieren (M3U)

Jellyfin versteht normale M3U; relative Pfade sind am portabelsten.²²²³

Pro Album:
- Entweder eine Playlist pro CD (z.B. Album (CD1).m3u) oder eine Gesamtplaylist Album.m3u, die alle Discs in Reihenfolge referenziert.
Inhalt (Beispiel Gesamtalbum):

#EXTM3U
#EXTINF:0,Erster Song
CD1/01 Erster Song.flac
#EXTINF:0,Zweiter Song
CD1/02 Zweiter Song.flac
#EXTINF:0,Dritter Song
CD2/01 Dritter Song.flac

Die Pfade sind relativ zum Album-Ordner, in dem die Playlist liegt.²² Du kannst Trackdauer aus den Dateien auslesen, ist aber für Jellyfin nicht zwingend nötig.

8. Umgang mit Mehrfach-CDs im LLM

Damit das bei alten/kruden Layouts robust wird, würde ich im Prompt explizit:

nach Mustern wie „CD 1“, „CD 2“, „CDI“, „CDII“, „Disc One“, „Disc Two“, „Seite 1/2“ suchen lassen,
anweisen, dass bei fehlenden expliziten Disc-Hinweisen alles als disc_number = 1 zu behandeln ist,
track-spezifische Zusätze („live“, „bonus track“, „remastered“) in den Titel integrieren.

Beispiel-Ausschnitt im Prompt:

„Wenn der OCR-Text keine Disc-Angabe hat, gehe von einer einzigen CD mit disc_number = 1 aus. Wenn du Formulierungen wie „CD 1“, „CD 2“, „Disc One“, „Disc Two“ findest, ordne die direkt darunter stehenden Tracks dieser Disc zu.“

9. Fehlertoleranz und manuelle Korrekturen

Damit du nicht in Sackgassen läufst:

Validierungsschritt:
- JSON vs. Dateiliste: Anzahl Tracks, Disc-Anzahl.
- Bei Diskrepanzen optional eine minimale TUI fragen: „Disc 1: 9 Tracks im JSON, 10 Dateien gefunden – letzte Datei ignorieren? (y/n)“.
Log-Datei pro Album (process.log) mit:
- OCR-Dateiname
- verwendetes JSON
- Mapping File ↔ Tracktitel
- Fehler/Warnungen

So kannst du im Zweifel einzelne Alben manuell nachziehen, ohne den Rest zu verlieren.

Wenn du möchtest, kann ich dir im nächsten Schritt ein konkretes Python-Skelett für cd-organizer process mit grober Modulstruktur (ocr.py, llm_client.py, model.py für das JSON, tagging.py, playlist.py, cli.py) skizzieren – so, dass du es direkt in ein Repo kippen und ausbauen kannst. ²⁴²⁵²⁶²⁷²⁸²⁹³⁰³¹

⁂

Können wir das Auto-Ripping nicht auch selbst mit einem Progamm erledigen? Das gäbe uns viel größere Felexibilität in Bezug auf unterschiedliche Konstellationen (Nur 1 CD, Album mit 2 CDS bis Album mit einigen CDs) . Dann erzeugt uns das Programm gleich die Verzeichnisstruktur.

Ja, das Ripping kannst du sehr gut in deinen eigenen Workflow integrieren – ich würde aber nicht „alles selbst“ implementieren, sondern ein bestehendes CLI-Rip-Tool wie abcde oder cdparanoia/icedax aus Python heraus steuern und den Rest (Struktur + Tags) in deinem Programm machen.³²³³³⁴

1. Grundidee: Dein Programm steuert den ganzen Zyklus

Ablauf, wenn eine CD im Laufwerk liegt:

Dein Programm erkennt (/dev/cdrom o.ä.), dass eine CD eingelegt ist.
Es fragt dich minimal interaktiv:
- „Ist das ein Single-Album, 2-CD-Album, Box mit n CDs?“
- oder du gibst eine Box-ID an und legst nacheinander die CDs ein.
Für jede eingelegte CD:
- Ripping via externem Tool (abcde/icedax/cdparanoia) in ein temporäres Verzeichnis.
- Parallel/anschließend: Fotos verarbeiten (OCR+LLM) für das ganze Album/Box-Set.
Wenn alle CDs gerippt sind, baut dein Programm aus dem OCR/LLM-JSON die Ziel-Verzeichnisstruktur (Artist/Album/CD1…, CD2…) und benennt/vertaggt alles passend für Jellyfin.³⁵³⁶

So hast du volle Kontrolle über Mehrfach-CD-Konstellationen, ohne ein eigenes CD-DA-Lesemodul schreiben zu müssen.

2. Ripping-Ebene: abcde als „Engine“ unter deiner Kontrolle

Für Linux ist abcde sehr robust, flexibel und skriptfreundlich.³⁷³³³⁴³²

Du nutzt es nur als „raw ripper“, Metadaten kommen aus deinem LLM, nicht aus CDDB:
- abcde -n -o flac -x -N -p -d /dev/cdrom
  - -n = kein CDDB-Lookup (du willst deine eigenen Tags)³⁴
  - -o flac (oder mp3/ogg/opus, was du willst)³⁴
  - -x = CD auswerfen nach dem Ripping (Qual-of-Life)³⁴
  - -N = non-interaktiv³⁴
  - -p = führende Nullen bei Tracknummern³⁴
In der .abcde.conf kannst du z.B. einstellen, dass:
- in ein von dir bestimmtes Temp-Verzeichnis gerippt wird,
- Dateinamen generisch bleiben (Track_01.flac etc.), weil du sie später selbst umbenennst.³²³⁴

Dein Programm ruft abcde via subprocess.run() auf, wartet, bis der Prozess fertig ist, und weiß dann: „CD X des aktuellen Albums wurde erfolgreich in tmp/album_X/ gerippt“.

Alternativ: direkter Einsatz von cdparanoia/icedax + flac/lame, aber abcde kapselt das alles schon sehr gut.³³³⁸³⁴

3. Multi-CD-Logik in deinem Programm

Du definierst den Album-Kontext nicht über das Rip-Tool, sondern in deiner Anwendung:

Du startest einen „Album-Job“:
- album_id (intern), optional manuell gesetzter Name.
- erwartete Anzahl CDs (kann auch „unbekannt“ sein, dann fragst du, wenn die Box fertig ist).
Für jede CD:
- Dein Programm zeigt z.B. „Bitte CD 1 (von ?/N) einlegen und Enter drücken“.
- Startet abcde mit Zielordner tmp/album_id/CD1.
- Wenn fertig → Disc 1 als „gerippt“ markieren.
Nach CD1, CD2, …:
- Parallel dazu läuft dein OCR+LLM-Prozess auf den Cover/Back-Fotos und erzeugt das JSON mit discs und track_number/title.
- Dein Programm matcht dann CD1 ↔ disc_number: 1, CD2 ↔ disc_number: 2 usw.

Damit kannst du alles abbilden: Single-CD, 2-CD-Album, 10-CD-Box, ohne dass das Rip-Tool davon etwas wissen muss.³⁵

4. Automatische Verzeichnisstruktur ab Ripping-Phase

Weil du beim Start eines Album-Jobs schon weißt, wohin es final gehen soll, kannst du die Struktur direkt ab dem ersten Rip anlegen:

Ziel (Jellyfin-root): /srv/media/Musik/Artist/Album (Year)/CD1, /CD2 …
Dein Programm entscheidet:
- Ab wann es die finalen Ordner anlegt (z.B. nach erfolgreichem OCR/LLM-Parsing).
- Ob es zuerst in tmp/ rippt und dann alles per Move/rename in den finalen Baum schiebt, oder ob du schon während des Rippens in die finalen CDx-Ordner schreibst und später nur noch umbenennst + Tags setzt.

Pragmatisch:

Beim Start eines Album-Jobs:
- tmp/album_id/CD1, tmp/album_id/CD2 …
Nach LLM-Parsing:
- Artist, Album, Year klar → finaler Pfad steht fest.
- Jetzt: mkdir -p /srv/media/Musik/Artist/Album (Year)/CD1 usw.
- Dateien umbenennen und verschieben: Track_01.flac → 01 Songtitle.flac.

5. Vorteil: Einheitliche Logik für alte/komplexe CDs

Mit eigenem Orchestrierungs-Programm und CLI-Ripper hast du:

Gleichen Workflow für:
- Single-CD ohne Booklet (nur Rückseite)
- 2-CD-Album
- 8-CD-Komplettbox
Kein Abhängigkeitschaos mit Online-Datenbanken (du wolltest ja MusicBrainz bewusst vermeiden).
Möglichkeit, die Multi-CD-Logik rein im JSON abzubilden:
- disc_number
- disc_name (z.B. „CD 3 – Live in Berlin“)
Playlist-Generierung direkt nach dem Ripping und Tagging:
- Für jede CD eine eigene M3U
- optional Gesamt-Album-Playlist (alle CDs in Reihe).³⁹³⁵

Wenn du willst, können wir als nächsten Schritt die Architektur deines Programms genauer entwerfen (Module/Klassen, CLI-Interface, State-File pro Album), z.B.:

ripper.py (abcde-Steuerung),
ocr.py,
llm_parser.py,
organizer.py (Struktur + Umbenennung),
tagger.py,
playlist.py,
cli.py mit Subcommands wie start-album, rip-disc, finalize-album. ⁴⁰⁴¹⁴²⁴³⁴⁴⁴⁵⁴⁶⁴⁷

⁂

Bevor wir anfangen: Gibt es so ein Programm bereits ?

Nach allem, was ich kenne: Es gibt viele Programme, die einzelne Teilaspekte abdecken, aber nichts, was genau deinen gewünschten Gesamtworkflow „Rippen + OCR der Cover + LLM‑Parsing + automatische Jellyfin-Verzeichnisstruktur + Playlists“ in einem Guss erledigt.

Typische existierende Lösungen sehen eher so aus:

Klassische CD‑Ripper (EAC, dBpoweramp, abcde, fre:ac, Audiograbber, MediaMonkey, etc.) können:
- CDs zuverlässig rippen.
- Metadaten aus Online-Datenbanken holen.
- Dateien nach bestimmten Mustern benennen und Ordner anlegen.
- Meist einfache Cover-Bilder einbinden oder laden.
Media-Manager (MediaMonkey, JRiver, MusicBee, beets, …) können:
- Bibliothek organisieren, umbennen, taggen.
- Cover laden (online), Playlists erstellen.
Einige Tools können OCR oder mit Online-Diensten Metadaten finden, aber:
- Sie arbeiten fast immer mit großen Musikdatenbanken (MusicBrainz, Discogs, Freedb, etc.).
- Sie nutzen nicht gezielt Fotos der CD-Rückseite als primäre Quelle.
- LLM-Integration für das saubere Strukturieren der OCR-Daten ist bisher sehr exotisch.

Was du haben willst, ist eine Mischung aus:

Headless CD-Ripper-Engine (abcde/whipper o.Ä.) als Backend.
Eigene OCR-Pipeline (Tesseract).
LLM-Schicht, die aus dem OCR-Text ein robustes JSON-Modell für Album/Discs/Tracks baut.
Organizer, der:
- die Dateien passend benennt,
- eine Jellyfin-konforme Album- und Mehrfach-CD-Struktur erzeugt,
- Tags setzt,
- Playlists anlegt.

Genau diese Kombination in einem integrierten Tool ist nach meinem Wissensstand noch nicht als fertiges, allgemein verfügbares Programm umgesetzt worden – das ist genau der interessante „Sweet Spot“ für dein Projekt. ⁴⁸⁴⁹⁵⁰⁵¹⁵²⁵³⁵⁴⁵⁵⁵⁶⁵⁷

⁂

27 KiB Raw Blame History Unescape Escape