dschlueter 41378e8a10 Add test utilities and Jellyfin audio conventions doc

- test_ean_scan.py: interactive EAN barcode scanning test via scanner server
- test_backcover_scan.py: comprehensive backcover metadata extraction test
- docs/Grundsaetzliche_Audio_Koventionen_und_Methoden_Jellyfin.md: notes on
  audio conventions and naming methods for Jellyfin

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

2026-02-20 11:59:02 +01:00

33 KiB

Raw Blame History

Ich digitalisiere gerade meine große CD Sammlung. Wie kann ich die Metadaten mit den Musikdateien verbinden?

Du verbindest die Infos (Titel, Album, Artist, Jahr, Cover …) direkt als Tags in den Dateien – je nach Format z.B. ID3 (MP3) oder Vorbis-Kommentare (FLAC/OGG).¹²

Grundprinzip

Jede Audiodatei enthält ein Tag-Set: Titel, Album, Artist, Tracknummer, Discnummer, Jahr, Genre, Album-Artist, Cover-Art etc.²¹
Jellyfin und andere Player lesen primär diese Tags; die Ordnerstruktur hilft vor allem bei der Album‑Gruppe und Mehrfach‑CDs.³⁴

Wenn du ein GUI‑Tool willst

Mp3tag (läuft auch gut unter Wine) zum massenhaften Bearbeiten von MP3, FLAC, OGG, MP4 usw.⁵⁶
Workflow:
- Album‑Ordner laden.
- Basisdaten (Album, Artist, Jahr, Genre, Album‑Artist) im linken Panel setzen.
- Titel pro Track eintragen (oder aus deiner eigenen Datenquelle reinkopieren).
- Cover als Bilddatei ins Cover‑Feld ziehen → wird eingebettet.⁵

Wenn du es skripten willst (Python)

Nutze die Bibliothek mutagen, die MP3, FLAC, OGG, AAC usw. unterstützt und Tags verlustfrei schreibt.⁷⁸⁹¹⁰
Beispiel für FLAC (pseudocodehaft, an deine Struktur anpassbar):

from mutagen.flac import FLAC
from mutagen.id3 import ID3, APIC
from pathlib import Path

album_dir = Path("/pfad/zum/album")
cover_data = Path(album_dir / "cover.jpg").read_bytes()

tracks = [
    "Titel 1",
    "Titel 2",
    # ...
]

for i, audio_file in enumerate(sorted(album_dir.glob("*.flac")), start=1):
    audio = FLAC(audio_file)
    audio["title"] = tracks[i-1]
    audio["album"] = "Albumname"
    audio["artist"] = "Künstler"
    audio["albumartist"] = "Künstler"
    audio["tracknumber"] = str(i)
    audio["date"] = "1987"
    audio["genre"] = "Rock"
    # Cover einmal pro Datei einbetten
    audio.add_picture({
        "data": cover_data,
        "mime": "image/jpeg",
        "type": 3,  # Front-Cover
        "desc": "Cover"
    })
    audio.save()

Für MP3 verwendest du in mutagen die Klasse mutagen.mp3.MP3 mit ID3‑Frames (TIT2, TALB, TPE1, TPE2, APIC etc.).⁹⁷

Jellyfin‑relevante Felder

Wichtige Tags pro Track:
- Titel (Title)
- Artist (Track‑Artist)
- Album
- Album‑Artist (für Sampler z.B. „Various Artists“)
- Tracknummer, Discnummer (+ Gesamtzahl Discs)
- Jahr / Erscheinungsdatum
- Genre
Wichtige Dateien im Album‑Ordner:
- Eingebettetes Cover im Tag, zusätzlich oft folder.jpg/cover.jpg im Ordner.¹¹³

Ordnerstruktur + Tags

Eine typische, für Jellyfin gut passende Struktur:

Artist/Album (Jahr)/CD1/01 Titel.flac mit passenden Tags (Album, Discnumber=1, Tracknumber=1, …).
Jellyfin kommt auch mit „viel in einem Ordner“ klar, solange die Tags sauber sind, aber mit Album‑Ordnern behältst du als Mensch den Überblick besser.⁴³

Wenn du mir sagst, ob du aktuell FLAC, MP3 oder beides benutzt und ob du lieber bei GUI oder Python bleiben willst, kann ich dir ein konkretes Tagging‑Skript oder Mp3tag‑Preset passend zu deinem Ripping‑Workflow bauen. ¹²¹³¹⁴¹⁵

⁂

Welche Angaben un Meta-Daten sind sinnvoll, wenn ich Audio-CDs oder Audio-CD-Alben in Jellyfin verwalten und präsentien will. Welche Infos benötige ich, welche Infos sind nice to have und in welcher Dateistruktur speichere ich die Daten (meine digitalisierte CD-Sammlung) am besten im Jellyfin Audio-Verzeichnis?

Für Jellyfin zählen vor allem sauber gesetzte Tags in den Dateien und eine halbwegs konsistente Ordnerstruktur pro Album.¹⁶¹⁷

Pflicht-Metadaten (für Jellyfin sinnvoll / „brauche ich“)

Pro Track solltest du mindestens setzen:¹⁷¹⁶

Titel (Title)
Artist (Interpret dieses Tracks)
Album
Album-Artist (für normale Alben = Artist, für Sampler z.B. „Various Artists“)¹⁸¹⁶¹⁷
Tracknummer
Discnummer und Gesamtzahl Discs (Disc number, Total discs) – wichtig für Mehrfach‑CD‑Alben.¹⁹¹⁶
Jahr oder Erscheinungsdatum (Date/Year) – für die zeitliche Sortierung.²⁰¹⁷
Eingebettetes Front-Cover (plus idealerweise folder.jpg im Albumordner) – für die Kachelansicht.¹⁶¹⁷

Ohne diese Felder wirkt die Jellyfin‑Ansicht schnell chaotisch (Alben nicht korrekt gruppiert, falsche Sortierung, keine Cover).²¹¹⁹¹⁶

Sinnvolle Zusatzinfos („nice to have“)

Genre – ermöglicht Genre‑Filter und Smart Playlists.²²¹⁷
Komponist (Composer) – wichtig bei Klassik, Soundtracks.²²¹⁸
Album-Sort, Artist-Sort (sortierbare Varianten, z.B. „Beatles, The“) – für saubere A–Z‑Listen.¹⁸
Originales Erscheinungsjahr getrennt von Re-Release‑Jahr (falls du beides pflegst).²⁰
Kommentar / Tagging-Notizen (z.B. Quelle, Remaster, eigene Kennzeichnung).²²
Mehrere Album-Artists bei Kollaborationen (durch Trenner wie „Artist1; Artist2“ im AlbumArtist‑Feld).²³¹⁸

Jellyfin nutzt diese Felder nicht immer explizit für das UI, aber sie helfen dir bei Filtern, Suchen und konsistenter Darstellung.²³¹⁶¹⁸

Ordner- und Dateistruktur (empfohlen)

Jellyfin: „Ein Album = ein Ordner“, der Rest erfolgt über Tags.¹⁷¹⁶

Top-Level

/media/music als Jellyfin‑Bibliothek vom Typ „Musik“.¹⁷

Album-Struktur

Empfohlenes Schema:¹⁶¹⁷

/media/music/Artist/Album (Jahr)/Trackdateien

Beispiel:¹⁷

/media/music/Daft Punk/Random Access Memories (2013)/01 - Give Life Back to Music.flac

Wichtiges aus der Jellyfin‑Doku:¹⁶

Ein Ordner enthält genau ein Album (bei Mehrfach‑CDs alle Discs dieses Albums).
Jellyfin verlässt sich primär auf die eingebetteten Tags; Dateinamen sind zweitrangig und werden nur genutzt, wenn Tags fehlen.²⁴¹⁶¹⁷

Mehrfach-CD-Alben

Zwei praktikable Varianten, beide funktionieren, solange die Tags stimmen:¹⁶¹⁷

Alles in einem Ordner (empfohlen von Jellyfin):
- /media/music/Artist/Album (Jahr)/101 - Track.flac
- /media/music/Artist/Album (Jahr)/201 - Track.flac oder
- /media/music/Artist/Album (Jahr)/CD1 - 01 - Track.flac
- Tags: discnumber=1/2, discnumber=2/2 usw.¹⁹¹⁶
Unterordner pro Disc (auch ok):
- /media/music/Artist/Album (Jahr)/CD1/01 - Track.flac
- /media/music/Artist/Album (Jahr)/CD2/01 - Track.flac
- Jellyfin nutzt trotzdem die Disc‑Tags zur Gruppierung der Discs, nicht den Ordnernamen.¹⁶

Was darf „chaotisch“ sein?

Du kannst theoretisch alle Tracks in einem großen Ordner halten; Jellyfin kann über Tags trotzdem Alben und Artists bauen.²⁵²⁴
Praktisch hilft dir selbst eine strukturierte Form Artist/Album enorm, z.B. bei Backups, manueller Nacharbeit und Tagging mit externen Tools.²⁴¹⁷

Kurze Empfehlung für dein Projekt

Ripping: immer gleich mit Tags füllen (Titel, Album, Artist, Album‑Artist, Track‑/Discnummer, Jahr, Genre).²²¹⁶
Albumordner: Artist/Album (Jahr)/, bei Multi‑CD optional CD1/, CD2/ darunter.¹⁷¹⁶
In jeden Albumordner: eingebettetes Cover in allen Dateien + folder.jpg (Front), optional back.jpg.¹⁷¹⁶

Wenn du mir ein konkretes Beispiel‑Album gibst (z.B. 3‑CD‑Sammlung, Sampler, Klassik), skizziere ich dir genau, welche Tags du setzen solltest (inkl. Beispiel‑Werten) und wie die Ordner dafür aussehen könnten. ²⁶²⁷²⁸²⁹³⁰

⁂

1. Wie sehen typische Verzeichnis-Bäume für Klassik, Pop, Volksmusik und Sonstige bei Jellyfin aus ? 2. Was muss und kann ich in die Tags der Audio-Dateien schreiben ?

Für Jellyfin kannst du für alle Musikrichtungen denselben Grundaufbau nutzen; Unterschiede liegen vor allem in den Tags (z.B. Komponist bei Klassik).³¹³²

1. Typische Verzeichnisbäume

Jellyfin‑Vorgabe: Ein Ordner enthält genau ein Album (bzw. eine Single‑Veröffentlichung).³³³¹

Pop / Rock / Volksmusik / „Sonstige“

Übliche Struktur:

/music
└── Pop
    ├── Abba
    │   ├── 1976 - Arrival
    │   │   ├── 01 - When I Kissed the Teacher.flac
    │   │   ├── 02 - Dancing Queen.flac
    │   │   └── folder.jpg
    │   └── 1979 - Voulez-Vous
    └── Queen
        └── 1975 - A Night at the Opera

Oder ohne Genre‑Ebene:

/music
└── Abba
    └── Arrival (1976)
        ├── 01 - When I Kissed the Teacher.flac
        └── folder.jpg

Beides funktioniert, da Jellyfin Alben primär über „ein Ordner = ein Album“ und Tags erkennt.³⁴³⁵³¹

Klassik

Hier lohnt sich eine Ebene für Komponisten bzw. Sammler:³²³⁶

Variante A – nach Komponist:

/music-classical
└── Beethoven, Ludwig van
    ├── Symphonies - Karajan (DG, 1963)
    │   ├── CD1
    │   │   ├── 01 - Symphony No.1 - I.flac
    │   │   └── 02 - Symphony No.1 - II.flac
    │   └── folder.jpg
    └── Piano Sonatas - Kempff

Variante B – nach Interpret/Ensemble:

/music-classical
└── Berliner Philharmoniker
    └── Beethoven - Symphonies (Karajan, 1963)
        ├── CD1
        └── folder.jpg

Beide Varianten sind ok; Jellyfin gruppiert letztlich nach Tags (Composer, Album, AlbumArtist).³¹³²

Singles / EPs / Sampler

Singles als „Mini‑Album“ im eigenen Ordner ablegen, damit Jellyfin sie nicht zu Alben zusammenwirft.³³
Sampler/Compilations z.B.:

/music
└── Compilations
    └── Bravo Hits 01 (1992)
        ├── 01 - Track.flac
        └── folder.jpg

Wichtig: AlbumArtist = „Various Artists“, Artist = je Track.³⁷³²

2. Pflicht‑Tags für Jellyfin

Diese Felder solltest du konsequent pro Track setzen, egal ob Klassik, Pop oder Volksmusik:³⁸³¹

Title – Tracktitel.
Album – Albumname exakt gleich für alle Tracks des Albums.³¹
Artist – Interpret des Tracks (bei Klassik meist Solist/Ensemble/Dirigent, nicht der Komponist).³⁶³²
AlbumArtist – „Haupt‑Artist“ des Albums (Band/Interpret, bei Samplern „Various Artists“; bei Kollabos mehrere Artists mit ; oder /).³⁷³¹
Track number – reine Nummer (1, 2, 3 …).
Disc number und Total discs – wichtig für Mehrfach‑CD‑Alben.³⁹³¹
Date/Year – Erscheinungsjahr bzw. Release‑Datum.³⁶³¹
Eingebettetes Cover (Front) in jeder Datei; zusätzlich folder.jpg im Albumordner.⁴⁰³¹

Ohne diese Tags gibt es z.B. falsch gruppierte Alben, fehlende Cover oder durcheinander sortierte Tracks.⁴¹³⁹³¹

3. Sinnvolle Zusatz‑Tags nach Genre

Für Pop / Rock / Volksmusik

Genre – möglichst konsistent (z.B. „Pop“, „Rock“, „Volksmusik“, nicht 20 Varianten).⁴²⁴³
Artist sort / AlbumArtist sort – für „The Beatles“ → „Beatles, The“.³²
Comment – Herkunft (CD, Vinyl‑Rip, Remaster), eigene Kennzeichnung.
Composer – für Singer‑Songwriter oder wichtige Songwriter.³⁶
Lyrics – optional (LRC/embedded), Jellyfin kann Texte darstellen über Plugins.³⁸³⁶

Speziell für Klassik

Jellyfin hat (über MusicBrainz‑Mapping) Felder, die für Klassik nützlich sind:³²³⁶

Composer – Komponist (z.B. „Beethoven, Ludwig van“).
Conductor – Dirigent.
Ensemble/Orchestra – Orchester/Chor.
Performer – Solisten (Violin, Piano etc.).
Work – Werk (z.B. „Symphony No.5 in C minor, Op.67“).
Movement – Satz (z.B. „I. Allegro con brio“).

Viele Tagger (Picard, puddletag, Mp3tag) können diese Felder schreiben; Jellyfin zeigt sie in den Detailansichten und in „People“ an.³²³⁶

Sampler / Compilations

AlbumArtist = „Various Artists“ (wichtig für Listen in Jellyfin).⁴⁴³⁷
Artist = jeweiliger Interpretenname pro Track.
Genre – „Compilation“ oder das eigentliche Genre (z.B. „Pop“), je nach deiner Sortierlogik.⁴³³²

4. Optionale Metadaten / Power‑User-Felder

Mehrere Genres getrennt durch ;, / oder \ (abhängig vom Tool); Plugins können das splitten.⁴³
Mood / Style / Tags (z.B. „melancholic“, „live“, „90s“), um später Sammlungen/Smart Playlists zu bauen.⁴²⁴³
Producer, Writer, Lyricist – wird in „People“ angezeigt, wenn gesetzt.³⁶
ReplayGain‑Tags (track/album gain) – für konsistente Lautstärke; von Jellyfin‑Clients teils unterstützt.³⁸
Lokale .nfo‑Dateien pro Album/Artist, wenn du sehr spezifische Beschreibungen/Bilder pflegen willst.⁴⁵

5. Kurzempfohlene Bäume je Kategorie

Nur als Illustration – passe es an deine Realität an:

/media
├── music-pop
│   └── Artist/Year - Album/Tracks...
├── music-classical
│   └── Composer/Work - Conductor (Label, Year)/CDx/Tracks...
├── music-folk
│   └── Region or Artist/Year - Album/Tracks...
└── music-misc
    └── Thema oder Artist/Album/Tracks...

Die eigentliche „Intelligenz“ liegt in den Tags; die Bäume dienen dir vor allem zur menschlichen Orientierung und für getrennte Jellyfin‑Bibliotheken (z.B. Pop, Klassik, Hörbücher).⁴⁶⁴⁴³¹

Wenn du magst, können wir im nächsten Schritt ein konkretes Tag‑Schema für „Beispiel‑Klassik‑Album (3 CDs)“ vs. „Pop‑Album (1 CD)“ durchdeklinieren, inkl. Beispielwerten für alle relevanten Felder. ⁴⁷⁴⁸

⁂

ja

Dann machen wir zwei konkrete Beispiele: ein 3‑CD‑Klassik‑Album und ein 1‑CD‑Pop‑Album, jeweils mit Baum + Tags.

Beispiel 1: Klassik‑Album, 3 CDs

Verzeichnisbaum

/music-classical
└── Beethoven, Ludwig van
    └── Symphonies - Karajan (DG, 1963)
        ├── CD1
        │   ├── 01 - Symphony No.1 - I.flac
        │   ├── 02 - Symphony No.1 - II.flac
        │   └── ...
        ├── CD2
        │   ├── 01 - Symphony No.3 - I.flac
        │   └── ...
        ├── CD3
        │   ├── 01 - Symphony No.5 - I.flac
        │   └── ...
        └── folder.jpg

Tags pro Track (Muss)

Für alle Tracks des Albums:

Album: Beethoven: Symphonies (Karajan, 1963)
AlbumArtist: Herbert von Karajan; Berliner Philharmoniker (oder nur Herbert von Karajan, je nach Systematik)
Date/Year: 1963
Genre: Classical

Pro Track:

Title: Symphony No.5 in C minor, Op.67: I. Allegro con brio
Artist: Berliner Philharmoniker; Herbert von Karajan
Track number: 1, 2, 3 … (je CD neu beginnend)
Disc number: 1, 2 oder 3
Total discs: 3
Embedded Cover: front cover als Bild im Tag

Tags pro Track (empfohlen für Klassik)

Composer: Beethoven, Ludwig van
Conductor: Herbert von Karajan
Ensemble/Orchestra: Berliner Philharmoniker
Work: Symphony No.5 in C minor, Op.67
Movement: I. Allegro con brio
Artist sort: Karajan, Herbert von; Berliner Philharmoniker
Composer sort: Beethoven, Ludwig van

Damit kann Jellyfin sauber nach Komponist, Dirigent, Album und ggf. Werk sortieren.⁴⁹⁵⁰⁵¹

Beispiel 2: Pop‑Album, 1 CD

Verzeichnisbaum

/music-pop
└── Queen
    └── A Night at the Opera (1975)
        ├── 01 - Death on Two Legs.flac
        ├── 02 - Lazing on a Sunday Afternoon.flac
        ├── ...
        └── folder.jpg

Tags pro Track (Muss)

Für alle Tracks des Albums:

Album: A Night at the Opera
AlbumArtist: Queen
Date/Year: 1975
Genre: Rock

Pro Track:

Title: Bohemian Rhapsody
Artist: Queen
Track number: 11 (oder entsprechend)
Disc number: 1
Total discs: 1
Embedded Cover: front cover

Tags pro Track (empfohlen)

Artist sort: Queen (oder bei „The Beatles“ z.B. Beatles, The)
Composer: Freddie Mercury (optional)
Comment: CD rip 2026-02, remaster 2011 o.ä.
Mehrere Genres: z.B. Rock; Classic Rock (je nach Tagger‑Trenner)

Damit erscheinen in Jellyfin Artist‑Ansicht, Album‑Ansicht und Sortierung so, wie man es von „normaler“ Pop‑Sammlung erwartet.⁵⁰⁵²⁴⁹

Kurz: Was du dir als „Schema“ merken kannst

Klassik:
- Ordner: nach Komponist oder Ensemble, pro Aufnahme ein Albumordner, CD‑Unterordner optional.
- Tags: Composer, Conductor, Ensemble, Work, Movement + Standardfelder (Album, AlbumArtist, Track/Disc, Year, Genre).
Pop/Volksmusik/Sonstige:
- Ordner: /Genre/Artist/Year - Album/Trackdateien.
- Tags: Album, AlbumArtist, Artist, Track/Disc, Year, Genre, optional Composer, Artist sort.

Wenn du willst, können wir als nächstes ein JSON‑Schema/Mapping definieren (z.B. wie dein Programm die Infos intern speichert und dann in Tags + Ordnernamen ausspielt).

⁂

ja

Dann skizziere ich dir ein schlankes JSON‑Schema, das du als interne „Album-Definition“ nutzen kannst; daraus kannst du Ordnernamen + Tags generieren.⁵³⁵⁴

JSON‑Schema für ein Album

{
  "album_id": "beethoven-karajan-dg-1963",
  "category": "classical",              
  "library": "music-classical",         

  "album": {
    "title": "Beethoven: Symphonies (Karajan, 1963)",
    "sort_title": "Beethoven: Symphonies (Karajan, 1963)",
    "year": 1963,
    "original_year": 1963,
    "label": "Deutsche Grammophon",
    "genres": ["Classical"],
    "album_artist": "Herbert von Karajan; Berliner Philharmoniker",
    "album_artist_sort": "Karajan, Herbert von; Berliner Philharmoniker"
  },

  "classical": {
    "composer": "Beethoven, Ludwig van",
    "composer_sort": "Beethoven, Ludwig van",
    "conductor": "Herbert von Karajan",
    "ensemble": "Berliner Philharmoniker"
  },

  "discs": [
    {
      "disc_number": 1,
      "disc_title": "Symphonies Nos. 1 & 2",
      "tracks": [
        {
          "track_number": 1,
          "title": "Symphony No.1 in C major, Op.21: I. Adagio molto – Allegro con brio",
          "work": "Symphony No.1 in C major, Op.21",
          "movement": "I. Adagio molto – Allegro con brio",
          "artists": ["Berliner Philharmoniker", "Herbert von Karajan"],
          "soloists": [],
          "comment": ""
        }
      ]
    }
  ],

  "artwork": {
    "front": "cover_front.jpg",
    "back": "cover_back.jpg",
    "booklet": ["booklet_01.jpg", "booklet_02.jpg"]
  }
}

Pop‑Album wäre dasselbe Schema, nur ohne classical‑Block und ohne work/movement, dafür ggf. lyrics, writer etc.⁵⁴

Mapping: JSON → Ordnername

Aus obigem Objekt generierst du z.B.:

/media/<library>/
  Composer oder Artist /
    "<year> - <album.title>"/
      "CD<disc_number>"/"TT - Title.ext"

Klassik‑Beispiel:

/media/music-classical/Beethoven, Ludwig van/
  1963 - Beethoven: Symphonies (Karajan, 1963)/
    CD1/01 - Symphony No.1 in C major, Op.21- I. Adagio molto – Allegro con brio.flac

Pop‑Beispiel:

"category": "pop",
"library": "music-pop",
"album": { "title": "A Night at the Opera", "year": 1975, "album_artist": "Queen" }

→

/media/music-pop/Queen/1975 - A Night at the Opera/01 - Death on Two Legs.flac

Mapping: JSON → Tag‑Felder

Pro Track kannst du in deinem Tagger (mutagen oder ähnlich) so mappen:⁵⁵⁵⁴

Pflichtfelder:

TITLE ← track.title
ALBUM ← album.title
ALBUMARTIST ← album.album_artist
ARTIST ← join(track.artists)
TRACKNUMBER ← track.track_number
DISCNUMBER ← disc.disc_number
DISCTOTAL ← len(discs)
DATE / YEAR ← album.year
GENRE ← join(album.genres)

Klassik‑Zusatz:

COMPOSER ← classical.composer
CONDUCTOR ← classical.conductor
ENSEMBLE/ORCHESTRA ← classical.ensemble
WORK ← track.work
MOVEMENT ← track.movement

Sonstige:

COMMENT ← track.comment oder globaler Kommentar
ALBUMSORT ← album.sort_title
ALBUMARTISTSORT← album.album_artist_sort

Cover:

Front‑Cover aus artwork.front als Embedded‑Bild + als folder.jpg im Albumordner.⁵⁶⁵³

Wenn du möchtest, formuliere ich dir im nächsten Schritt ein kleines Python‑Pseudomodul, das genau dieses JSON einliest und daraus Ordner + FLAC‑Tags erzeugt (inkl. Hook für dein Ripping‑Ergebnis).

⁂

ja

Hier ist ein kompaktes Python‑Grundgerüst, das dein JSON einliest, Verzeichnisse anlegt und FLAC‑Tags mit Mutagen setzt.⁵⁷⁵⁸⁵⁹⁶⁰

Annahmen

Du hast pro Album eine JSON‑Datei wie im letzten Beispiel.
Die gerippten FLACs liegen schon in einem „Roh“-Ordner (z.B. input_disc1/track01.flac usw.).
Dein Skript baut Zielordner + Dateinamen und schreibt alle Tags.

Beispielmodul `album_builder.py`

from pathlib import Path
import json
from mutagen.flac import FLAC

BASE_DIR = Path("/media")  # Root für deine Libraries

def load_album(json_path: Path) -> dict:
    with json_path.open("r", encoding="utf-8") as f:
        return json.load(f)

def build_album_path(album_meta: dict) -> Path:
    lib = album_meta["library"]          # z.B. "music-classical"
    cat = album_meta["category"]         # "classical" / "pop" ...
    album = album_meta["album"]
    classical = album_meta.get("classical", {})

    if cat == "classical":
        composer = classical.get("composer_sort") or classical.get("composer") or "Unknown"
        base = BASE_DIR / lib / composer
    else:
        artist = album.get("album_artist_sort") or album.get("album_artist") or "Unknown"
        base = BASE_DIR / lib / artist

    year = album.get("year")
    title = album["title"]
    folder_name = f"{year} - {title}" if year else title
    return base / folder_name

def build_track_filename(disc_number: int, track_number: int, title: str, ext="flac") -> str:
    tn = f"{track_number:02d}"
    return f"{tn} - {title}.{ext}"

def tag_flac_file(
    file_path: Path,
    album_meta: dict,
    disc_meta: dict,
    track_meta: dict,
    total_discs: int,
    cover_data: bytes | None = None,
):
    album = album_meta["album"]
    classical = album_meta.get("classical", {})

    audio = FLAC(file_path)

    # Grundtags
    audio["TITLE"] = track_meta["title"]
    audio["ALBUM"] = album["title"]
    audio["ALBUMARTIST"] = album["album_artist"]
    audio["ARTIST"] = "; ".join(track_meta.get("artists") or [album["album_artist"]])
    audio["TRACKNUMBER"] = str(track_meta["track_number"])
    audio["DISCNUMBER"] = str(disc_meta["disc_number"])
    audio["DISCTOTAL"] = str(total_discs)

    if "year" in album:
        audio["DATE"] = str(album["year"])
    if album.get("genres"):
        audio["GENRE"] = "; ".join(album["genres"])

    # Klassik‑Tags
    if album_meta.get("category") == "classical":
        if "composer" in classical:
            audio["COMPOSER"] = classical["composer"]
        if "conductor" in classical:
            audio["CONDUCTOR"] = classical["conductor"]
        if "ensemble" in classical:
            audio["ENSEMBLE"] = classical["ensemble"]
        if track_meta.get("work"):
            audio["WORK"] = track_meta["work"]
        if track_meta.get("movement"):
            audio["MOVEMENT"] = track_meta["movement"]

    # Sortierfelder
    if album.get("sort_title"):
        audio["ALBUMSORT"] = album["sort_title"]
    if album.get("album_artist_sort"):
        audio["ALBUMARTISTSORT"] = album["album_artist_sort"]

    # Kommentar
    if track_meta.get("comment"):
        audio["COMMENT"] = track_meta["comment"]

    # Cover einbetten (einheitliches Front‑Cover pro Album)
    if cover_data is not None:
        from mutagen.flac import Picture
        pic = Picture()
        pic.data = cover_data
        pic.type = 3  # Front Cover
        pic.mime = "image/jpeg"
        pic.desc = "Cover"
        audio.clear_pictures()
        audio.add_picture(pic)

    audio.save()

def process_album(json_path: Path, input_root: Path):
    album_meta = load_album(json_path)
    target_album_dir = build_album_path(album_meta)
    target_album_dir.mkdir(parents=True, exist_ok=True)

    # Cover in Ordner kopieren + Bytes laden
    artwork = album_meta.get("artwork", {})
    front_name = artwork.get("front")
    cover_bytes = None
    if front_name:
        cover_src = json_path.parent / front_name
        if cover_src.is_file():
            cover_bytes = cover_src.read_bytes()
            cover_dst = target_album_dir / "folder.jpg"
            if cover_src.suffix.lower() != ".jpg":
                cover_dst.write_bytes(cover_bytes)
            else:
                if cover_src.resolve() != cover_dst.resolve():
                    cover_dst.write_bytes(cover_bytes)

    discs = album_meta["discs"]
    total_discs = len(discs)

    for disc in discs:
        disc_no = disc["disc_number"]
        disc_title = disc.get("disc_title")

        # CD‑Unterordner optional:
        if total_discs > 1:
            disc_dir = target_album_dir / f"CD{disc_no}"
            disc_dir.mkdir(parents=True, exist_ok=True)
        else:
            disc_dir = target_album_dir

        # Hier musst du definieren, wo die Roh‑Files liegen:
        # z.B. input_root/<album_id>/disc<nr>/trackXX.flac
        raw_disc_dir = input_root / album_meta["album_id"] / f"disc{disc_no}"

        for track in disc["tracks"]:
            src_file = raw_disc_dir / f"track{track['track_number']:02d}.flac"
            filename = build_track_filename(disc_no, track["track_number"], track["title"])
            dst_file = disc_dir / filename

            dst_file.parent.mkdir(parents=True, exist_ok=True)
            dst_file.write_bytes(src_file.read_bytes())

            tag_flac_file(
                dst_file,
                album_meta=album_meta,
                disc_meta=disc,
                track_meta=track,
                total_discs=total_discs,
                cover_data=cover_bytes,
            )

if __name__ == "__main__":
    import sys
    if len(sys.argv) != 3:
        print("Usage: album_builder.py <album.json> <input_root>")
        sys.exit(1)
    json_path = Path(sys.argv[^6_1])
    input_root = Path(sys.argv[^6_2])
    process_album(json_path, input_root)

Mutagen‑Tag‑Zugriff ist hier im FLAC‑Stil als dict‑Interface umgesetzt, wie in der Doku beschrieben.⁵⁸⁵⁷
Verzeichnisanlage nutzt Path.mkdir(parents=True, exist_ok=True), wie in üblichen Best‑Practices für verschachtelte Ordner gezeigt.⁵⁹⁶⁰

Wenn du mir ein konkretes JSON für ein reales Album und den aktuellen Speicherort deiner Roh‑Files schickst, passe ich dir Pfade, Dateinamensschema und Tag‑Mapping exakt darauf an. ⁶¹⁶²⁶³⁶⁴⁶⁵⁶⁶⁶⁷⁶⁸⁶⁹⁷⁰⁷¹

⁂

33 KiB Raw Blame History Unescape Escape

Ich digitalisiere gerade meine große CD Sammlung. Wie kann ich die Metadaten mit den Musikdateien verbinden?

Grundprinzip

Wenn du ein GUI‑Tool willst

Wenn du es skripten willst (Python)

Jellyfin‑relevante Felder

Ordnerstruktur + Tags

Pflicht-Metadaten (für Jellyfin sinnvoll / „brauche ich“)

Sinnvolle Zusatzinfos („nice to have“)

Ordner- und Dateistruktur (empfohlen)

Top-Level

Album-Struktur

Mehrfach-CD-Alben

Was darf „chaotisch“ sein?

Kurze Empfehlung für dein Projekt

1. Wie sehen typische Verzeichnis-Bäume für Klassik, Pop, Volksmusik und Sonstige bei Jellyfin aus ? 2. Was muss und kann ich in die Tags der Audio-Dateien schreiben ?

1. Typische Verzeichnisbäume

Pop / Rock / Volksmusik / „Sonstige“

Klassik

Singles / EPs / Sampler

2. Pflicht‑Tags für Jellyfin

3. Sinnvolle Zusatz‑Tags nach Genre

Für Pop / Rock / Volksmusik

Speziell für Klassik

Sampler / Compilations

4. Optionale Metadaten / Power‑User-Felder

5. Kurzempfohlene Bäume je Kategorie

ja

Beispiel 1: Klassik‑Album, 3 CDs

Verzeichnisbaum

Tags pro Track (Muss)

Tags pro Track (empfohlen für Klassik)

Beispiel 2: Pop‑Album, 1 CD

Verzeichnisbaum

Tags pro Track (Muss)

Tags pro Track (empfohlen)

Kurz: Was du dir als „Schema“ merken kannst

ja

JSON‑Schema für ein Album

Mapping: JSON → Ordnername

Mapping: JSON → Tag‑Felder

ja

Annahmen

Beispielmodul album_builder.py

33 KiB

Raw Blame History

Beispielmodul `album_builder.py`