Live-TV: erst den Tuner belegen, dann umrechnen lassen

Der übersprungene Schritt. Ich habe die Sendung direkt an den Transcoder gegeben — ohne dass jemand den Tuner belegt hätte. Der Server fing an, merkte, dass er nichts zu senden hat, und brach ab: „die Wiedergabe wurde unterbrochen", ohne weitere Angabe. Jetzt zwei Schritte. Erst eine Live-Sitzung eröffnen, dann die Adresse dieser Sitzung umrechnen lassen — nicht die des Senders und nicht die der Sendung. mediaIndex und partIndex sind dabei -1: ein laufender Sender hat keine Fassungen zur Auswahl. Unter welchem Schlüssel sich die Sitzung eröffnen lässt, unterscheidet sich je nach Anbieter, deshalb werden die in Frage kommenden der Reihe nach probiert — der Raster-Schlüssel zuerst, weil er den Sender genauso bezeichnet wie die Liste, aus der er stammt. Dazu zwei Stellen, an denen Gründe bisher verschwanden: Vor dem Abspielen wird der Server gefragt, ob er den Strom überhaupt zulässt. Er antwortet im Klartext; der Player meldet nur, dass es nicht ging. Und wenn der Motor scheitert, steht sein Grund ab jetzt auf dem Bildschirm statt nur im Protokoll. „Die Wiedergabe wurde unterbrochen" allein sagt weder, ob der Server ablehnt, noch ob der Motor das Format nicht mag — und genau diese Unterscheidung hat diese Runde gekostet. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-12 13:51:05 +02:00
parent bbe47b83be
commit 861ca805a5
6 changed files with 2788 additions and 2629 deletions
@@ -360,50 +360,126 @@ extension PlexServer {
    /// Schaltet einen Sender ein.
    ///
    /// Live-TV kommt immer als umgerechneter Strom: der Tuner liefert einen
-    /// Transportstrom, den kein iPhone direkt abspielt. Deshalb führt der Weg
-    /// hier zwangsläufig über den Transcoder — anders als bei Dateien, wo
-    /// DirectPlay der Normalfall ist.
+    /// Transportstrom, den kein iPhone direkt abspielt.
    ///
-    /// Zwei Wege, je nachdem, woher der Sender kam. Steht die laufende
-    /// Sendung im Programmraster, ist ihre Adresse beim Programmanbieter der
-    /// direkte Weg: Plex behandelt eine laufende Sendung wie einen Film.
-    /// Stammt der Sender dagegen aus der Liste des Tuners, bleibt der Umweg
-    /// über eine Live-Sitzung.
+    /// Zwei Schritte, und der erste ist der, den ich zuerst übersprungen
+    /// hatte: **der Server muss den Tuner belegen**. Erst danach gibt es
+    /// etwas umzurechnen. Ohne diesen Schritt begann die Wiedergabe und starb
+    /// sofort wieder — „die Wiedergabe wurde unterbrochen", ohne dass ein
+    /// Fehler zu sehen gewesen wäre.
+    ///
+    /// Unter welchem Schlüssel die Sitzung eröffnet wird, unterscheidet sich
+    /// je nach Anbieter, deshalb werden die in Frage kommenden der Reihe nach
+    /// probiert. Was dabei herauskam, steht in `trace` — scheitert alles, ist
+    /// ohne Rückfrage zu sehen, was der Server geantwortet hat.
    public func tune(
        channel: PlexChannel,
        program: PlexProgram? = nil,
        maximumBitrate: Int?
-    ) async throws(PlexError) -> URL? {
+    ) async -> LiveTuneResult {
        let session = UUID().uuidString
+        var trace: [ChannelProbe] = []

-        if let metadataKey = program?.metadataKey {
-            return transcodeURL(for: TranscodeRequest(
-                ratingKey: channel.id,
-                maximumBitrate: maximumBitrate,
-                isLocal: connection.local,
-                sessionIdentifier: session,
-                pathOverride: metadataKey
-            ))
+        for key in Self.sessionKeys(channel: channel, program: program) {
+            let path = "/livetv/sessions/\(session)/\(key)"
+            do {
+                let container = try await client.send(
+                    PlexRequest(
+                        path: path,
+                        query: [URLQueryItem(name: "X-Plex-Session-Identifier", value: session)],
+                        timeout: .seconds(30)
+                    ),
+                    as: PlexMediaContainer<PlexItem>.self
+                )
+
+                guard let item = container.content.first else {
+                    trace.append(ChannelProbe(path: path, result: "leer"))
+                    continue
+                }
+
+                // Die Sitzung hat jetzt einen Tuner. Die Adresse, unter der
+                // sie läuft, ist der Weg zum Transcoder — nicht die des
+                // Senders und nicht die der Sendung.
+                let streamPath = item.media.first?.parts.first?.key
+                    ?? (item.key.isEmpty ? "/livetv/sessions/\(session)" : item.key)
+
+                trace.append(ChannelProbe(path: path, result: "Sitzung: \(streamPath)"))
+
+                return LiveTuneResult(
+                    url: transcodeURL(for: TranscodeRequest(
+                        ratingKey: item.ratingKey,
+                        // -1 heißt „was auch immer die Sitzung liefert". Ein
+                        // laufender Sender hat keine Fassungen zur Auswahl.
+                        mediaIndex: -1,
+                        partIndex: -1,
+                        maximumBitrate: maximumBitrate,
+                        isLocal: connection.local,
+                        sessionIdentifier: session,
+                        pathOverride: streamPath
+                    )),
+                    sessionIdentifier: session,
+                    trace: trace
+                )
+            } catch {
+                trace.append(ChannelProbe(path: path, result: Self.shortDescription(of: error)))
+            }
        }

-        guard let key = channel.key else { return nil }
+        // Letzter Versuch: die Sendung unmittelbar umrechnen lassen. Auf
+        // Servern, die den Tuner selbst belegen, genügt das.
+        if let metadataKey = program?.metadataKey {
+            trace.append(ChannelProbe(path: metadataKey, result: "direkt versucht"))
+            return LiveTuneResult(
+                url: transcodeURL(for: TranscodeRequest(
+                    ratingKey: channel.id,
+                    maximumBitrate: maximumBitrate,
+                    isLocal: connection.local,
+                    sessionIdentifier: session,
+                    pathOverride: metadataKey
+                )),
+                sessionIdentifier: session,
+                trace: trace
+            )
+        }

-        let container = try await client.send(
-            PlexRequest(
-                path: "/livetv/sessions/\(session)/\(key)",
-                query: [URLQueryItem(name: "X-Plex-Session-Identifier", value: session)],
-                timeout: .seconds(30)
-            ),
-            as: PlexMediaContainer<PlexItem>.self
-        )
+        return LiveTuneResult(url: nil, sessionIdentifier: session, trace: trace)
+    }

-        guard let item = container.content.first else { throw .notFound }
-        return transcodeURL(for: TranscodeRequest(
-            ratingKey: item.ratingKey,
-            maximumBitrate: maximumBitrate,
-            isLocal: connection.local,
-            sessionIdentifier: session
-        ))
+    /// Unter welchen Schlüsseln sich eine Live-Sitzung eröffnen lässt.
+    ///
+    /// Der Raster-Schlüssel zuerst: er bezeichnet den Sender genau so, wie
+    /// das Programmraster ihn führt, aus dem auch die Senderliste kommt.
+    static func sessionKeys(channel: PlexChannel, program: PlexProgram?) -> [String] {
+        var keys = [
+            channel.gridKey,
+            program?.metadataKey.flatMap { $0.split(separator: "/").last.map(String.init) },
+            program?.id,
+            channel.key,
+            channel.id,
+        ].compactMap { $0 }
+
+        // Volle Adressen taugen hier nicht: an `/livetv/sessions/<uuid>/`
+        // gehört ein Schlüssel, kein zweiter Pfad.
+        keys = keys.map { $0.split(separator: "/").last.map(String.init) ?? $0 }
+
+        var seen = Set<String>()
+        return keys.filter { !$0.isEmpty && seen.insert($0).inserted }
+    }
+
+    /// Fragt den Server, ob er diesen Strom zulässt — und warum nicht.
+    public func liveTVVerdict(for url: URL) async -> String? {
+        // Dieselben Angaben, nur an den Entscheider statt an den Transcoder.
+        // Er antwortet im Klartext, warum er ablehnt — sonst bleibt nur „die
+        // Wiedergabe wurde unterbrochen", und das sagt nichts.
+        guard let items = URLComponents(url: url, resolvingAgainstBaseURL: false)?.queryItems
+        else { return nil }
+
+        guard let decision = try? await client.send(
+            PlexRequest(path: "/video/:/transcode/universal/decision", query: items),
+            as: TranscodeDecision.self
+        ) else { return nil }
+
+        return decision.isAllowed ? nil : decision.explanation
    }
 }

@@ -640,3 +716,11 @@ public struct LiveTVGuide: Sendable {
    /// Jede abgeklopfte Adresse mit ihrer Antwort, falls nichts gefunden wurde.
    public let trace: [ChannelProbe]
 }
+
+/// Was beim Einschalten herauskam.
+public struct LiveTuneResult: Sendable {
+    public let url: URL?
+    public let sessionIdentifier: String
+    /// Jeder versuchte Weg mit seiner Antwort.
+    public let trace: [ChannelProbe]
+}
@@ -189,6 +189,8 @@ struct PlexGridMedia: Decodable {
    let channelVcn: String?
    /// Die laufende Nummer des Senders am Server.
    let channelID: String?
+    /// Der Schlüssel des Senders im Raster — ein Kandidat fürs Einschalten.
+    let gridKey: String?
    /// Anfang und Ende der Sendung.
    ///
    /// Sie stehen hier und **nicht** am Eintrag darüber. Genau daran ist das
@@ -200,7 +202,7 @@ struct PlexGridMedia: Decodable {

    private enum CodingKeys: String, CodingKey {
        case channelIdentifier, channelTitle, channelCallSign, channelThumb, channelVcn, channelID
-        case beginsAt, endsAt
+        case gridKey, beginsAt, endsAt
        case part = "Part"
    }

@@ -225,6 +227,7 @@ struct PlexGridMedia: Decodable {
        } else {
            self.channelID = nil
        }
+        self.gridKey = try? values.decodeIfPresent(String.self, forKey: .gridKey)
        self.beginsAt = try? values.decodeIfPresent(Int.self, forKey: .beginsAt)
        self.endsAt = try? values.decodeIfPresent(Int.self, forKey: .endsAt)
        self.parts = try values.decodeIfPresent([PlexGridPart].self, forKey: .part) ?? []
@@ -242,7 +245,8 @@ struct PlexGridMedia: Decodable {
            title: Self.withoutLeadingNumber(name, number: channelVcn),
            channelIdentifier: channelVcn,
            thumb: channelThumb,
-            key: parts.first?.key ?? channelID
+            key: parts.first?.key ?? channelID,
+            gridKey: gridKey
        )
    }

@@ -272,6 +276,8 @@ public struct PlexChannel: Sendable, Equatable, Decodable, Identifiable {
    public let thumb: String?
    /// Der Schlüssel, über den sich der Sender einschalten lässt.
    public let key: String?
+    /// Der Schlüssel des Senders im Programmraster.
+    public let gridKey: String?
    public let id: String

    /// Ob dieser Sender einen Namen trägt.
@@ -284,7 +290,7 @@ public struct PlexChannel: Sendable, Equatable, Decodable, Identifiable {
    static let placeholder = "—"

    private enum CodingKeys: String, CodingKey {
-        case channelIdentifier, title, thumb, key
+        case channelIdentifier, title, thumb, key, gridKey
        case identifier = "id"
        case uuid, name, callSign, vcn, number, channelTitle, channelCallSign
    }
@@ -306,7 +312,8 @@ public struct PlexChannel: Sendable, Equatable, Decodable, Identifiable {
        self.channelIdentifier = number
            ?? keyValue.flatMap { $0.allSatisfy { character in character.isNumber || character == "." } ? $0 : nil }
        self.thumb = try values.decodeIfPresent(String.self, forKey: .thumb)
-        self.key = try values.decodeIfPresent(String.self, forKey: .key)
+        self.key = Self.text(in: values, forKeys: [.key])
+        self.gridKey = try? values.decodeIfPresent(String.self, forKey: .gridKey)

        // Plex liefert die Kennung mal als Zahl, mal als Zeichenkette, mal als
        // `uuid`. Ein einzelner erwarteter Typ hätte hier bei manchen
@@ -358,12 +365,20 @@ public struct PlexChannel: Sendable, Equatable, Decodable, Identifiable {
        return nil
    }

-    public init(id: String, title: String, channelIdentifier: String? = nil, thumb: String? = nil, key: String? = nil) {
+    public init(
+        id: String,
+        title: String,
+        channelIdentifier: String? = nil,
+        thumb: String? = nil,
+        key: String? = nil,
+        gridKey: String? = nil
+    ) {
        self.id = id
        self.title = title
        self.channelIdentifier = channelIdentifier
        self.thumb = thumb
        self.key = key
+        self.gridKey = gridKey
    }
 }