VLC ist weg — es gibt nur noch einen Spieler

Du hattest recht mit der Erwartung, nur nicht mit dem Stand: entfernt war er
nicht. Was wir gemacht haben, war, ihm Arbeit wegzunehmen — DTS, TrueHD und
Vorbis gehen seit Kurzem über das Umpacken beim Server. Übrig blieb er an
einer Stelle, `PlaybackDecider.fallback`.

Jetzt ist er ganz weg, samt dem 920-MB-Binärpaket.

**Was an seine Stelle tritt.** Die Entscheidung sagt nicht mehr, *wer* spielt,
sondern *was ankommt*: direkt, umgepackt oder umgerechnet. `PlaybackEngineKind`
fällt damit weg, `directPlay` trägt keine Engine mehr, und `PlaybackPolicy`
kennt kein `allowsFallbackEngine`.

**Das Auffangnetz bleibt, nur anders geknüpft.** Scheiterte das Umpacken am
Player, sprang bisher VLC ein — der Server entscheidet erst beim Ausliefern,
ob er die Ströme wirklich kopieren kann, und manche Antworten nimmt AVPlayer
nicht an. Statt der zweiten Engine rechnet der Server jetzt neu
(`fallBackToTranscode`). Teurer für ihn, aber es kommt etwas an, statt einer
schwarzen Wand mit einer Fehlernummer.

**Offline wäre das ein Rückschritt gewesen** — dort gibt es keinen Server, der
einspringt. Deshalb ging der vorige Commit voraus: was heruntergeladen wird,
kommt schon in einer Hülle, die der Systemplayer öffnet.

Was dadurch überall gilt, auch für Dateien, die bisher bei VLC landeten:
Bild-in-Bild, AirPlay, Bedienung im Sperrbildschirm — und dasselbe Verhalten
auf dem Apple TV, wo es VLC ohnehin nie gab.

Die Attrappe heißt ihren Schalter jetzt `--dts` statt `--vlc`: der Fall ist
geblieben, sein Ziel nicht.

iOS und tvOS bauen, 494 Tests grün.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Flixy.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -1,15 +0,0 @@
-{
-  "originHash" : "8b778ccd4dce9d26be9db57d4587b19c4a4366fcdaf8b6017e1df36fa1eddb4f",
-  "pins" : [
-    {
-      "identity" : "vlckit",
-      "kind" : "remoteSourceControl",
-      "location" : "https://github.com/videolan/vlckit.git",
-      "state" : {
-        "revision" : "6cbc4e7b248aa51ec0906697abb30ecae47194b7",
-        "version" : "4.0.0-a24"
-      }
-    }
-  ],
-  "version" : 3
-}

Flixy/Resources/Localizable.xcstrings

@@ -7326,23 +7326,6 @@
         }
       }
     },
-    "technical.directPlayVLC": {
-      "extractionState": "stale",
-      "localizations": {
-        "de": {
-          "stringUnit": {
-            "state": "translated",
-            "value": "Direkt (VLC)"
-          }
-        },
-        "en": {
-          "stringUnit": {
-            "state": "translated",
-            "value": "Direct (VLC)"
-          }
-        }
-      }
-    },
     "technical.file": {
       "localizations": {
         "de": {

Flixy/Session/NowPlaying.swift

@@ -133,7 +133,7 @@ final class NowPlaying {
     ///
     /// Die Handlung läuft über einen Sprung auf den Hauptakteur statt über
     /// `assumeIsolated`: dass diese Rückrufe dort ankommen, ist nirgends
-    /// zugesagt, und dieselbe Annahme hat die App im VLC-Engine schon einmal
+    /// zugesagt, und dieselbe Annahme hat die App schon einmal
     /// zum Absturz gebracht. Der Umweg kostet einen Durchlauf — unbemerkbar
     /// neben dem Tastendruck, der ihn ausgelöst hat.
     private func add(

Flixy/Session/PlaybackDiagnostics.swift

@@ -6,8 +6,8 @@ import FlixyPlayback
 ///
 /// Der Player verschwindet, wenn man ihn schließt — und mit ihm jeder Hinweis
 /// darauf, woran es lag. Dieser Mitschnitt überlebt das und steht in den
-/// Einstellungen. Aus „es läuft nicht" wird damit „VLC, lokale Verbindung,
+/// Einstellungen. Aus „es läuft nicht" wird damit „umgepackt, lokale
-/// hängt bei Öffnen" — und das ist ein Unterschied, der Stunden spart.
+/// Verbindung, hängt bei Öffnen" — ein Unterschied, der Stunden spart.
 @MainActor
 @Observable
 final class PlaybackDiagnostics {
@@ -65,11 +65,8 @@ final class PlaybackDiagnostics {
 
     private static func describe(_ decision: PlaybackDecision) -> String {
         switch decision.method {
-        case .directPlay(let engine):
+        case .directPlay:
-            switch engine {
+            "Direkt" 
-            case .avPlayer: "Direkt · AVPlayer"
-            case .vlc: "Direkt · VLC"
-            }
         case .remux:
             decision.rationale.contains { if case .audioCodecUnsupported = $0 { true } else { false } }
                 ? "Umgepackt · Bild unverändert, Ton umgerechnet"

Flixy/Session/PlaybackSettings.swift

@@ -1,12 +1,4 @@
 import Foundation
-// **`!os(tvOS)` und nicht nur `canImport`.** Der Fernseher verlinkt FlixyVLC
-// nicht, aber der Abhängigkeits-Sucher von Clang prüft den Import trotzdem —
-// und bricht dann an VLCKit ab, das für dieses Ziel gar nicht gebaut wird.
-// „Unable to resolve module dependency: VLCKit" nennt dabei weder diese Datei
-// noch VLC als Grund.
-#if canImport(FlixyVLC) && !os(tvOS)
-import FlixyVLC
-#endif
 import Observation
 import FlixyPlayback
 
@@ -60,25 +52,6 @@ final class PlaybackSettings {
     /// Die Geschwindigkeiten, mit denen eine Wiedergabe beginnen kann.
     static let rateChoices: [Double] = [0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
 
-    /// Ob ein zweiter Spieler zur Verfügung steht.
-    ///
-    /// VLC steckt in einem eigenen Paket, das nur für iOS gebaut wird — sein
-    /// Binärpaket hat keinen Teil für Mac Catalyst. Wo es fehlt, übernimmt der
-    /// Server: MKV und DTS werden dann umgerechnet statt unverändert
-    /// übertragen. Das kostet ihn Rechenzeit und sieht man nicht, aber es
-    /// spielt.
-    ///
-    /// Auf dem Fernseher ebenfalls nicht: 920 MB Binärpaket für einen
-    /// Rückfallweg, der auf einem Apple TV selten greift, sind die Bauzeit
-    /// nicht wert.
-    static var hasFallbackEngine: Bool {
-        #if canImport(FlixyVLC) && !os(tvOS)
-        true
-        #else
-        false
-        #endif
-    }
-
     private let defaults: UserDefaults
 
     var wifiQuality: Quality { didSet { defaults.set(wifiQuality.rawValue, forKey: Key.wifiQuality) } }
@@ -165,10 +138,6 @@ final class PlaybackSettings {
 
         return PlaybackPolicy(
             allowsTranscoding: true,
-            // Nur, wenn es ihn auf dieser Plattform gibt. Ohne VLC wählte die
-            // Entscheidung sonst einen Spieler, den es nicht gibt — und die
-            // Wiedergabe bliebe schwarz, statt dass der Server umrechnet.
-            allowsFallbackEngine: Self.hasFallbackEngine,
             maximumBitrate: quality.bitrateLimit
         )
     }

Flixy/Session/PlexWebAuthenticator.swift

@@ -90,7 +90,7 @@ final class PlexWebAuthenticator: NSObject {
             callbackURLScheme: callbackScheme
         ) { [weak self] _, error in
             // ASWebAuthenticationSession ruft den Abschlussblock auf dem
-            // Hauptthread auf — anders als VLCKit, wo dieselbe Annahme die App
+            // Hauptthread auf — anders als mancher Rückruf, wo dieselbe Annahme die App
             // zum Absturz gebracht hat. Hier ist sie dokumentiert.
             MainActor.assumeIsolated {
                 guard let self else { return }

Flixy/Session/TopShelfWriter.swift

@@ -5,7 +5,7 @@
 // einen Import genügte dabei nicht: der Abhängigkeits-Sucher von Clang prüft
 // ihn trotzdem und bricht mit „Unable to resolve module dependency:
 // TVServices" ab, ohne den Fernseher zu erwähnen. Dieselbe Falle wie bei
-// VLCKit, siehe `PlaybackSettings`.
+// siehe `PlaybackSettings`.
 #if os(tvOS)
 import Foundation
 import MediaKit

Flixy/Views/Detail/TechnicalDetails.swift

@@ -96,11 +96,8 @@ struct TechnicalDetails: View {
 
     private var playbackMethodLabel: String {
         switch decision.method {
-        case .directPlay(let engine):
+        case .directPlay:
-            switch engine {
+            String(localized: "technical.directPlayNative")
-            case .avPlayer: String(localized: "technical.directPlayNative")
-            case .vlc: String(localized: "technical.directPlayVLC")
-            }
         // **Zwei Fälle unter einem Namen wären eine Lüge.** Umgepackt bleibt
         // das Bild unberührt — der Ton nur dann, wenn AVPlayer ihn kennt.
         case .remux:

Flixy/Views/Player/PlayerModel.swift

@@ -4,11 +4,6 @@ import MediaKit
 import Observation
 import FlixyDownloads
 import FlixyPlayback
-// Siehe `PlaybackSettings`: `!os(tvOS)` muss dazu, sonst bricht der
-// Abhängigkeits-Sucher an VLCKit ab, das für dieses Ziel gar nicht gebaut wird.
-#if canImport(FlixyVLC) && !os(tvOS)
-import FlixyVLC
-#endif
 import PlexKit
 
 /// Führt einen Abspielwunsch aus.
@@ -162,9 +157,6 @@ final class PlayerModel {
     /// das Bild zeichnet: auf dem Telefon hängt die gehaltene `AVPlayerLayer`
     /// daran, auf dem Fernseher ein `AVPlayerViewController`. Beide holen sich
     /// hier dasselbe ab.
-    ///
-    /// `nil` bei VLC — kein Sonderfall, sondern dieselbe Auskunft, die
-    /// `VideoSurface` heute schon auswertet.
     var systemPlayer: AVPlayer? { (engine as? AVPlayerEngine)?.player }
 
     /// Wie das Bild in die Fläche gelegt wird.
@@ -174,18 +166,6 @@ final class PlayerModel {
     /// Neuaufbau der Engine gehen an der Ansicht vorbei. Läge die Wahl dort,
     /// spränge das Bild bei jedem Qualitätswechsel zurück auf „eingepasst".
     ///
-    /// **Warum der Knopf lange nichts tat, und warum der Grund nicht der
-    /// `didSet` war, der hier stand.** Ein `didSet` auf einer verfolgten
-    /// Eigenschaft einer `@Observable`-Klasse wird durchaus gemeldet —
-    /// `HomeLayoutSettings` lebt davon. Der Knopf schrieb `videoGravity` auf
-    /// `surface.playerLayer`, und diese Ebene hängt bei einer Datei, die über
-    /// VLC läuft, überhaupt nicht im Baum: `VideoSurface` nimmt dort
-    /// `vlcEngine.videoView`, und `attachSurface` steigt für alles ausser
-    /// AVPlayer gleich wieder aus. Geschrieben wurde also auf eine Ebene, die
-    /// niemand sieht.
-    ///
-    /// Deshalb geht die Einstellung jetzt durch die Engine — siehe
-    /// `applyVideoFit()`.
     var videoFit: VideoFit = .fit
 
     /// Wo das Bild aufhört.
@@ -208,9 +188,6 @@ final class PlayerModel {
     /// **Beobachtet, nicht abgefragt.** `isPictureInPicturePossible` steht erst
     /// fest, wenn der Player ein Bild hat — wer beim Zeichnen fragt, bekommt
     /// `false` und zeichnet den Knopf nie wieder. Also meldet es sich selbst.
-    ///
-    /// Bleibt bei VLC dauerhaft falsch: `AVPictureInPictureController` braucht
-    /// eine `AVPlayerLayer`, und VLC zeichnet in eine eigene Ansicht.
     private(set) var canUsePictureInPicture = false
     private(set) var isPictureInPictureActive = false
     /// Was beim Beenden von Bild-in-Bild wieder ins Vollbild führen soll.
@@ -269,7 +246,7 @@ final class PlayerModel {
     /// Ohne das gewönne die letzte Meldung von der alten Stelle gegen den
     /// gerade ausgelösten Sprung.
     private var seekTarget: Duration?
-    /// Ob schon einmal auf VLC ausgewichen wurde.
+    /// Ob schon einmal auf den Transcoder ausgewichen wurde.
     private var hasFallenBack = false
     /// Ob der Vorratsspeicher für diese Wiedergabe aufgegeben wurde.
     ///
@@ -440,9 +417,6 @@ final class PlayerModel {
         guard let ceiling = automaticCeiling ?? startingCeiling else { return base }
         return PlaybackPolicy(
             allowsTranscoding: true,
-            // Ohne Ersatz-Engine: sonst spielte VLC die Datei unverändert ab,
-            // und die abgesenkte Grenze bliebe wirkungslos.
-            allowsFallbackEngine: false,
             maximumBitrate: min(ceiling, base.maximumBitrate ?? ceiling),
             forcesTranscoding: true
         )
@@ -759,8 +733,8 @@ final class PlayerModel {
                 videoCodec: offline?.videoCodec,
                 audioCodec: offline?.audioCodec,
                 bitrate: offline?.bitrate,
-                // Was heruntergeladen wurde, ist untersucht. Ohne diese Zusage
+                // Was heruntergeladen wurde, ist untersucht — und seit das
-                // ginge jede Offline-Datei vorsichtshalber an VLC.
+                // Herunterladen bei Bedarf umpackt, auch zu öffnen.
                 hasKnownStreams: offline?.videoCodec != nil
             ),
             // Lokal gibt es nichts umzurechnen und keine Bandbreitengrenze.
@@ -781,10 +755,6 @@ final class PlayerModel {
         let engine = makeEngine(for: decision)
         self.engine = engine
         attachSurface(to: engine)
-        // **Auch für VLC**, und deshalb hier und nicht in `attachSurface`:
-        // das steigt für alles ausser AVPlayer sofort aus, weil es die
-        // Bildebene anhängt. Die Skalierung geht aber beide an.
-        engine.setVideoFit(videoFit)
         observe(engine)
         // **Vor dem Öffnen.** Ein frisch angelegter Gegenstand ist
         // ungestaltet, und der erste Untertitel käme sonst in der Vorgabe.
@@ -1208,18 +1178,24 @@ final class PlayerModel {
         return true
     }
 
-    /// Der Rückzug auf VLC, wenn das Umpacken nicht getragen hat.
+    /// Der Rückzug auf den Transcoder, wenn das Umpacken nicht getragen hat.
     ///
-    /// Genau **einmal** je Wiedergabe: scheitert auch VLC, ist es ein Fehler
+    /// **Hier stand VLC.** Scheiterte das Umpacken, spielte die zweite Engine
+    /// die Datei unverändert — das gibt es nicht mehr. Statt dessen rechnet der
+    /// Server das Bild neu: teurer für ihn, aber es kommt etwas an, und der
+    /// Nutzer steht nicht vor einer schwarzen Wand mit einer Fehlernummer.
+    ///
+    /// Genau **einmal** je Wiedergabe: scheitert auch das, ist es ein Fehler
     /// des Materials, und ein zweiter Anlauf schickte die App im Kreis.
-    private func fallBackToVLC() async -> Bool {
+    private func fallBackToTranscode() async -> Bool {
-        guard !hasFallenBack, policy.allowsFallbackEngine else { return false }
+        let geltend = effectivePolicy
+        guard !hasFallenBack, geltend.allowsTranscoding else { return false }
         hasFallenBack = true
-        diagnostics.note("Umpacken abgelehnt — noch einmal mit VLC")
+        diagnostics.note("Umpacken abgelehnt — noch einmal, diesmal umgerechnet")
 
         await restart(forcing: PlaybackDecision(
-            method: .directPlay(engine: .vlc),
+            method: .transcode(maximumBitrate: geltend.maximumBitrate),
-            rationale: (decision?.rationale ?? []) + [.transcodingUnavailable]
+            rationale: decision?.rationale ?? []
         ))
         if case .failed = phase { return false }
         return true
@@ -1741,14 +1717,10 @@ final class PlayerModel {
     /// Eine eigene Funktion, weil es zwei Anlässe gibt: die Wahl des Nutzers
     /// und jeder Engine-Wechsel. Beide müssen dasselbe tun.
     ///
-    /// **Zwei Zeilen, weil es zwei Engines gibt.** Die Bildebene gehört der
+    /// Die Bildebene gehört der App und nicht dem Systemplayer — deshalb
-    /// App und nicht dem Systemplayer — deshalb steht `videoGravity` hier und
+    /// steht `videoGravity` hier und nicht in `AVPlayerEngine`.
-    /// nicht in `AVPlayerEngine`. VLC zeichnet dagegen selbst und passt sein
-    /// Bild von sich aus ein; ihm muss man es sagen. Solange nur die erste
-    /// Zeile hier stand, war der Knopf bei jeder Datei über VLC ohne Wirkung.
     func applyVideoFit() {
         surface.playerLayer.videoGravity = videoFit == .fill ? .resizeAspectFill : .resizeAspect
-        engine?.setVideoFit(videoFit)
     }
 
     /// Hängt die gehaltene Bildebene an den aktuellen Engine.
@@ -1758,7 +1730,6 @@ final class PlayerModel {
     /// weiter auf einen abgeräumten Player und bleibt schwarz.
     private func attachSurface(to engine: any VideoPlayerEngine) {
         guard let avEngine = engine as? AVPlayerEngine else { return }
-
         surface.playerLayer.player = avEngine.player
         // **Den Zustand lesen, keine Konstante.** Hier stand fest
         // `.resizeAspect` — und weil diese Zeile nach jedem Neuaufbau erneut
@@ -1818,20 +1789,14 @@ final class PlayerModel {
         restoreFromPictureInPicture = action
     }
 
+    /// **Es gibt nur noch einen.**
+    ///
+    /// Die Entscheidung sagt nicht mehr, *wer* spielt, sondern *was ankommt*:
+    /// direkt, umgepackt oder umgerechnet. Am Ende steht immer der
+    /// Systemplayer — und damit überall Bild-in-Bild, AirPlay und die
+    /// Bedienung im Sperrbildschirm, auch auf dem Apple TV.
     private func makeEngine(for decision: PlaybackDecision) -> any VideoPlayerEngine {
-        #if canImport(FlixyVLC) && !os(tvOS)
-        switch decision.engine {
-        case .vlc: VLCPlayerEngine()
-        // Auch der Transcode-Weg endet beim Systemplayer: er liefert HLS, und
-        // genau darin wechselt AVPlayer die Bitrate von selbst.
-        case .avPlayer, .none: AVPlayerEngine()
-        }
-        #else
-        // Auf dem Mac gibt es VLC (noch) nicht: das Binärpaket ist auf iOS
-        // festgelegt. Was der Systemplayer nicht öffnen kann, scheitert dort
-        // mit einer Meldung, statt still schwarz zu bleiben.
         AVPlayerEngine()
-        #endif
     }
 
     private func observe(_ engine: any VideoPlayerEngine) {
@@ -1853,19 +1818,17 @@ final class PlayerModel {
                     if case .failed(let failure) = state {
                         diagnostics.note("Wiedergabe gescheitert: \(failure)")
 
-                        // **Scheitert das Umpacken, bleibt VLC.**
+                        // **Scheitert das Umpacken, rechnet der Server um.**
                         //
-                        // Der Server entscheidet erst beim Ausliefern, ob er
+                        // Er entscheidet erst beim Ausliefern, ob er die
-                        // die Ströme wirklich kopieren kann — und manche
+                        // Ströme wirklich kopieren kann — und manche Antworten
-                        // Antworten kann AVPlayer nicht annehmen, auch wenn
+                        // kann AVPlayer nicht annehmen, auch wenn sie formal
-                        // sie formal richtig sind. Das hier vorher zu wissen
+                        // richtig sind. Das vorher zu wissen ist nicht
-                        // ist nicht möglich; es hinterher aufzufangen schon.
+                        // möglich; es hinterher aufzufangen schon.
                         //
                         // Ohne diesen Weg stünde der Nutzer vor einer
-                        // schwarzen Wand mit einer Fehlernummer, obwohl ein
+                        // schwarzen Wand mit einer Fehlernummer.
-                        // Player danebensteht, der die Datei anstandslos
+                        if case .remux = decision?.method, await fallBackToTranscode() { return }
-                        // spielt.
-                        if case .remux = decision?.method, await fallBackToVLC() { return }
 
                         diagnostics.finish(outcome: "Wiedergabe gescheitert: \(failure)")
                         // Der Grund gehört auf den Bildschirm, nicht nur ins

Flixy/Views/Player/PlayerView.swift

@@ -516,11 +516,9 @@ struct PlayerView: View {
                 )
             }
 
-            // **Bild-in-Bild von Hand.** Automatisch geht es bisher nur beim
+            // **Bild-in-Bild von Hand.** Automatisch geht es nur beim
             // Verlassen der App — und auf dem Mac gar nicht. Der Knopf
-            // erscheint nur, wenn es wirklich ginge: bei VLC gibt es keine
+            // erscheint nur, wenn es wirklich ginge.
-            // `AVPlayerLayer`, und ohne die kann das System kein kleines Fenster
-            // aufziehen.
             if model.canUsePictureInPicture {
                 Button {
                     model.togglePictureInPicture()

Flixy/Views/Player/VideoSurface.swift

@@ -6,11 +6,6 @@ import UIKit
 #else
 import AppKit
 #endif
-// Siehe `PlaybackSettings`: `!os(tvOS)` muss dazu, sonst bricht der
-// Abhängigkeits-Sucher an VLCKit ab, das für dieses Ziel gar nicht gebaut wird.
-#if canImport(FlixyVLC) && !os(tvOS)
-import FlixyVLC
-#endif
 
 /// Die Ansichtsklasse der jeweiligen Plattform.
 ///
@@ -22,12 +17,7 @@ typealias PlatformView = UIView
 typealias PlatformView = NSView
 #endif
 
-/// Die Bildfläche des laufendie Engine.
+/// Die Bildfläche der laufenden Engine.
-///
-/// Die einzige Stelle in der App, an der der Unterschied zwischen den beiden
-/// Engines sichtbar wird — weil beide ihr Bild auf unterschiedliche Weise
-/// ausliefern: AVPlayer über eine `AVPlayerLayer`, VLC in eine gewöhnliche
-/// `UIView`.
 struct VideoSurface: View {
     let engine: (any VideoPlayerEngine)?
     /// Die Bildebene des Systemplayers, gehalten vom Modell.
@@ -36,8 +26,6 @@ struct VideoSurface: View {
     /// entsteht, stirbt mit jedem Identitätswechsel der Ansicht — und genau
     /// das passiert beim Wechsel zwischen Kachel und Vollbild. Das Bild
     /// setzte dann jedes Mal neu an, sichtbar als Zucken und Schwarzbild.
-    /// VLC macht es seit jeher richtig und reicht seine `videoView` durch;
-    /// hier ist es jetzt derselbe Weg.
     let surface: PlayerLayerView
 
     /// Ob **diese** Ansicht die Bildfläche gerade haben soll.
@@ -61,21 +49,11 @@ struct VideoSurface: View {
     var bottomInset: CGFloat = 0
 
     var body: some View {
-        #if canImport(FlixyVLC) && !os(tvOS)
-        if let vlcEngine = engine as? VLCPlayerEngine {
-            SurfaceContainer(view: vlcEngine.videoView, isActive: isActive, bottomInset: bottomInset)
-        } else if engine is AVPlayerEngine {
-            SurfaceContainer(view: surface, isActive: isActive, bottomInset: bottomInset)
-        } else {
-            Color.black
-        }
-        #else
         if engine is AVPlayerEngine {
             SurfaceContainer(view: surface, isActive: isActive, bottomInset: bottomInset)
         } else {
             Color.black
         }
-        #endif
     }
 }
 

Packages/FlixyKit/Package.swift

@@ -61,9 +61,7 @@ let package = Package(
         .testTarget(name: "FlixyDesignTests", dependencies: ["FlixyDesign"]),
 
         // Die Wiedergabe-Abstraktion samt AVPlayer-Engine und der Entscheidung
-        // DirectPlay/Transcode. VLCKit steckt bewusst NICHT hier drin, sondern
+        // direkt / umpacken / umrechnen.
-        // in FlixyPlaybackVLC — sonst zöge jeder Testlauf ein 920 MB großes
-        // xcframework hinter sich her.
         .target(name: "FlixyPlayback", dependencies: ["MediaKit"]),
         .testTarget(name: "FlixyPlaybackTests", dependencies: ["FlixyPlayback"]),
 

Packages/FlixyKit/Sources/FlixyPlayback/Decision/DeviceCapabilities.swift

@@ -2,10 +2,10 @@ import Foundation
 
 /// Was AVPlayer auf diesem Gerät nativ abspielen kann.
 ///
-/// Diese Liste ist der Grund, warum Flixy überhaupt zwei Engines hat. iOS
+/// Diese Liste ist der Grund, warum es das Umpacken gibt: iOS spielt weder
-/// spielt weder Matroska-Dateien noch DTS- oder TrueHD-Ton — und genau das
+/// Matroska-Dateien noch DTS- oder TrueHD-Ton, und genau das liegt in
-/// liegt in typischen Plex-Beständen. Alles, was hier nicht steht, geht an
+/// typischen Beständen. Alles, was hier nicht steht, lässt die App vom Server
-/// VLCKit (oder ab Phase 2 an den Transcoder).
+/// umpacken — beim Abspielen wie beim Herunterladen.
 public struct DeviceCapabilities: Sendable, Equatable {
     public var containers: Set<String>
     public var videoCodecs: Set<String>
@@ -26,7 +26,7 @@ public struct DeviceCapabilities: Sendable, Equatable {
         containers: ["mp4", "m4v", "mov", "qt"],
         // AV1 fehlt bewusst: Hardware-Dekodierung gibt es erst ab A17 Pro, und
         // Software-Dekodierung von 4K-AV1 bringt auch neue Geräte an die
-        // Grenze. VLC macht das kontrollierter.
+        // Grenze. Umrechnen ist dort das Verlässlichere.
         videoCodecs: ["h264", "avc1", "hevc", "h265", "hvc1", "dvh1", "dvhe"],
         // DTS, TrueHD und Vorbis fehlen — die drei Gründe, warum ein sonst
         // tadelloser MP4-Film trotzdem stumm bliebe.

Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift

@@ -81,10 +81,9 @@ public struct PlaybackDecider: Sendable {
             // Bild. Beides zusammen geht ebenso.
             //
             // Das kostet Tonqualität, und zwar nur beim Ton. Dagegen steht,
-            // was es einbringt: der Titel landet bei AVPlayer statt bei VLC,
+            // was es einbringt: der Titel läuft überhaupt — mit Bild-in-Bild,
-            // also mit Bild-in-Bild, AirPlay und Sperrbildschirm — und er
+            // AirPlay und Sperrbildschirm, und ohne dass das ganze Bild neu
-            // läuft auf dem Apple TV, wo es VLC nicht gibt, ohne dass das
+            // gerechnet werden muss.
-            // ganze Bild neu gerechnet werden muss.
             //
             // Stimmt dagegen der **Videocodec** nicht, ist hier Schluss: dann
             // fehlt nicht der Zugang, sondern das Können, und jeder Weg über
@@ -111,21 +110,20 @@ public struct PlaybackDecider: Sendable {
         }
 
         rationale.append(.nativelySupported)
-        return PlaybackDecision(method: .directPlay(engine: .avPlayer), rationale: rationale)
+        return PlaybackDecision(method: .directPlay, rationale: rationale)
     }
 
     /// Was passiert, wenn AVPlayer nicht kann.
     ///
-    /// VLCKit hat Vorrang vor dem Transcoder: die Datei geht unverändert über
+    /// **Hier stand einmal eine zweite Engine.** VLCKit hatte Vorrang vor dem
-    /// die Leitung, der Server muss nicht rechnen, und die Bildqualität bleibt
+    /// Transcoder: die Datei ging unverändert über die Leitung, der Server
-    /// die des Originals. Umgerechnet wird erst, wenn auch VLC ausscheidet.
+    /// musste nicht rechnen. Es gibt sie nicht mehr — was der Systemplayer
+    /// nicht öffnet, rechnet der Server um, und was heruntergeladen wird,
+    /// kommt schon in einer Hülle, die er öffnet.
     private func fallback(
         policy: PlaybackPolicy,
         rationale: [PlaybackDecision.Rationale]
     ) -> PlaybackDecision {
-        if policy.allowsFallbackEngine {
-            return PlaybackDecision(method: .directPlay(engine: .vlc), rationale: rationale)
-        }
         if policy.allowsTranscoding {
             return PlaybackDecision(
                 method: .transcode(maximumBitrate: policy.maximumBitrate),
@@ -134,7 +132,7 @@ public struct PlaybackDecider: Sendable {
         }
         var rationale = rationale
         rationale.append(.transcodingUnavailable)
-        return PlaybackDecision(method: .directPlay(engine: .avPlayer), rationale: rationale)
+        return PlaybackDecision(method: .directPlay, rationale: rationale)
     }
 
     /// Plex schreibt Codecs mal groß, mal klein, und hängt bei Containern

Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecision.swift

@@ -1,19 +1,10 @@
 import Foundation
 
-/// Welcher Engine die Wiedergabe übernimmt.
-public enum PlaybackEngineKind: String, Sendable, Equatable, Codable {
-    /// Der Systemplayer. Bringt Bild-in-Bild, AirPlay und die Steuerung im
-    /// Sperrbildschirm mit — deshalb hat er immer Vorrang, wenn er kann.
-    case avPlayer
-    /// VLCKit. Spielt praktisch jedes Format, kann dafür kein Bild-in-Bild.
-    case vlc
-}
-
 /// Wie ein Titel abgespielt werden soll.
 public struct PlaybackDecision: Sendable, Equatable {
     public enum Method: Sendable, Equatable {
         /// Die Datei wird unverändert übertragen und lokal dekodiert.
-        case directPlay(engine: PlaybackEngineKind)
+        case directPlay
         /// Der Server reicht das Bild durch und legt es in eine andere
         /// Schachtel — den Ton rechnet er um, falls nötig.
         ///
@@ -33,10 +24,9 @@ public struct PlaybackDecision: Sendable, Equatable {
         /// nichts, vor allem keine einzige Bildzeile. Ob es im Einzelfall
         /// passiert ist, steht in `rationale`: `audioCodecUnsupported`.
         ///
-        /// Der Gewinn ist gross: solche Titel landen nicht mehr bei VLC,
+        /// Der Gewinn ist gross: solche Titel laufen damit im Systemplayer,
-        /// sondern bei AVPlayer. Damit gibt es dort Bild-in-Bild, AirPlay und
+        /// mit Bild-in-Bild, AirPlay und Systembedienung — und es muss nicht
-        /// die Systembedienung — und auf einem Apple TV, wo es VLC gar nicht
+        /// das ganze Bild neu gerechnet werden.
-        /// gibt, muss nicht mehr das ganze Bild neu gerechnet werden.
         case remux
         /// Der Server rechnet um. Ab Phase 2; `maximumBitrate` in Kilobit.
         case transcode(maximumBitrate: Int?)
@@ -68,19 +58,6 @@ public struct PlaybackDecision: Sendable, Equatable {
         self.rationale = rationale
     }
 
-    public var engine: PlaybackEngineKind? {
-        switch method {
-        case .directPlay(let engine): engine
-        // Der Transcoder liefert HLS, und damit ist AVPlayer der richtige
-        // Engine. **Nicht** aber, wie hier früher stand, „inklusive
-        // automatischem Bitratenwechsel": den gibt es nur, wenn die Playlist
-        // mehrere Stufen führt, und das muss ausdrücklich bestellt werden.
-        case .transcode: .avPlayer
-        // Umgepackt kommt eine MP4 heraus — genau das, wofür es AVPlayer gibt.
-        case .remux: .avPlayer
-        }
-    }
-
     public var isDirectPlay: Bool {
         if case .directPlay = method { return true }
         return false

Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackPolicy.swift

@@ -9,8 +9,6 @@ import Foundation
 public struct PlaybackPolicy: Sendable, Equatable {
     /// Darf der Server umrechnen?
     public var allowsTranscoding: Bool
-    /// Darf VLCKit einspringen?
-    public var allowsFallbackEngine: Bool
     /// Obergrenze in Kilobit pro Sekunde. `nil` heißt unbegrenzt — der
     /// Normalfall im heimischen WLAN.
     public var maximumBitrate: Int?
@@ -24,12 +22,10 @@ public struct PlaybackPolicy: Sendable, Equatable {
 
     public init(
         allowsTranscoding: Bool,
-        allowsFallbackEngine: Bool = true,
         maximumBitrate: Int? = nil,
         forcesTranscoding: Bool = false
     ) {
         self.allowsTranscoding = allowsTranscoding
-        self.allowsFallbackEngine = allowsFallbackEngine
         self.maximumBitrate = maximumBitrate
         self.forcesTranscoding = forcesTranscoding
     }

Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlayerQuality.swift

@@ -164,14 +164,10 @@ public enum PlayerQuality: Hashable, Sendable, Identifiable {
             base
         case .original:
             // Keine Grenze und kein Umrechnen: ausdrücklich das Original.
-            PlaybackPolicy(allowsTranscoding: false, allowsFallbackEngine: true, maximumBitrate: nil)
+            PlaybackPolicy(allowsTranscoding: false, maximumBitrate: nil)
         case .limited, .audioOnly:
-            // Ohne Ersatzmotor, damit die Entscheidung zwangsläufig beim
-            // Transcoder landet — sonst spielte VLC die Datei direkt ab und
-            // die gewählte Stufe bliebe wirkungslos.
             PlaybackPolicy(
                 allowsTranscoding: true,
-                allowsFallbackEngine: false,
                 maximumBitrate: maximumBitrate,
                 forcesTranscoding: true
             )

Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift

@@ -419,8 +419,8 @@ public final class AVPlayerEngine: VideoPlayerEngine {
             player.observe(\.timeControlStatus, options: [.new]) { [weak self] player, _ in
                 // Kein `assumeIsolated`: KVO meldet auf dem Thread, der die
                 // Änderung ausgelöst hat, und AVPlayer ändert seinen Zustand
-                // auch aus internen Threads. Genau dieselbe Annahme hat die App
+                // auch aus internen Threads. Dieselbe Annahme hat die App
-                // im VLC-Engine zum Absturz gebracht.
+                // an anderer Stelle schon einmal hart abbrechen lassen.
                 Task { @MainActor in
                     guard let self else { return }
                     switch player.timeControlStatus {

Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift

@@ -2,10 +2,10 @@ import Foundation
 
 /// Eine wählbare Ton- oder Untertitelspur.
 ///
-/// Bewusst getrennt von den Spuren, die der Server meldet: VLCKit und
+/// Bewusst getrennt von den Spuren, die der Server meldet: der Player
-/// AVPlayer nummerieren selbst, und ihre Nummern stimmen mit denen des Servers
+/// nummeriert selbst, und seine Nummern stimmen mit denen des Servers nicht
-/// nicht überein. `engineIdentifier` hält fest, wie die laufende Engine die
+/// überein. `engineIdentifier` hält fest, wie die Engine die Spur nennt,
-/// Spur nennt, `serverStreamID`, wie der Server sie nennt.
+/// `serverStreamID`, wie der Server sie nennt.
 public struct MediaTrack: Sendable, Equatable, Identifiable {
     public enum Kind: Sendable, Equatable { case audio, subtitle }
 

Packages/FlixyKit/Sources/FlixyPlayback/Engine/VideoPlayerEngine.swift

@@ -42,10 +42,9 @@ public struct PlaybackSource: Sendable, Equatable {
 
 /// Was eine Engine von sich aus meldet.
 ///
-/// Ein Stream statt beobachtbarer Eigenschaften: AVPlayer meldet über KVO,
+/// Ein Stream statt beobachtbarer Eigenschaften: der Player meldet über
-/// VLCKit über Delegat-Rückrufe. Beide in dieselbe Ereignisfolge zu
+/// KVO, und das in eine Ereignisfolge zu übersetzen hält den Unterschied an
-/// übersetzen hält den Unterschied an genau einer Stelle je Engine — statt in
+/// einer Stelle — statt in jeder View, die den Zustand anzeigt.
-/// jeder View, die den Zustand anzeigt.
 public enum PlaybackEvent: Sendable, Equatable {
     case stateChanged(PlaybackState)
     case timeChanged(Duration)
@@ -66,11 +65,11 @@ public enum VideoFit: Sendable {
     case fill
 }
 
-/// Der gemeinsame Nenner von AVPlayer und VLCKit.
+/// Was die Oberfläche zum Steuern braucht — und nichts darüber hinaus.
 ///
-/// Alles, was die Oberfläche zum Steuern braucht — und nichts darüber hinaus.
+/// **Ein Protokoll für einen Spieler.** Es gab einmal zwei, und der Schnitt
-/// Was hier nicht steht, gibt es für die Views nicht; dadurch bleibt der
+/// ist geblieben: er hält die Oberfläche von AVFoundation fern, und was hier
-/// Austausch des Engine unsichtbar.
+/// nicht steht, gibt es für die Views nicht.
 @MainActor
 public protocol VideoPlayerEngine: AnyObject {
     var events: AsyncStream<PlaybackEvent> { get }
@@ -86,8 +85,7 @@ public protocol VideoPlayerEngine: AnyObject {
 
     /// Ob dieser Engine sein Bild an ein AirPlay-Gerät geben kann.
     ///
-    /// Nur der Systemplayer kann das. VLC zeichnet selbst und kennt die
+    /// Ein Knopf dafür darf nur stehen, wo er auch etwas trifft.
-    /// Empfängerliste nicht — ein Knopf dafür führte dort ins Leere.
     var supportsAirPlay: Bool { get }
 
     func load(_ source: PlaybackSource) async throws(PlaybackFailure)
@@ -96,18 +94,6 @@ public protocol VideoPlayerEngine: AnyObject {
     func seek(to time: Duration) async
     func setRate(_ rate: Double)
 
-    /// Wie das Bild in seiner Fläche liegt.
-    ///
-    /// **Muss durch die Engine, nicht nur über die Fläche.** Wer die Fläche
-    /// auf den ganzen Schirm wachsen lässt, hat damit erst die Hälfte gesagt:
-    /// VLC zeichnet selbst und passt sein Bild von sich aus ein, also wird
-    /// der Balken daneben nur breiter. Beschneiden muss man ihm sagen.
-    ///
-    /// Der Systemplayer braucht es nicht — seine Bildebene gehört der App,
-    /// und die stellt `videoGravity` selbst. Deshalb steht unten eine
-    /// Voreinstellung, die nichts tut.
-    func setVideoFit(_ fit: VideoFit)
-
     var audioTracks: [MediaTrack] { get }
     var subtitleTracks: [MediaTrack] { get }
     func selectAudioTrack(_ track: MediaTrack?)
@@ -144,8 +130,7 @@ public protocol VideoPlayerEngine: AnyObject {
     /// Wunsch, keine Vorschrift.
     func setPeakBitrate(_ kilobits: Int?)
 
-    /// Gibt Puffer und Dekoder frei. Muss beim Verlassen des Players laufen,
+    /// Gibt Puffer und Dekoder frei. Muss beim Verlassen des Players laufen.
-    /// sonst behält besonders VLCKit den Speicher.
     func teardown()
 }
 
@@ -255,9 +240,6 @@ extension VideoPlayerEngine {
 
     /// Wer Untertitel nicht gestalten kann, lässt sie, wie sie sind.
     ///
-    /// VLC kann es im Grundsatz, aber nur über Angaben, die beim Bau der
-    /// Bibliothek gesetzt werden, global gelten und sich mitten im Film nicht
-    /// ändern lassen — ein zweiter Weg, der vom ersten abdriftet.
     public func applySubtitleStyle(_ style: SubtitleStyle) {}
 
     /// Wer nichts dazu sagt, kann es nicht.

Packages/FlixyKit/Sources/JellyfinKit/JellyfinBackend+Playback.swift

@@ -16,7 +16,7 @@ extension JellyfinBackend {
             // `static=true` schaltet jede Umrechnung ab: die Datei kommt so,
             // wie sie auf der Platte liegt. Ob das Gerät sie überhaupt
             // abspielen kann, ist vorher entschieden worden — und wenn nicht
-            // der Systemplayer, dann VLC.
+            // der Systemplayer.
             guard let url = client.url(
                 path: "/Videos/\(intent.itemID)/stream",
                 query: [

Packages/FlixyKit/Tests/FlixyPlaybackTests/PlaybackDeciderTests.swift

@@ -49,59 +49,62 @@ struct PlaybackDeciderTests {
             policy: .directPlayOnly
         )
 
-        #expect(decision.method == .directPlay(engine: .avPlayer))
+        #expect(decision.method == .directPlay)
         #expect(decision.rationale.contains(.nativelySupported))
     }
 
-    // MARK: - Was VLC übernehmen muss
+    // MARK: - Was ohne Serverhilfe übrig bleibt
 
-    @Test("Matroska geht an VLC, auch bei nativen Codecs")
+    /// **Hier stand einmal VLC.** Eine zweite Engine nahm all das an, was
-    func matroskaFallsBackToVLC() {
+    /// AVPlayer nicht öffnet. Es gibt sie nicht mehr: darf der Server helfen,
+    /// packt er um oder rechnet um (siehe `RemuxDecisionTests`); darf er es
+    /// nicht, bleibt nur der Versuch — und der Grund steht in der Begründung.
+    @Test("Matroska ohne Serverhilfe: der Versuch, mit Begründung")
+    func matroskaWithoutServerHelp() {
         let decision = PlaybackDecider().decide(
             profile: profile(container: "mkv", video: "h264", audio: "aac"),
             policy: .directPlayOnly
         )
 
-        #expect(decision.method == .directPlay(engine: .vlc))
+        #expect(decision.method == .directPlay)
         #expect(decision.rationale.contains(.containerUnsupported("mkv")))
+        // Die Begründung ist der ganze Wert dieses Falls: ohne sie sähe das
+        // Scheitern aus wie ein Fehler der App.
+        #expect(decision.rationale.contains(.transcodingUnavailable))
     }
 
-    /// **Nur ohne Serverhilfe.** Darf umgepackt werden, geht dieselbe Datei
-    /// an AVPlayer — siehe `RemuxDecisionTests`. Hier ist Umrechnen verboten,
-    /// und dann bleibt VLC der einzige Weg.
     @Test(
-        "Nicht unterstützter Ton geht ohne Transcoder an VLC",
+        "Nicht unterstützter Ton ohne Transcoder: der Versuch",
         arguments: ["dts", "dca", "truehd", "vorbis", "opus"]
     )
-    func unsupportedAudioFallsBackToVLC(codec: String) {
+    func unsupportedAudioWithoutServerHelp(codec: String) {
         let decision = PlaybackDecider().decide(
             profile: profile(container: "mp4", video: "h264", audio: codec),
             policy: .directPlayOnly
         )
 
-        #expect(decision.method == .directPlay(engine: .vlc))
+        #expect(decision.method == .directPlay)
         #expect(decision.rationale.contains(.audioCodecUnsupported(codec)))
     }
 
     @Test(
-        "Nicht unterstütztes Bild geht an VLC",
+        "Nicht unterstütztes Bild geht an den Transcoder",
         arguments: ["av1", "vp9", "mpeg2video", "vc1", "wmv3"]
     )
-    func unsupportedVideoFallsBackToVLC(codec: String) {
+    func unsupportedVideoTranscodes(codec: String) {
+        // Steht das **Bild** im Weg, hilft Umpacken nicht — dieselben Ströme
+        // in einer anderen Hülle blieben dieselben Ströme.
         let decision = PlaybackDecider().decide(
             profile: profile(container: "mp4", video: codec, audio: "aac"),
-            policy: .directPlayOnly
+            policy: PlaybackPolicy(allowsTranscoding: true)
         )
 
-        #expect(decision.method == .directPlay(engine: .vlc))
+        #expect(decision.method == .transcode(maximumBitrate: nil))
         #expect(decision.rationale.contains(.videoCodecUnsupported(codec)))
     }
 
     @Test("Die gewählte Tonspur zählt, nicht die erste beste")
     func decisionFollowsSelectedAudioTrack() {
-        // Deutsches AAC ist ausgewählt, englisches DTS liegt daneben. Würde
-        // der Decider nur die erste Tonspur ansehen, ginge diese Datei
-        // unnötig an VLC — und damit ohne Bild-in-Bild.
         // Die Datei hat englisches DTS und deutsches AAC; gewählt ist
         // Deutsch. Entschieden wird über die Spur, die klingen soll — wer sie
         // aussucht, hat der Aufrufer beim Bauen des Profils entschieden.
@@ -109,18 +112,19 @@ struct PlaybackDeciderTests {
             profile: profile(container: "mp4", video: "h264", audio: "aac"),
             policy: .directPlayOnly
         )
-        #expect(decision.method == .directPlay(engine: .avPlayer))
+        #expect(decision.method == .directPlay)
     }
 
-    @Test("Unanalysierte Dateien gehen an den toleranteren Engine")
+    @Test("Unanalysierte Dateien gehen an den Transcoder")
-    func unknownStreamsFallBackToVLC() {
+    func unknownStreamsTranscode() {
         // Der Server hat die Datei noch nicht untersucht: keine Spuren, kein
-        // bekannter Codec. Dann ist Raten die falsche Antwort.
+        // bekannter Codec. Dann ist Raten die falsche Antwort — und seit es
+        // keine tolerantere Engine mehr gibt, ist Umrechnen die sichere.
         let decision = PlaybackDecider().decide(
             profile: MediaProfile(container: "mp4", hasKnownStreams: false),
-            policy: .directPlayOnly
+            policy: PlaybackPolicy(allowsTranscoding: true)
         )
-        #expect(decision.method == .directPlay(engine: .vlc))
+        #expect(decision.method == .transcode(maximumBitrate: nil))
         #expect(decision.rationale.contains(.streamsUnknown))
     }
 
@@ -162,16 +166,15 @@ struct PlaybackDeciderTests {
             profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 4_000),
             policy: policy
         )
-        #expect(decision.method == .directPlay(engine: .avPlayer))
+        #expect(decision.method == .directPlay)
     }
 
-    /// Auf dem Apple TV gibt es VLC nicht. Früher landete eine Datei mit
+    /// Früher landete eine Datei mit DTS-Ton beim vollen Neurechnen — Bild
-    /// DTS-Ton deshalb beim vollen Neurechnen — Bild inbegriffen, obwohl mit
+    /// inbegriffen, obwohl mit dem Bild nichts war. Jetzt bleibt es beim
-    /// dem Bild nichts war. Jetzt bleibt es beim Umpacken, und nur der Ton
+    /// Umpacken, und nur der Ton wird angefasst.
-    /// wird angefasst.
+    @Test("Umpacken reicht, solange das Bild passt")
-    @Test("Ohne VLC reicht Umpacken, solange das Bild passt")
+    func remuxIsEnough() {
-    func withoutFallbackEngineRemuxIsEnough() {
+        let policy = PlaybackPolicy(allowsTranscoding: true)
-        let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
 
         let decision = PlaybackDecider().decide(
             profile: profile(container: "mkv", video: "h264", audio: "dts"),
@@ -181,9 +184,9 @@ struct PlaybackDeciderTests {
     }
 
     /// Erst wenn auch das Bild nicht geht, muss wirklich gerechnet werden.
-    @Test("Ohne VLC übernimmt der Transcoder, sobald das Bild nicht passt")
+    @Test("Der Transcoder übernimmt, sobald das Bild nicht passt")
-    func withoutFallbackEngineTranscodingTakesOver() {
+    func transcodingTakesOver() {
-        let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
+        let policy = PlaybackPolicy(allowsTranscoding: true)
 
         let decision = PlaybackDecider().decide(
             profile: profile(container: "mkv", video: "av1", audio: "aac"),
@@ -195,15 +198,14 @@ struct PlaybackDeciderTests {
     @Test("Der Transcode-Weg läuft über AVPlayer")
     func transcodingUsesAVPlayer() {
         // HLS ist genau die Kost, für die AVPlayer gebaut ist — inklusive
-        // automatischem Bitratenwechsel. Deshalb darf VLC hier nicht greifen.
+        // automatischem Bitratenwechsel.
-        let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
+        let policy = PlaybackPolicy(allowsTranscoding: true)
 
         let decision = PlaybackDecider().decide(
             profile: profile(container: "mkv", video: "av1", audio: "aac"),
             policy: policy
         )
         #expect(decision.method == .transcode(maximumBitrate: nil))
-        #expect(decision.engine == .avPlayer)
     }
 
     @Test("Eine gewählte Stufe wird umgerechnet, auch wenn die Datei darunter liegt")
@@ -215,7 +217,6 @@ struct PlaybackDeciderTests {
             profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 8_000),
             policy: PlaybackPolicy(
                 allowsTranscoding: true,
-                allowsFallbackEngine: false,
                 maximumBitrate: 12_000,
                 forcesTranscoding: true
             )
@@ -232,7 +233,7 @@ struct PlaybackDeciderTests {
             policy: PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 12_000)
         )
 
-        #expect(decision.method == .directPlay(engine: .avPlayer))
+        #expect(decision.method == .directPlay)
     }
 }
 
@@ -241,12 +242,12 @@ struct RemuxDecisionTests {
     private let decider = PlaybackDecider()
 
     private var policy: PlaybackPolicy {
-        PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: true)
+        PlaybackPolicy(allowsTranscoding: true)
     }
 
     /// Der Blu-ray-Rip: Matroska aussen, lauter Dinge innen, die AVPlayer
     /// bestens kann. Im Weg steht allein die Verpackung — und dafür gibt es
-    /// das Umpacken, nicht VLC und schon gar nicht den Transcoder.
+    /// das Umpacken, und schon gar nicht den Transcoder.
     @Test("Matroska mit brauchbarem Inhalt wird umgepackt")
     func matroskaIsRemuxed() {
         let entscheidung = decider.decide(
@@ -257,15 +258,13 @@ struct RemuxDecisionTests {
             policy: policy
         )
         #expect(entscheidung.method == .remux)
-        // Und damit AVPlayer: Bild-in-Bild, AirPlay, weites Vorausladen.
-        #expect(entscheidung.engine == .avPlayer)
     }
 
     /// Steht der Ton im Weg, bleibt das Bild trotzdem unberührt: der Server
     /// kopiert es und rechnet genau die eine Tonspur um. Das ist der Grund,
     /// warum DTS auf dem Apple TV nicht mehr das ganze Bild kostet.
     @Test(
-        "Nicht unterstützter Ton wird umgepackt, nicht an VLC gegeben",
+        "Nicht unterstützter Ton wird umgepackt, nicht neu gerechnet",
         arguments: ["dts", "dca", "truehd", "vorbis", "opus"]
     )
     func unsupportedAudioIsRemuxed(codec: String) {
@@ -277,7 +276,6 @@ struct RemuxDecisionTests {
             policy: policy
         )
         #expect(entscheidung.method == .remux)
-        #expect(entscheidung.engine == .avPlayer)
         // Die Begründung ist das, woran die Oberfläche später erkennt, dass
         // der Ton angefasst wurde — ohne sie stünde dort „ohne Neukodierung".
         #expect(entscheidung.rationale.contains(.audioCodecUnsupported(codec)))
@@ -317,7 +315,7 @@ struct RemuxDecisionTests {
     /// Der Gegenbeweis, und die Grenze: stimmt das **Bild** nicht, hilft kein
     /// Durchreichen — dann müsste jede Bildzeile neu gerechnet werden, und
     /// dafür ist dies nicht der Weg.
-    @Test("Bei falschem Bildcodec bleibt es beim Rückfall")
+    @Test("Bei falschem Bildcodec wird gerechnet")
     func wrongVideoCodecIsNotRemuxed() {
         let entscheidung = decider.decide(
             profile: MediaProfile(
@@ -326,7 +324,7 @@ struct RemuxDecisionTests {
             ),
             policy: policy
         )
-        #expect(entscheidung.method == .directPlay(engine: .vlc))
+        #expect(entscheidung.method == .transcode(maximumBitrate: nil))
     }
 
     /// Eine MP4, die AVPlayer ohnehin öffnet, wird nicht angefasst. Umpacken
@@ -340,7 +338,7 @@ struct RemuxDecisionTests {
             ),
             policy: policy
         )
-        #expect(entscheidung.method == .directPlay(engine: .avPlayer))
+        #expect(entscheidung.method == .directPlay)
     }
 
     /// Reicht die Leitung nicht, nützt Umpacken nichts: die Datei bliebe
@@ -352,27 +350,25 @@ struct RemuxDecisionTests {
                 container: "mkv", videoCodec: "hevc", audioCodec: "ac3",
                 bitrate: 80_000, hasKnownStreams: true
             ),
-            policy: PlaybackPolicy(
+            policy: PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 8_000)
-                allowsTranscoding: true, allowsFallbackEngine: true, maximumBitrate: 8_000
-            )
         )
         #expect(entscheidung.method == .transcode(maximumBitrate: 8_000))
     }
 
     /// Ohne Transcoder gibt es auch kein Umpacken — beides läuft über
     /// denselben Weg im Server.
-    @Test("Ohne Serverhilfe bleibt es bei VLC")
+    @Test("Ohne Serverhilfe bleibt nur der Versuch")
-    func withoutServerHelpVLC() {
+    func withoutServerHelp() {
         let entscheidung = decider.decide(
             profile: MediaProfile(
                 container: "mkv", videoCodec: "hevc", audioCodec: "ac3",
                 bitrate: 20_000, hasKnownStreams: true
             ),
-            policy: PlaybackPolicy(
+            policy: PlaybackPolicy(allowsTranscoding: false)
-                allowsTranscoding: false, allowsFallbackEngine: true
-            )
         )
-        #expect(entscheidung.method == .directPlay(engine: .vlc))
+        // Mehr als der Versuch bleibt nicht — aber der Grund steht dabei.
+        #expect(entscheidung.method == .directPlay)
+        #expect(entscheidung.rationale.contains(.transcodingUnavailable))
     }
 }
 

Packages/FlixyVLC/Package.swift

@@ -1,31 +0,0 @@
-// swift-tools-version: 6.2
-import PackageDescription
-
-/// VLCKit steckt bewusst in einem eigenen Package, nicht in FlixyKit.
-///
-/// Das Binärpaket ist 920 MB groß und entpackt sich zu rund 2,7 GB. Läge es im
-/// Abhängigkeitsbaum von FlixyKit, zöge es jeder `swift test`-Lauf hinter sich
-/// her — und aus drei Sekunden Testlaufzeit würden Minuten.
-let package = Package(
-    name: "FlixyVLC",
-    defaultLocalization: "en",
-    platforms: [.iOS(.v26)],
-    products: [
-        .library(name: "FlixyVLC", targets: ["FlixyVLC"]),
-    ],
-    dependencies: [
-        .package(name: "FlixyKit", path: "../FlixyKit"),
-        // Genau festgenagelt: die 4.0-Reihe ist noch im Alpha-Stadium, und die
-        // API hat sich zwischen den Vorabversionen mehrfach geändert.
-        .package(url: "https://github.com/videolan/vlckit.git", exact: "4.0.0-a24"),
-    ],
-    targets: [
-        .target(
-            name: "FlixyVLC",
-            dependencies: [
-                .product(name: "FlixyPlayback", package: "FlixyKit"),
-                .product(name: "VLCKit", package: "vlckit"),
-            ]
-        ),
-    ]
-)

Packages/FlixyVLC/Sources/FlixyVLC/VLCPlayerEngine.swift

@@ -1,375 +0,0 @@
-import AVFoundation
-import Foundation
-import FlixyPlayback
-import UIKit
-@preconcurrency import VLCKit
-
-/// Wiedergabe über VLCKit.
-///
-/// Der Weg für alles, was der Systemplayer nicht öffnet: Matroska-Container,
-/// DTS- und TrueHD-Ton, ältere Codecs. Langsamer beim Starten und stromhungriger,
-/// dafür spielt er praktisch jede Datei ohne Zutun des Servers.
-///
-/// `@preconcurrency import`, weil VLCKit als Objective-C-Bibliothek nichts über
-/// Nebenläufigkeit aussagt. Die ganze Klasse liegt deshalb auf dem Hauptakteur —
-/// VLCKit erwartet seine Rückrufe ohnehin dort.
-@MainActor
-public final class VLCPlayerEngine: NSObject, VideoPlayerEngine {
-    /// Die Fläche, in die VLC zeichnet. Die Ansicht hängt sie in ihren
-    /// Hierarchiebaum.
-    public let videoView: UIView = VLCSurfaceView()
-
-    private let player = VLCMediaPlayer()
-
-    /// Was VLC über den laufenden Stream weiß.
-    ///
-    /// Bisher meldete dieser Weg gar nichts: die Standardimplementierung gibt
-    /// `nil` zurück, und die Bitratenanzeige blieb bei VLC dauerhaft leer.
-    ///
-    /// **Keine Leiter, und das ist die richtige Aussage.** VLC spielt hier
-    /// eine Datei, keine Playlist — es gibt keine Stufen, zwischen denen
-    /// etwas wechseln könnte. `variantCount` bleibt deshalb `nil` und nicht
-    /// etwa `1`: „gibt es nicht" ist etwas anderes als „gibt es einmal".
-    ///
-    /// **Zur Bitrate, ehrlich:** libvlc führt `inputBitrate` als Byte je
-    /// Sekunde, deshalb der Faktor acht. Das ist der wahrscheinliche, aber
-    /// nicht belegte Fall — wer es prüfen will, hält den Wert neben die
-    /// bekannte Bitrate der Datei; liegt er um Faktor acht daneben, steht
-    /// hier das Falsche.
-    public var statistics: PlaybackStatistics? {
-        guard let media = player.media else { return nil }
-        let werte = media.statistics
-
-        let kilobit = Int((werte.inputBitrate * 8 / 1_000).rounded())
-        let größe = player.videoSize
-
-        return PlaybackStatistics(
-            observedBitrate: kilobit > 0 ? kilobit : nil,
-            indicatedBitrate: nil,
-            width: größe.width > 0 ? Int(größe.width) : nil,
-            height: größe.height > 0 ? Int(größe.height) : nil,
-            // Nur die wirklich verworfenen. `latePictures` sind zu spät
-            // gekommen, aber angezeigt worden — sie unter „verworfen" zu
-            // führen machte die Zahl größer und die Aussage falsch.
-            droppedFrames: Int(werte.lostPictures)
-        )
-    }
-
-    public private(set) var state: PlaybackState = .idle {
-        didSet {
-            guard state != oldValue else { return }
-            continuation?.yield(.stateChanged(state))
-        }
-    }
-
-    public private(set) var duration: Duration?
-    public private(set) var audioTracks: [MediaTrack] = []
-    public private(set) var subtitleTracks: [MediaTrack] = []
-
-    public var currentTime: Duration {
-        .milliseconds(Int(player.time.intValue))
-    }
-
-    /// VLCKit 4 bringt ein eigenes Bild-in-Bild-Protokoll mit
-    /// (`VLCPictureInPictureMediaControlling`). Angebunden ist es noch nicht —
-    /// solange steht hier `false`, damit kein Knopf erscheint, der nichts tut.
-    /// Nachzuholen in Phase 2, zusammen mit der Steuerung im Sperrbildschirm.
-    public let supportsPictureInPicture = false
-
-    public private(set) lazy var events: AsyncStream<PlaybackEvent> = {
-        AsyncStream { continuation in
-            self.continuation = continuation
-        }
-    }()
-
-    private var continuation: AsyncStream<PlaybackEvent>.Continuation?
-    private var pendingStartTime: Duration = .zero
-
-    /// Wie das Bild in `videoView` liegen soll.
-    ///
-    /// **Gemerkt und nicht nur weitergegeben.** Solange VLC keine
-    /// Bildausgabe hat, gibt es nichts, worauf die Einstellung wirken könnte;
-    /// vor dem ersten Bild gesetzt, ist sie weg. Deshalb steht sie hier und
-    /// wird beim Anlaufen erneut gelegt.
-    private var fit: VideoFit = .fit
-
-    public override init() {
-        super.init()
-        videoView.backgroundColor = .black
-        player.delegate = self
-        player.drawable = videoView
-        AudioSessionBridge.activate()
-    }
-
-    public func load(_ source: PlaybackSource) async throws(PlaybackFailure) {
-        state = .loading
-        pendingStartTime = source.startTime
-
-        // `initWithURL:` ist nullable. Ohne diese Prüfung bliebe `media` still
-        // `nil`, `play()` täte nichts, und auf dem Bildschirm stünde ein
-        // Ladekreis ohne Ende — ohne dass irgendwo ein Fehler aufschlüge.
-        guard let media = VLCMedia(url: source.url) else {
-            let failure = PlaybackFailure(
-                kind: .sourceUnavailable,
-                underlyingDescription: "VLCMedia ließ sich für \(source.url) nicht anlegen"
-            )
-            state = .failed(failure)
-            throw failure
-        }
-        player.media = media
-
-        // VLC kennt Länge und Spuren erst, wenn es die Datei geöffnet hat.
-        // Beides kommt später über den Delegaten — hier gibt es nichts zu
-        // warten, und ein `await` würde nur den Bildaufbau verzögern.
-        player.play()
-    }
-
-    public func play() {
-        player.play()
-    }
-
-    public func pause() {
-        // `pause()` ist bei VLC ein Umschalter. Ohne diese Prüfung würde ein
-        // Aufruf im pausierten Zustand die Wiedergabe wieder starten.
-        if player.isPlaying { player.pause() }
-    }
-
-    public func seek(to time: Duration) async {
-        player.time = VLCTime(int: time.vlcMilliseconds)
-        continuation?.yield(.timeChanged(time))
-    }
-
-    public func setRate(_ rate: Double) {
-        player.rate = Float(rate)
-    }
-
-    public func setVideoFit(_ fit: VideoFit) {
-        self.fit = fit
-        applyFit()
-    }
-
-    /// Legt die gemerkte Einstellung auf den Player.
-    ///
-    /// `smaller` heisst bei libvlc ausdrücklich „fit inside", `larger`
-    /// „fit outside" — also einpassen mit Balken beziehungsweise füllen mit
-    /// Beschnitt. Die Namen sagen es nicht von selbst; die Kopfdatei tut es.
-    private func applyFit() {
-        player.videoFitMode = fit == .fill ? .larger : .smaller
-    }
-
-    public func selectAudioTrack(_ track: MediaTrack?) {
-        select(track, from: player.audioTracks)
-    }
-
-    public func selectSubtitleTrack(_ track: MediaTrack?) {
-        select(track, from: player.textTracks)
-    }
-
-    public func teardown() {
-        player.stop()
-        player.delegate = nil
-        player.drawable = nil
-        continuation?.finish()
-        continuation = nil
-        state = .idle
-        AudioSessionBridge.deactivate()
-    }
-
-    // MARK: - Spuren
-
-    private func select(_ track: MediaTrack?, from tracks: [VLCMediaPlayer.Track]) {
-        guard let track, let identifier = track.engineTrackID else {
-            // Abschalten: alle Spuren dieser Art abwählen. Bei Untertiteln der
-            // Normalfall.
-            tracks.forEach { $0.isSelected = false }
-            return
-        }
-        // `isSelectedExclusively` wählt diese Spur und wählt die übrigen
-        // desselben Typs ab. Einzeln zu setzen ließe zwei Tonspuren gleichzeitig
-        // laufen.
-        tracks.first { $0.trackId == identifier }?.isSelectedExclusively = true
-    }
-
-    private func refreshTracks() {
-        audioTracks = player.audioTracks.map { $0.mediaTrack(kind: .audio) }
-        subtitleTracks = player.textTracks.map { $0.mediaTrack(kind: .subtitle) }
-        continuation?.yield(.tracksResolved(audio: audioTracks, subtitle: subtitleTracks))
-    }
-}
-
-// MARK: - VLCMediaPlayerDelegate
-
-/// VLCKit ruft den Delegaten von seinem **eigenen Input-Thread**, nicht über
-/// die Hauptwarteschlange.
-///
-/// Hier stand vorher das Gegenteil, und darauf aufbauend `assumeIsolated` —
-/// mit dem Ergebnis, dass die App beim Drücken auf Play hart abbrach, sobald
-/// VLC den ersten Zustandswechsel meldete:
-///
-///     _dispatch_assert_queue_fail
-///     MainActor.assumeIsolated
-///     VLCPlayerEngine.mediaPlayerStateChanged(_:)
-///     VLCKit input_thread_Events
-///
-/// Deshalb jetzt ein echter Sprung auf den Hauptakteur. Die Reihenfolge bleibt
-/// dabei erhalten: die Aufgaben werden aus demselben Thread nacheinander
-/// eingereiht und auch so abgearbeitet.
-extension VLCPlayerEngine: VLCMediaPlayerDelegate {
-    public nonisolated func mediaPlayerStateChanged(_ newState: VLCMediaPlayerState) {
-        Task { @MainActor in
-            switch newState {
-            case .opening:
-                state = .loading
-            case .playing:
-                state = .playing
-                applyPendingStartTime()
-                refreshTracks()
-                // Siehe `fit`: vor dem ersten Bild wäre sie ins Leere
-                // gegangen. Hier gibt es eine Ausgabe.
-                applyFit()
-            case .paused:
-                state = .paused
-            case .stopped, .stopping:
-                // VLC meldet das Ende einer Datei als „gestoppt". Ob das
-                // Ansehen abgeschlossen ist oder jemand abgebrochen hat,
-                // unterscheidet nur die Position.
-                state = isNearEnd ? .ended : .idle
-                if isNearEnd { continuation?.yield(.reachedEnd) }
-            case .error:
-                state = .failed(PlaybackFailure(kind: .formatUnsupported))
-            case .nothingSpecial:
-                break
-            @unknown default:
-                break
-            }
-        }
-    }
-
-    /// Der Puffer-Fortschritt — **der einzige Weg, auf dem VLC das Stocken
-    /// überhaupt meldet.**
-    ///
-    /// `VLCMediaPlayerState` kennt keinen Wert für „wartet auf Daten": die
-    /// Aufzählung führt nur `opening`, `playing`, `paused`, `stopped` und
-    /// `error`. Weil diese Methode bisher fehlte, ging der Zustand
-    /// `.buffering` auf dem VLC-Weg **nie** an — und damit löste der
-    /// Watchdog im Player dort nie aus. Ein hängender Stream lief stumm ins
-    /// Nichts, ohne Kreisel, ohne Meldung, ohne Abbruch.
-    ///
-    /// Nur aus dem Spielen heraus gewertet. Die Dokumentation sagt, dass vor
-    /// jeder erfolgreichen Wiedergabe einmal 0,0 und einmal 1,0 kommt —
-    /// dieses anfängliche Füllen ist der Start und kein Rückler, und es
-    /// mitzuzählen gäbe jeder Wiedergabe eine Vorstrafe.
-    public nonisolated func mediaPlayerBufferingChanged(_ progress: Float) {
-        Task { @MainActor in
-            if progress >= 1 {
-                if state == .buffering { state = .playing }
-            } else if state == .playing {
-                state = .buffering
-            }
-        }
-    }
-
-    public nonisolated func mediaPlayerTimeChanged(_ aNotification: Notification) {
-        Task { @MainActor in
-            continuation?.yield(.timeChanged(currentTime))
-        }
-    }
-
-    public nonisolated func mediaPlayerLengthChanged(_ length: Int64) {
-        Task { @MainActor in
-            guard length > 0 else { return }
-            let value = Duration.milliseconds(length)
-            duration = value
-            continuation?.yield(.durationResolved(value))
-        }
-    }
-
-    /// Beim Fortsetzen: VLC nimmt eine Position erst an, wenn die Wiedergabe
-    /// tatsächlich läuft. Vorher gesetzt, wird sie kommentarlos verworfen.
-    private func applyPendingStartTime() {
-        guard pendingStartTime > .zero else { return }
-        player.time = VLCTime(int: pendingStartTime.vlcMilliseconds)
-        pendingStartTime = .zero
-    }
-
-    private var isNearEnd: Bool {
-        // Ein Rest von unter zwei Sekunden zählt als durchgesehen — VLC
-        // stoppt selten exakt am Dateiende.
-        guard let duration else { return false }
-        return currentTime + .seconds(2) >= duration
-    }
-}
-
-extension Duration {
-    /// Millisekunden als `Int32`, wie VLCTime sie erwartet.
-    ///
-    /// Abgeschnitten statt umgewandelt: `Int32(...)` stürzt bei Überlauf ab,
-    /// und die Grenze liegt bei rund 24 Tagen Laufzeit. Das wird keine Datei
-    /// erreichen — aber ein Absturz an dieser Stelle wäre besonders schwer zu
-    /// erklären.
-    var vlcMilliseconds: Int32 {
-        let milliseconds = components.seconds * 1000
-        return Int32(clamping: milliseconds)
-    }
-}
-
-extension VLCMediaPlayer.Track {
-    fileprivate func mediaTrack(kind: MediaTrack.Kind) -> MediaTrack {
-        MediaTrack(
-            id: "vlc-\(trackId)",
-            kind: kind,
-            displayName: trackName.isEmpty ? trackId : trackName,
-            engineIdentifier: nil
-        )
-    }
-}
-
-extension MediaTrack {
-    /// VLC führt seine Spuren unter Zeichenketten, nicht unter Zahlen —
-    /// deshalb steckt die Kennung im `id`-Feld statt in `engineIdentifier`.
-    fileprivate var engineTrackID: String? {
-        id.hasPrefix("vlc-") ? String(id.dropFirst(4)) : nil
-    }
-}
-
-/// Die Tonsitzung, damit der Ton auch bei umgelegtem Stummschalter läuft.
-enum AudioSessionBridge {
-    static func activate() {
-        try? AVAudioSession.sharedInstance().setCategory(.playback, mode: .moviePlayback)
-        try? AVAudioSession.sharedInstance().setActive(true)
-    }
-
-    static func deactivate() {
-        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-    }
-}
-
-/// Die Fläche, die VLC als Zeichenfläche bekommt.
-///
-/// **Eine eigene Klasse, weil VLC seine Anzeigefläche nur ein einziges Mal
-/// misst.** `VLCDrawable` verlangt vom Aufnehmenden zwei Dinge: `addSubview:`
-/// und `bounds`. VLCKit fragt die Grösse beim Anlegen ab, legt seine
-/// `VLCVideoUIView` genau so gross an und überlässt sie danach der
-/// Autoresizing-Maske. Eine Maske hält aber den **Unterschied** fest, nicht
-/// das Verhältnis: was beim Anlegen zu gross war, bleibt für immer um denselben
-/// Betrag zu gross.
-///
-/// Und beim Anlegen ist die Grösse regelmässig falsch — die Fläche entsteht
-/// mitten in der Drehung ins Querformat, während SwiftUI sie gerade einblendet.
-/// Gemessen: eine Anzeigefläche von 1200×480 Punkt in einer Zeichenfläche von
-/// 711×400. Auf dem Bildschirm sah man davon das Stück, das hineinpasste —
-/// unten rechts angeschlagen, in falschem Seitenverhältnis. Genau das war
-/// „das Bild sitzt nicht mittig" bei allem, was über VLC läuft.
-///
-/// Hier bekommt die Anzeigefläche bei jedem Layout wieder genau die eigene
-/// Grösse. Das ist keine Notlösung, sondern der Teil des Vertrags, den nur der
-/// Aufnehmende erfüllen kann: VLC kennt den Grund für eine Grössenänderung
-/// nicht, die Ansicht kennt ihn.
-final class VLCSurfaceView: UIView {
-    override func layoutSubviews() {
-        super.layoutSubviews()
-        for view in subviews where view.frame != bounds {
-            view.frame = bounds
-        }
-    }
-}

Tools/JellyfinStub/server.py

@@ -50,12 +50,15 @@ USERDATA_LOG = []
 # Mit `--unanalysed` melden die Quellen keine Spuren. Dann entscheidet die App
 # auf Umrechnen, und der Weg über PlaybackInfo lässt sich prüfen.
 UNANALYSED = "--unanalysed" in os.sys.argv
-# Mit `--vlc` melden die Quellen DTS-Ton. AVFoundation kann das nicht, also
+# Mit `--dts` melden die Quellen DTS-Ton. AVFoundation kann das nicht, also
-# faellt die App auf VLCKit zurueck — und dieser Weg ist sonst mit der
+# muss der Server umpacken — und dieser Weg ist sonst mit der Beispieldatei
-# Beispieldatei gar nicht erreichbar. Die Datei selbst bleibt dieselbe; VLC
+# gar nicht erreichbar. Die Datei selbst bleibt dieselbe; geprueft wird die
-# spielt sie ebenso, und geprueft wird der Weg, nicht der Ton.
+# Entscheidung, nicht der Ton.
-AS_VLC = "--vlc" in os.sys.argv
+#
-AUDIO_CODEC = "dts" if AS_VLC else "aac"
+# Hiess einmal `--vlc`, weil dieser Fall damals bei der zweiten Engine landete.
+# Die gibt es nicht mehr.
+AS_DTS = "--dts" in os.sys.argv
+AUDIO_CODEC = "dts" if AS_DTS else "aac"
 
 TITLES = [
     ("m1", "Der weite Himmel", "Movie", "Ein Mann, ein Berg, zwei Stunden Schweigen."),

project.yml

@@ -21,10 +21,6 @@ settings:
 packages:
   FlixyKit:
     path: Packages/FlixyKit
-  # Eigenes Package, weil das VLCKit-Binärpaket 920 MB wiegt und sonst bei
-  # jedem `swift test` in FlixyKit mitgezogen würde.
-  FlixyVLC:
-    path: Packages/FlixyVLC
 
 targets:
   Flixy:
@@ -69,8 +65,6 @@ targets:
         product: FlixyPlayback
       - package: FlixyKit
         product: FlixyDownloads
-      - package: FlixyVLC
-        product: FlixyVLC
     settings:
       base:
         PRODUCT_BUNDLE_IDENTIFIER: com.scarriffleservices.flixy
@@ -132,10 +126,9 @@ targets:
         # („Missing Compliance"), und der Build lässt sich bis dahin nicht
         # verteilen.
         #
-        # Zu beachten, falls sich das ändert: VLCKit ist ein fremdes Binary
+        # Zu beachten, falls sich das ändert: solange nur Dateien vom eigenen
-        # und bringt eigene Netzwerkbibliotheken mit. Solange nur Dateien vom
+        # Server abgespielt werden, bleibt es bei Standardverfahren. Käme
-        # eigenen Server abgespielt werden, bleibt es bei Standardverfahren.
+        # irgendwann etwas mit eigener Verschlüsselung dazu — DRM etwa —,
-        # Käme irgendwann etwas mit eigener Verschlüsselung dazu — DRM etwa —,
         # gehört dieser Wert überprüft.
         ITSAppUsesNonExemptEncryption: false