Flixy heißt ab hier Halo
Reine Umbenennung, kein Verhalten geändert — bewusst als eigener Commit, damit „umbenannt" und „umgebaut" im Nachhinein auseinanderzuhalten sind. 712 mal `Flixy`, 778 mal `flixy`, 7 mal `FLIXY` in 169 Dateien, dazu 25 Pfade. Ziele: `Halo`, `HaloTV`, `HaloTopShelf`, `HaloUITests`, `HaloKit` mit `HaloDesign`, `HaloDownloads`, `HaloPlayback` und `HaloProbe`. `MediaKit`, `JellyfinKit` und `DownloadWidget` tragen den Namen nicht und bleiben. `docs/superpowers/specs/` ist ausgenommen. Datierte Entwurfsdokumente sind ein Protokoll getroffener Entscheidungen; sie nachträglich umzuschreiben hiesse, die Vergangenheit zu glätten. **Die Bundle-ID wandert mit** — ausdrücklich so gewollt, mit bekanntem Preis: `com.scarriffleservices.halo` ist für iOS eine *andere* App. Die installierte Fassung bleibt daneben stehen, mit Downloads und Anmeldung in ihrem Container; Halo startet leer. Einmal neu anmelden, heruntergeladene Folgen einmal neu laden. Dasselbe gilt für die App-Gruppe, die sich TV-App und Top Shelf teilen. **Eine Folge davon, die beim Entscheiden noch nicht auf dem Tisch lag:** der Aufräumschritt aus dem vorigen Commit kommt an die alten Plex-Token nicht mehr heran. Der Schlüsselbund grenzt nach Team und Bundle-Kennung ab — was unter `…flixy` liegt, ist für `…halo` unerreichbar. Erledigt wird es trotzdem, nur anders: **die alte App löschen.** iOS räumt deren Schlüsselbund-Einträge beim Deinstallieren mit ab. Der Code bleibt stehen, weil er für jeden Stand vor dieser Umbenennung richtig ist und im Jahr einen Startvergleich kostet. Die Projektdatei ist aus `project.yml` neu erzeugt, der alte Ordner gelöscht statt umbenannt — sie steht ohnehin nicht im Repo. Das Verzeichnis des Repos selbst heißt weiter `Flixy`; das umzubenennen ist ein Handgriff ausserhalb des Projekts. 368 Tests grün. iOS und tvOS bauen. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
2fcf6821c8
commit
4b9a1e7b67
@@ -0,0 +1,536 @@
|
||||
// **Nur für den Rechner, auf dem entwickelt wird.**
|
||||
//
|
||||
// Das hier ist ein Kommandozeilenwerkzeug: es fragt nach einem Passwort über
|
||||
// `getpass`, löst Rechnernamen über `Host` auf und druckt in ein Terminal.
|
||||
// Nichts davon gibt es auf iOS, und auf tvOS erst recht nicht — die App
|
||||
// hängt auch nicht daran. Ohne diese Bedingung scheitert aber jeder Versuch,
|
||||
// **das ganze Paket** für eine andere Plattform zu übersetzen, an einem
|
||||
// Werkzeug, das dort nie laufen sollte. Das kostete eine halbe Stunde
|
||||
// Fehlersuche an der falschen Stelle.
|
||||
#if os(macOS)
|
||||
import Foundation
|
||||
import JellyfinKit
|
||||
import MediaKit
|
||||
|
||||
// Die Frage, für die dieser Teil des Werkzeugs gebaut ist:
|
||||
//
|
||||
// Liefert der Server eine HLS-Liste mit **mehreren** Stufen — oder mit
|
||||
// einer?
|
||||
//
|
||||
// Davon hängt alles ab. AVPlayer kann nur zwischen Varianten umschalten, die
|
||||
// in der Liste stehen; bei einer gibt es nichts zu wechseln, und jedes
|
||||
// Nachregeln greift ins Leere. Bisher war das eine Annahme, und zwei
|
||||
// Kommentare im Code haben sie als Tatsache ausgegeben.
|
||||
//
|
||||
// Geprüft wird über HTTP, nicht über einen Build aufs Gerät. Der Token bleibt
|
||||
// im Schlüsselbund; gedruckt werden Stufen und Zahlen, nie eine vollständige
|
||||
// Adresse.
|
||||
|
||||
/// Wie der Server die Herkunft dieser Anfrage einordnet.
|
||||
///
|
||||
/// `isInNetwork` ist genau die Größe, an der Jellyfins ABR-Sperre hängt.
|
||||
struct Endpunktlage: Decodable {
|
||||
let isLocal: Bool
|
||||
let isInNetwork: Bool
|
||||
|
||||
private enum CodingKeys: String, CodingKey {
|
||||
case isLocal = "IsLocal"
|
||||
case isInNetwork = "IsInNetwork"
|
||||
}
|
||||
}
|
||||
|
||||
/// Welche Fassung der Server hat.
|
||||
struct Serverfassung: Decodable {
|
||||
let version: String?
|
||||
private enum CodingKeys: String, CodingKey { case version = "Version" }
|
||||
}
|
||||
|
||||
/// Die Netzwerkeinstellungen des Servers — nur der Teil, der hier zählt.
|
||||
struct Netzwerkeinstellung: Decodable {
|
||||
let knownProxies: [String]?
|
||||
|
||||
private enum CodingKeys: String, CodingKey {
|
||||
case knownProxies = "KnownProxies"
|
||||
}
|
||||
}
|
||||
|
||||
/// Was in einer Playlist steht.
|
||||
struct Leiter {
|
||||
var stufen: [(bandbreite: Int, auflösung: String?)] = []
|
||||
var istMaster = false
|
||||
var zeilen = 0
|
||||
|
||||
var beschreibung: String {
|
||||
guard istMaster else {
|
||||
return " Keine Master-Playlist (\(zeilen) Zeilen) — das ist eine Liste von Schnipseln, keine von Stufen."
|
||||
}
|
||||
guard !stufen.isEmpty else {
|
||||
return " Master-Playlist ohne eine einzige Stufe."
|
||||
}
|
||||
var text = " \(stufen.count) Stufe\(stufen.count == 1 ? "" : "n"):\n"
|
||||
for stufe in stufen.sorted(by: { $0.bandbreite < $1.bandbreite }) {
|
||||
let mbit = String(format: "%.1f", Double(stufe.bandbreite) / 1_000_000)
|
||||
text += " \(mbit) Mbit/s"
|
||||
if let auflösung = stufe.auflösung { text += " · \(auflösung)" }
|
||||
text += "\n"
|
||||
}
|
||||
if stufen.count == 1 {
|
||||
text += " → Eine Stufe. Es gibt nichts, worauf der Player ausweichen könnte.\n"
|
||||
}
|
||||
return text
|
||||
}
|
||||
}
|
||||
|
||||
/// Liest eine Playlist und zählt, was drinsteht.
|
||||
func leiter(in text: String) -> Leiter {
|
||||
var ergebnis = Leiter()
|
||||
let zeilen = text.split(separator: "\n", omittingEmptySubsequences: false)
|
||||
ergebnis.zeilen = zeilen.count
|
||||
|
||||
for zeile in zeilen where zeile.hasPrefix("#EXT-X-STREAM-INF:") {
|
||||
ergebnis.istMaster = true
|
||||
let attribute = zeile.dropFirst("#EXT-X-STREAM-INF:".count)
|
||||
|
||||
func wert(_ name: String) -> String? {
|
||||
// Reicht für BANDWIDTH und RESOLUTION: beide sind unquotiert.
|
||||
guard let bereich = attribute.range(of: "\(name)=") else { return nil }
|
||||
let rest = attribute[bereich.upperBound...]
|
||||
return String(rest.prefix { $0 != "," })
|
||||
}
|
||||
|
||||
guard let roh = wert("BANDWIDTH"), let bandbreite = Int(roh) else { continue }
|
||||
ergebnis.stufen.append((bandbreite, wert("RESOLUTION")))
|
||||
}
|
||||
return ergebnis
|
||||
}
|
||||
|
||||
/// Holt eine Playlist und beurteilt sie.
|
||||
func prüfePlaylist(_ url: URL, kopfzeilen: [String: String] = [:]) async -> String {
|
||||
var request = URLRequest(url: url)
|
||||
for (name, wert) in kopfzeilen { request.setValue(wert, forHTTPHeaderField: name) }
|
||||
|
||||
do {
|
||||
let (daten, antwort) = try await URLSession.shared.data(for: request)
|
||||
let status = (antwort as? HTTPURLResponse)?.statusCode ?? 0
|
||||
guard (200..<300).contains(status) else {
|
||||
return " HTTP \(status) — keine Playlist bekommen."
|
||||
}
|
||||
let text = String(decoding: daten, as: UTF8.self)
|
||||
let gelesen = leiter(in: text)
|
||||
// **Bei einer Stufe den Wortlaut zeigen.** Ab hier hilft keine
|
||||
// Zusammenfassung mehr: was fehlt, sieht man nur im Original.
|
||||
guard gelesen.stufen.count <= 1 else { return gelesen.beschreibung }
|
||||
return gelesen.beschreibung + "\n ——— Wortlaut ———\n"
|
||||
+ text.split(separator: "\n").map { " " + $0 }.joined(separator: "\n")
|
||||
} catch {
|
||||
return " Nicht erreichbar: \(error.localizedDescription)"
|
||||
}
|
||||
}
|
||||
|
||||
/// Setzt einen Abfragewert — vorhandene gleichen Namens werden **ersetzt**.
|
||||
///
|
||||
/// Dieselbe Falle wie bei `maxHeight` im Backend: bei zwei gleichnamigen
|
||||
/// Werten gilt beim Server der erste, und ein danebengestellter zweiter
|
||||
/// bewirkt nichts.
|
||||
func setzend(_ name: String, auf wert: String, in url: URL) -> URL {
|
||||
guard var teile = URLComponents(url: url, resolvingAgainstBaseURL: true) else { return url }
|
||||
var werte = (teile.queryItems ?? []).filter { $0.name.lowercased() != name.lowercased() }
|
||||
werte.append(URLQueryItem(name: name, value: wert))
|
||||
teile.queryItems = werte
|
||||
return teile.url ?? url
|
||||
}
|
||||
|
||||
/// Macht aus einer Varianten-Playlist die Master-Playlist.
|
||||
///
|
||||
/// `main.m3u8` ist die Liste der **Schnipsel** einer Stufe, `master.m3u8` die
|
||||
/// Liste der **Stufen**. Nur auf letzterer kann der Parameter für mehrere
|
||||
/// Varianten überhaupt wirken.
|
||||
func alsMaster(_ url: URL) -> URL {
|
||||
guard url.lastPathComponent == "main.m3u8" else { return url }
|
||||
return url.deletingLastPathComponent().appending(path: "master.m3u8")
|
||||
}
|
||||
|
||||
// MARK: - Jellyfin
|
||||
|
||||
/// Fragt einen Jellyfin-Server, welche Playlist er für einen Titel ausgibt.
|
||||
///
|
||||
/// Das Passwort wird hier eingetippt und nirgends aufbewahrt; der Token bleibt
|
||||
/// in diesem Prozess. Gedruckt wird der **Pfad** der Adresse, nie die
|
||||
/// vollständige mit Schlüssel.
|
||||
func jellyfinLeiter(host: String) async {
|
||||
guard let basis = URL(string: host.contains("://") ? host : "http://\(host)") else {
|
||||
print("Keine brauchbare Adresse: \(host)")
|
||||
return
|
||||
}
|
||||
|
||||
print("Benutzername: ", terminator: "")
|
||||
guard let name = readLine(), !name.isEmpty else { return }
|
||||
|
||||
// Ohne Echo, damit nichts im Bild und nichts im Verlauf steht.
|
||||
guard let passwort = String(validatingCString: getpass("Passwort: ")), !passwort.isEmpty else {
|
||||
return
|
||||
}
|
||||
|
||||
let identity = JellyfinIdentity(
|
||||
client: "Halo-Probe",
|
||||
device: "Mac",
|
||||
deviceID: "halo-probe-" + UUID().uuidString,
|
||||
version: "1.0"
|
||||
)
|
||||
let client = JellyfinClient(baseURL: basis, identity: identity)
|
||||
|
||||
let konto: JellyfinAccount
|
||||
do {
|
||||
konto = try await JellyfinAuthenticator(client: client).signIn(
|
||||
userName: name,
|
||||
password: passwort
|
||||
)
|
||||
} catch {
|
||||
print("Anmeldung gescheitert: \(error)")
|
||||
return
|
||||
}
|
||||
print("Angemeldet als \(konto.userName).")
|
||||
|
||||
// Die Fassung des Servers. Ohne sie lese ich womöglich den Quelltext
|
||||
// einer anderen — und suche den Fehler an einer Stelle, die es dort
|
||||
// gar nicht gibt.
|
||||
if let info = try? await client.send(
|
||||
JellyfinRequest(path: "/System/Info/Public"),
|
||||
as: Serverfassung.self
|
||||
) {
|
||||
print("Jellyfin \(info.version ?? "unbekannt")")
|
||||
}
|
||||
print("")
|
||||
|
||||
let backend = JellyfinBackend(client: client, account: konto, serverName: "Probe")
|
||||
|
||||
// **Die Frage, die alles andere erklärt, direkt an den Server.**
|
||||
//
|
||||
// `/System/Endpoint` beantwortet `IsInNetwork` mit demselben Aufruf,
|
||||
// mit dem auch die ABR-Sperre entscheidet:
|
||||
// `_networkManager.IsInLocalNetwork(HttpContext.GetNormalizedRemoteIP())`.
|
||||
// Damit muss niemand mehr raten, ob „von zuhause" der Grund ist.
|
||||
let lage = try? await client.send(
|
||||
JellyfinRequest(path: "/System/Endpoint"),
|
||||
as: Endpunktlage.self
|
||||
)
|
||||
if let lage {
|
||||
// Beide Werte ausdrücklich: sie unterscheiden zwei Lagen mit ganz
|
||||
// verschiedenen Ursachen.
|
||||
print("Der Server sieht: IsLocal=\(lage.isLocal), IsInNetwork=\(lage.isInNetwork)")
|
||||
if lage.isLocal {
|
||||
print(" → IsLocal heißt: die Anfrage kommt vom Rechner selbst,")
|
||||
print(" also über 127.0.0.1. Dann steht der Proxy auf demselben")
|
||||
print(" Host, und der Eintrag unter Bekannte Proxys muss 127.0.0.1")
|
||||
print(" lauten (bzw. die Adresse im Docker-Netz), nicht 192.168.x.")
|
||||
}
|
||||
// **Was der Server tatsächlich eingetragen hat.**
|
||||
//
|
||||
// Ein Eintrag, der gespeichert, aber nicht übernommen wurde, sieht
|
||||
// von außen genauso aus wie gar keiner. Hier steht, was gilt.
|
||||
if let netz = try? await client.send(
|
||||
JellyfinRequest(path: "/System/Configuration/network"),
|
||||
as: Netzwerkeinstellung.self
|
||||
) {
|
||||
let proxys = netz.knownProxies ?? []
|
||||
if proxys.isEmpty {
|
||||
print(" Bekannte Proxys: KEINE eingetragen.")
|
||||
} else {
|
||||
print(" Bekannte Proxys: \(proxys.joined(separator: ", "))")
|
||||
}
|
||||
}
|
||||
|
||||
if lage.isInNetwork {
|
||||
print("Der Server hält diese Verbindung für LOKAL.")
|
||||
print(" → Eine Leiter wird er hier grundsätzlich nicht liefern,")
|
||||
print(" ganz gleich was wir anfragen. Das Folgende sagt damit")
|
||||
print(" nichts darüber, was von unterwegs käme.")
|
||||
} else {
|
||||
print("Der Server hält diese Verbindung für AUSSERHALB.")
|
||||
print(" → Hier ist eine Leiter möglich. Kommt trotzdem nur eine")
|
||||
print(" Stufe, liegt es an etwas anderem.")
|
||||
}
|
||||
print("")
|
||||
}
|
||||
|
||||
// Irgendeinen Film. Es geht um die Form der Antwort, nicht um den Inhalt.
|
||||
guard let mediathek = (try? await backend.libraries())?.first(where: { $0.kind == .movie }),
|
||||
let kachel = try? await backend.items(
|
||||
inLibrary: mediathek,
|
||||
query: MediaQuery(),
|
||||
offset: 0,
|
||||
limit: 1
|
||||
).items.first
|
||||
else {
|
||||
print("Keine Filmmediathek mit einem Titel gefunden.")
|
||||
return
|
||||
}
|
||||
|
||||
// Die Kachel aus der Liste trägt keine Dateiangaben — die kommen erst mit
|
||||
// den Einzelheiten. Ohne sie lässt sich keine Wiedergabe vorbereiten.
|
||||
let film = (try? await backend.item(id: kachel.id)) ?? kachel
|
||||
guard let fassung = film.preferredVersion, let datei = fassung.files.first else {
|
||||
print("Zu „\(film.title)“ meldet der Server keine Datei.")
|
||||
return
|
||||
}
|
||||
print("Titel: \(film.title)\n")
|
||||
|
||||
guard let ziel = try? await backend.preparePlayback(PlaybackIntent(
|
||||
itemID: film.id,
|
||||
versionIndex: 0,
|
||||
file: datei,
|
||||
// Ausdrücklich umrechnen lassen: nur dann gibt es überhaupt eine
|
||||
// Playlist, über die sich die Frage stellen lässt.
|
||||
transcode: TranscodeSettings(maximumBitrate: 8_000, resolution: nil)
|
||||
)) else {
|
||||
print("Der Server gibt für diesen Titel keine Transcode-Adresse her.")
|
||||
return
|
||||
}
|
||||
|
||||
let kopf = ["X-Emby-Token": konto.token]
|
||||
let adresse = ziel.url
|
||||
|
||||
print("Was der Server von sich aus liefert:")
|
||||
print(" Pfad: \(adresse.path)")
|
||||
let abfrage = URLComponents(url: adresse, resolvingAgainstBaseURL: true)?.queryItems ?? []
|
||||
print(" Abfragewerte: \(abfrage.map(\.name).sorted().joined(separator: ", "))")
|
||||
|
||||
// **Die Werte nur von den harmlosen Schlüsseln.** Schlüssel, Kennungen
|
||||
// und Sitzungsnummern bleiben ungedruckt — aber ob Bild und Ton
|
||||
// umgerechnet oder nur kopiert werden, entscheidet mit darüber, ob es
|
||||
// überhaupt eine Leiter geben kann, und steht nirgends sonst.
|
||||
let unbedenklich = ["VideoCodec", "AudioCodec", "VideoBitrate", "AudioBitrate",
|
||||
"TranscodeReasons", "SegmentContainer", "maxHeight"]
|
||||
let gezeigt = abfrage
|
||||
.filter { unbedenklich.contains($0.name) }
|
||||
.map { "\($0.name)=\($0.value ?? "")" }
|
||||
.sorted()
|
||||
if !gezeigt.isEmpty { print(" Davon: \(gezeigt.joined(separator: ", "))") }
|
||||
|
||||
if abfrage.contains(where: { $0.name == "AudioCodec" && $0.value?.lowercased() == "copy" })
|
||||
|| abfrage.contains(where: { $0.name == "VideoCodec" && $0.value?.lowercased() == "copy" }) {
|
||||
print("")
|
||||
print(" ACHTUNG: Hier wird kopiert statt gerechnet. Jellyfin liefert")
|
||||
print(" dann grundsätzlich keine Leiter — auch von unterwegs nicht.")
|
||||
}
|
||||
print("")
|
||||
|
||||
print("1) Unverändert")
|
||||
print(await prüfePlaylist(adresse, kopfzeilen: kopf))
|
||||
|
||||
let master = alsMaster(adresse)
|
||||
if master != adresse {
|
||||
print("2) Als master.m3u8")
|
||||
print(await prüfePlaylist(master, kopfzeilen: kopf))
|
||||
}
|
||||
|
||||
print("3) Als master.m3u8 mit enableAdaptiveBitrateStreaming=true")
|
||||
let mitABR = await prüfePlaylist(
|
||||
setzend("enableAdaptiveBitrateStreaming", auf: "true", in: master),
|
||||
kopfzeilen: kopf
|
||||
)
|
||||
print(mitABR)
|
||||
|
||||
if mitABR.contains("1 Stufe:") {
|
||||
erklärungWarumKeineLeiter()
|
||||
await prüfeSelbstgebauteLeiter(master: master, kopfzeilen: kopf)
|
||||
}
|
||||
|
||||
// Aufräumen: die Aushandlung hat am Server eine Sitzung angelegt, und
|
||||
// ohne dieses Signal rechnet der Transcoder weiter, obwohl niemand
|
||||
// zusieht. Ein Messwerkzeug, das Arbeit hinterlässt, ist ein schlechtes.
|
||||
if let sitzung = ziel.sessionID {
|
||||
await backend.endPlayback(sessionID: sitzung)
|
||||
}
|
||||
print("")
|
||||
print("Transcode-Sitzung beendet.")
|
||||
}
|
||||
|
||||
/// Sagt, woran es liegen kann — aus Jellyfins eigenem Quelltext.
|
||||
///
|
||||
/// `DynamicHlsHelper.EnableAdaptiveBitrateStreaming` prüft der Reihe nach,
|
||||
/// und die erste Hürde ist die überraschendste.
|
||||
func erklärungWarumKeineLeiter() {
|
||||
print("")
|
||||
print(" Warum nur eine Stufe kommt — aus Jellyfins Quelltext,")
|
||||
print(" `DynamicHlsHelper.EnableAdaptiveBitrateStreaming`, der Reihe nach:")
|
||||
print("")
|
||||
print(" 1. Im lokalen Netz liefert Jellyfin grundsätzlich keine Leiter.")
|
||||
print(" Wörtlich im Quelltext: „Within the local network this will")
|
||||
print(" likely do more harm than good.\" Das gilt auch für ein")
|
||||
print(" schwaches WLAN — unterschieden wird da nicht.")
|
||||
print(" 2. Ohne den Parameter keine Leiter; im Server steht er auf false.")
|
||||
print(" 3. Bei einem laufenden Sender nicht.")
|
||||
print(" 4. Wird Bild ODER Ton nur kopiert statt neu gerechnet, nicht.")
|
||||
print(" Das trifft oft zu, wenn der Ton schon AAC ist.")
|
||||
print("")
|
||||
print(" Kam dieser Aufruf von zuhause, ist Punkt 1 die Erklärung — und dann")
|
||||
print(" sagt die Messung nichts darüber, was von unterwegs käme.")
|
||||
}
|
||||
|
||||
/// Prüft, ob wir uns die Leiter **selbst** bauen könnten — und ob das etwas
|
||||
/// brächte.
|
||||
///
|
||||
/// Eine Master-Playlist ist nur ein Menü: eine Liste von Adressen. Jellyfins
|
||||
/// eigene Leiter bestünde aus derselben `main.m3u8`-Adresse, mehrfach, mit
|
||||
/// anderem `VideoBitrate`. Schreiben wir das Menü selbst, brauchen wir seine
|
||||
/// Zustimmung nicht.
|
||||
///
|
||||
/// **Die Playlist zu bekommen beweist aber noch nichts.** Sie ist Text und
|
||||
/// kostet nichts; die Datenrate steckt in den Schnipseln. Entscheidend ist
|
||||
/// deshalb allein, ob die Schnipsel bei kleinerer Zahl auch kleiner werden —
|
||||
/// oder ob der Server stur denselben Stream ausliefert, weil die Sitzung schon
|
||||
/// läuft. Deshalb wird hier gewogen, nicht gezählt.
|
||||
func prüfeSelbstgebauteLeiter(master: URL, kopfzeilen: [String: String]) async {
|
||||
print("")
|
||||
print("=== Ginge eine selbstgebaute Leiter — und brächte sie etwas? ===")
|
||||
|
||||
guard let (daten, _) = try? await URLSession.shared.data(for: anfrage(master, kopfzeilen)),
|
||||
let zeile = String(decoding: daten, as: UTF8.self)
|
||||
.split(separator: "\n")
|
||||
.first(where: { $0.hasPrefix("main.m3u8") }),
|
||||
let unter = URL(string: String(zeile), relativeTo: master)?.absoluteURL
|
||||
else {
|
||||
print(" Keine Unter-Playlist im Menü gefunden.")
|
||||
return
|
||||
}
|
||||
|
||||
let versuche: [(String, Int?, Int?)] = [
|
||||
("wie gehabt", nil, nil),
|
||||
("halbe Bitrate", 3_000_000, nil),
|
||||
("ein Viertel", 1_500_000, nil),
|
||||
("ein Viertel + 480p", 1_500_000, 480),
|
||||
]
|
||||
|
||||
for (name, bitrate, höhe) in versuche {
|
||||
var ziel = unter
|
||||
if let bitrate { ziel = setzend("VideoBitrate", auf: String(bitrate), in: ziel) }
|
||||
if let höhe { ziel = setzend("maxHeight", auf: String(höhe), in: ziel) }
|
||||
print(" \(name): \(await wiegeErstenSchnipsel(ziel, kopfzeilen: kopfzeilen))")
|
||||
}
|
||||
|
||||
print("")
|
||||
print(" Werden die Schnipsel kleiner, trägt die Idee. Bleiben sie gleich")
|
||||
print(" gross, rechnet der Server trotz anderer Zahl denselben Stream —")
|
||||
print(" dann bringt ein selbstgebautes Menü nichts.")
|
||||
}
|
||||
|
||||
/// Holt die Unter-Playlist, lädt den ersten Schnipsel und rechnet aus, was das
|
||||
/// an Datenrate bedeutet.
|
||||
private func wiegeErstenSchnipsel(_ playlist: URL, kopfzeilen: [String: String]) async -> String {
|
||||
guard let (daten, antwort) = try? await URLSession.shared.data(for: anfrage(playlist, kopfzeilen)) else {
|
||||
return "nicht erreichbar"
|
||||
}
|
||||
let status = (antwort as? HTTPURLResponse)?.statusCode ?? 0
|
||||
guard (200..<300).contains(status) else { return "HTTP \(status)" }
|
||||
|
||||
let zeilen = String(decoding: daten, as: UTF8.self).split(separator: "\n")
|
||||
guard let dauerZeile = zeilen.firstIndex(where: { $0.hasPrefix("#EXTINF") }),
|
||||
zeilen.indices.contains(dauerZeile + 1),
|
||||
let schnipselURL = URL(string: String(zeilen[dauerZeile + 1]), relativeTo: playlist)?.absoluteURL
|
||||
else { return "HTTP \(status), aber kein Schnipsel darin" }
|
||||
|
||||
let dauer = Double(
|
||||
zeilen[dauerZeile]
|
||||
.dropFirst("#EXTINF:".count)
|
||||
.prefix { $0 != "," }
|
||||
) ?? 0
|
||||
|
||||
guard let (rohdaten, schnipselAntwort) = try? await URLSession.shared.data(
|
||||
for: anfrage(schnipselURL, kopfzeilen)
|
||||
) else { return "Playlist ja, Schnipsel nicht erreichbar" }
|
||||
|
||||
let schnipselStatus = (schnipselAntwort as? HTTPURLResponse)?.statusCode ?? 0
|
||||
guard (200..<300).contains(schnipselStatus) else {
|
||||
return "Playlist ja, Schnipsel HTTP \(schnipselStatus)"
|
||||
}
|
||||
|
||||
let kilobyte = Double(rohdaten.count) / 1024
|
||||
guard dauer > 0 else { return String(format: "%.0f kB", kilobyte) }
|
||||
let kilobit = Double(rohdaten.count) * 8 / 1000 / dauer
|
||||
return String(format: "%.0f kB für %.1f s → %.0f kbit/s", kilobyte, dauer, kilobit)
|
||||
}
|
||||
|
||||
private func anfrage(_ url: URL, _ kopfzeilen: [String: String]) -> URLRequest {
|
||||
var request = URLRequest(url: url)
|
||||
for (name, wert) in kopfzeilen { request.setValue(wert, forHTTPHeaderField: name) }
|
||||
return request
|
||||
}
|
||||
|
||||
/// Zeigt, was der Server über die Tonspuren eines Titels wirklich sagt.
|
||||
///
|
||||
/// **Der Grund:** Die Sprachwahl vergleicht Kürzel, und Kürzel lügen. Ob bei
|
||||
/// einer Datei der Titel das rettet — „eng" im Kürzel, „Deutsch" im Namen —,
|
||||
/// sieht man nur, wenn man beides nebeneinander legt. Alles andere wäre
|
||||
/// geraten.
|
||||
func zeigeSpuren(host: String, suche: String) async {
|
||||
guard let basis = URL(string: host.contains("://") ? host : "http://\(host)") else { return }
|
||||
|
||||
print("Benutzername: ", terminator: "")
|
||||
guard let name = readLine(), !name.isEmpty else { return }
|
||||
guard let passwort = String(validatingCString: getpass("Passwort: ")), !passwort.isEmpty else { return }
|
||||
|
||||
let identity = JellyfinIdentity(
|
||||
client: "Halo-Probe",
|
||||
device: "Mac",
|
||||
deviceID: "halo-probe-" + UUID().uuidString,
|
||||
version: "1.0"
|
||||
)
|
||||
let client = JellyfinClient(baseURL: basis, identity: identity)
|
||||
|
||||
guard let konto = try? await JellyfinAuthenticator(client: client).signIn(
|
||||
userName: name,
|
||||
password: passwort
|
||||
) else {
|
||||
print("Anmeldung gescheitert.")
|
||||
return
|
||||
}
|
||||
print("Angemeldet als \(konto.userName).\n")
|
||||
|
||||
// Suchen, damit man nicht mit Kennungen hantieren muss.
|
||||
let treffer = try? await client.send(
|
||||
JellyfinRequest(path: "/Users/\(konto.userID)/Items", query: [
|
||||
URLQueryItem(name: "searchTerm", value: suche),
|
||||
URLQueryItem(name: "Recursive", value: "true"),
|
||||
URLQueryItem(name: "IncludeItemTypes", value: "Movie,Episode"),
|
||||
URLQueryItem(name: "Limit", value: "5"),
|
||||
URLQueryItem(name: "Fields", value: "MediaSources"),
|
||||
]),
|
||||
as: JellyfinItemPage.self
|
||||
)
|
||||
|
||||
guard let gefunden = treffer?.items, !gefunden.isEmpty else {
|
||||
print("Nichts gefunden zu „\(suche)“.")
|
||||
return
|
||||
}
|
||||
|
||||
for eintrag in gefunden {
|
||||
print("── \(eintrag.name ?? "—")")
|
||||
let quellen = eintrag.mediaSources ?? []
|
||||
guard let streams = quellen.first?.mediaStreams else {
|
||||
print(" keine Spurangaben\n")
|
||||
continue
|
||||
}
|
||||
|
||||
for spur in streams where spur.type == "Audio" {
|
||||
let kürzel = spur.language ?? "—"
|
||||
let name = spur.title ?? "—"
|
||||
var merkmale: [String] = []
|
||||
if spur.isDefault == true { merkmale.append("Standard") }
|
||||
if spur.isForced == true { merkmale.append("erzwungen") }
|
||||
if spur.isHearingImpaired == true { merkmale.append("hörgeschädigt") }
|
||||
if spur.isOriginal == true { merkmale.append("Original") }
|
||||
|
||||
print(" [\(spur.index ?? -1)] Kürzel \(kürzel)")
|
||||
print(" Name in der Datei: \(name)")
|
||||
print(" Wie Jellyfin es zeigt: \(spur.displayTitle ?? "—")")
|
||||
print(" \(spur.codec ?? "—"), \(spur.channels ?? 0) Kanäle"
|
||||
+ (merkmale.isEmpty ? "" : ", " + merkmale.joined(separator: ", ")))
|
||||
}
|
||||
print("")
|
||||
}
|
||||
|
||||
print("Zu lesen ist das so: stimmt das Kürzel nicht mit dem Namen überein,")
|
||||
print("lügt die Datei — und dann hilft nur der Name oder das Merken.")
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user