From 6b927c21b007cfcc3be4aa6bf8bea35807689563 Mon Sep 17 00:00:00 2001 From: Scarriffle Date: Sat, 3 Oct 2026 08:04:23 +0200 Subject: [PATCH] =?UTF-8?q?VLC=20ist=20weg=20=E2=80=94=20es=20gibt=20nur?= =?UTF-8?q?=20noch=20einen=20Spieler?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 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 --- .../xcshareddata/swiftpm/Package.resolved | 15 - Flixy/Resources/Localizable.xcstrings | 17 - Flixy/Session/NowPlaying.swift | 2 +- Flixy/Session/PlaybackDiagnostics.swift | 11 +- Flixy/Session/PlaybackSettings.swift | 31 -- Flixy/Session/PlexWebAuthenticator.swift | 2 +- Flixy/Session/TopShelfWriter.swift | 2 +- Flixy/Views/Detail/TechnicalDetails.swift | 7 +- Flixy/Views/Player/PlayerModel.swift | 101 ++--- Flixy/Views/Player/PlayerView.swift | 6 +- Flixy/Views/Player/VideoSurface.swift | 24 +- Packages/FlixyKit/Package.swift | 4 +- .../Decision/DeviceCapabilities.swift | 10 +- .../Decision/PlaybackDecider.swift | 22 +- .../Decision/PlaybackDecision.swift | 31 +- .../Decision/PlaybackPolicy.swift | 4 - .../Decision/PlayerQuality.swift | 6 +- .../FlixyPlayback/Engine/AVPlayerEngine.swift | 4 +- .../FlixyPlayback/Engine/MediaTrack.swift | 8 +- .../Engine/VideoPlayerEngine.swift | 36 +- .../JellyfinBackend+Playback.swift | 2 +- .../PlaybackDeciderTests.swift | 112 +++--- Packages/FlixyVLC/Package.swift | 31 -- .../Sources/FlixyVLC/VLCPlayerEngine.swift | 375 ------------------ Tools/JellyfinStub/server.py | 15 +- project.yml | 13 +- 26 files changed, 147 insertions(+), 744 deletions(-) delete mode 100644 Flixy.xcworkspace/xcshareddata/swiftpm/Package.resolved delete mode 100644 Packages/FlixyVLC/Package.swift delete mode 100644 Packages/FlixyVLC/Sources/FlixyVLC/VLCPlayerEngine.swift diff --git a/Flixy.xcworkspace/xcshareddata/swiftpm/Package.resolved b/Flixy.xcworkspace/xcshareddata/swiftpm/Package.resolved deleted file mode 100644 index 613e4ba..0000000 --- a/Flixy.xcworkspace/xcshareddata/swiftpm/Package.resolved +++ /dev/null @@ -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 -} diff --git a/Flixy/Resources/Localizable.xcstrings b/Flixy/Resources/Localizable.xcstrings index 9c4d2ee..eb37d97 100644 --- a/Flixy/Resources/Localizable.xcstrings +++ b/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": { diff --git a/Flixy/Session/NowPlaying.swift b/Flixy/Session/NowPlaying.swift index 7e23e76..cef6ccd 100644 --- a/Flixy/Session/NowPlaying.swift +++ b/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( diff --git a/Flixy/Session/PlaybackDiagnostics.swift b/Flixy/Session/PlaybackDiagnostics.swift index d4371f2..8d0fd95 100644 --- a/Flixy/Session/PlaybackDiagnostics.swift +++ b/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, -/// hängt bei Öffnen" — und das ist ein Unterschied, der Stunden spart. +/// Einstellungen. Aus „es läuft nicht" wird damit „umgepackt, lokale +/// 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): - switch engine { - case .avPlayer: "Direkt · AVPlayer" - case .vlc: "Direkt · VLC" - } + case .directPlay: + "Direkt" case .remux: decision.rationale.contains { if case .audioCodecUnsupported = $0 { true } else { false } } ? "Umgepackt · Bild unverändert, Ton umgerechnet" diff --git a/Flixy/Session/PlaybackSettings.swift b/Flixy/Session/PlaybackSettings.swift index 54489f0..7a93ce2 100644 --- a/Flixy/Session/PlaybackSettings.swift +++ b/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 ) } diff --git a/Flixy/Session/PlexWebAuthenticator.swift b/Flixy/Session/PlexWebAuthenticator.swift index ec96cbe..5ad5cfa 100644 --- a/Flixy/Session/PlexWebAuthenticator.swift +++ b/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 } diff --git a/Flixy/Session/TopShelfWriter.swift b/Flixy/Session/TopShelfWriter.swift index 2c801d2..29dbee7 100644 --- a/Flixy/Session/TopShelfWriter.swift +++ b/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 diff --git a/Flixy/Views/Detail/TechnicalDetails.swift b/Flixy/Views/Detail/TechnicalDetails.swift index c4631c9..841f5c8 100644 --- a/Flixy/Views/Detail/TechnicalDetails.swift +++ b/Flixy/Views/Detail/TechnicalDetails.swift @@ -96,11 +96,8 @@ struct TechnicalDetails: View { private var playbackMethodLabel: String { switch decision.method { - case .directPlay(let engine): - switch engine { - case .avPlayer: String(localized: "technical.directPlayNative") - case .vlc: String(localized: "technical.directPlayVLC") - } + case .directPlay: + String(localized: "technical.directPlayNative") // **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: diff --git a/Flixy/Views/Player/PlayerModel.swift b/Flixy/Views/Player/PlayerModel.swift index a052b63..c67de49 100644 --- a/Flixy/Views/Player/PlayerModel.swift +++ b/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 - // ginge jede Offline-Datei vorsichtshalber an VLC. + // Was heruntergeladen wurde, ist untersucht — und seit das + // 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 { - guard !hasFallenBack, policy.allowsFallbackEngine else { return false } + private func fallBackToTranscode() async -> Bool { + 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), - rationale: (decision?.rationale ?? []) + [.transcodingUnavailable] + method: .transcode(maximumBitrate: geltend.maximumBitrate), + 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 - /// App und nicht dem Systemplayer — deshalb steht `videoGravity` hier und - /// 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. + /// Die Bildebene gehört der App und nicht dem Systemplayer — deshalb + /// steht `videoGravity` hier und nicht in `AVPlayerEngine`. 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 - // die Ströme wirklich kopieren kann — und manche - // Antworten kann AVPlayer nicht annehmen, auch wenn - // sie formal richtig sind. Das hier vorher zu wissen - // ist nicht möglich; es hinterher aufzufangen schon. + // Er entscheidet erst beim Ausliefern, ob er die + // Ströme wirklich kopieren kann — und manche Antworten + // kann AVPlayer nicht annehmen, auch wenn sie formal + // richtig sind. Das vorher zu wissen ist nicht + // möglich; es hinterher aufzufangen schon. // // Ohne diesen Weg stünde der Nutzer vor einer - // schwarzen Wand mit einer Fehlernummer, obwohl ein - // Player danebensteht, der die Datei anstandslos - // spielt. - if case .remux = decision?.method, await fallBackToVLC() { return } + // schwarzen Wand mit einer Fehlernummer. + if case .remux = decision?.method, await fallBackToTranscode() { return } diagnostics.finish(outcome: "Wiedergabe gescheitert: \(failure)") // Der Grund gehört auf den Bildschirm, nicht nur ins diff --git a/Flixy/Views/Player/PlayerView.swift b/Flixy/Views/Player/PlayerView.swift index 55ca4f3..029d390 100644 --- a/Flixy/Views/Player/PlayerView.swift +++ b/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 - // `AVPlayerLayer`, und ohne die kann das System kein kleines Fenster - // aufziehen. + // erscheint nur, wenn es wirklich ginge. if model.canUsePictureInPicture { Button { model.togglePictureInPicture() diff --git a/Flixy/Views/Player/VideoSurface.swift b/Flixy/Views/Player/VideoSurface.swift index d9cf7b3..b463756 100644 --- a/Flixy/Views/Player/VideoSurface.swift +++ b/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 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`. +/// Die Bildfläche der laufenden Engine. 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 } } diff --git a/Packages/FlixyKit/Package.swift b/Packages/FlixyKit/Package.swift index 3aff79c..20171f2 100644 --- a/Packages/FlixyKit/Package.swift +++ b/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 - // in FlixyPlaybackVLC — sonst zöge jeder Testlauf ein 920 MB großes - // xcframework hinter sich her. + // direkt / umpacken / umrechnen. .target(name: "FlixyPlayback", dependencies: ["MediaKit"]), .testTarget(name: "FlixyPlaybackTests", dependencies: ["FlixyPlayback"]), diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/DeviceCapabilities.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/DeviceCapabilities.swift index 191d2e9..583dcd1 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/DeviceCapabilities.swift +++ b/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 -/// spielt weder Matroska-Dateien noch DTS- oder TrueHD-Ton — und genau das -/// liegt in typischen Plex-Beständen. Alles, was hier nicht steht, geht an -/// VLCKit (oder ab Phase 2 an den Transcoder). +/// Diese Liste ist der Grund, warum es das Umpacken gibt: iOS spielt weder +/// Matroska-Dateien noch DTS- oder TrueHD-Ton, und genau das liegt in +/// typischen Beständen. Alles, was hier nicht steht, lässt die App vom Server +/// umpacken — beim Abspielen wie beim Herunterladen. public struct DeviceCapabilities: Sendable, Equatable { public var containers: Set public var videoCodecs: Set @@ -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. diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift index a74a144..beffc1e 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecider.swift +++ b/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, - // also mit Bild-in-Bild, AirPlay und Sperrbildschirm — und er - // läuft auf dem Apple TV, wo es VLC nicht gibt, ohne dass das - // ganze Bild neu gerechnet werden muss. + // was es einbringt: der Titel läuft überhaupt — mit Bild-in-Bild, + // AirPlay und Sperrbildschirm, und ohne dass das 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 - /// die Leitung, der Server muss nicht rechnen, und die Bildqualität bleibt - /// die des Originals. Umgerechnet wird erst, wenn auch VLC ausscheidet. + /// **Hier stand einmal eine zweite Engine.** VLCKit hatte Vorrang vor dem + /// Transcoder: die Datei ging unverändert über die Leitung, der Server + /// 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 diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecision.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecision.swift index 4268dbd..d022eac 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecision.swift +++ b/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, - /// sondern bei AVPlayer. Damit gibt es dort Bild-in-Bild, AirPlay und - /// die Systembedienung — und auf einem Apple TV, wo es VLC gar nicht - /// gibt, muss nicht mehr das ganze Bild neu gerechnet werden. + /// Der Gewinn ist gross: solche Titel laufen damit im Systemplayer, + /// mit Bild-in-Bild, AirPlay und Systembedienung — und es muss nicht + /// 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 diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackPolicy.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackPolicy.swift index 093ff79..e08e90f 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackPolicy.swift +++ b/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 } diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlayerQuality.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlayerQuality.swift index 35a49be..2e84beb 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlayerQuality.swift +++ b/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 ) diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift index cc12c01..017840e 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/AVPlayerEngine.swift +++ b/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 - // im VLC-Engine zum Absturz gebracht. + // auch aus internen Threads. Dieselbe Annahme hat die App + // an anderer Stelle schon einmal hart abbrechen lassen. Task { @MainActor in guard let self else { return } switch player.timeControlStatus { diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift index ae0e7f1..80de8a7 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift +++ b/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 -/// AVPlayer nummerieren selbst, und ihre Nummern stimmen mit denen des Servers -/// nicht überein. `engineIdentifier` hält fest, wie die laufende Engine die -/// Spur nennt, `serverStreamID`, wie der Server sie nennt. +/// Bewusst getrennt von den Spuren, die der Server meldet: der Player +/// nummeriert selbst, und seine Nummern stimmen mit denen des Servers nicht +/// überein. `engineIdentifier` hält fest, wie die Engine die Spur nennt, +/// `serverStreamID`, wie der Server sie nennt. public struct MediaTrack: Sendable, Equatable, Identifiable { public enum Kind: Sendable, Equatable { case audio, subtitle } diff --git a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/VideoPlayerEngine.swift b/Packages/FlixyKit/Sources/FlixyPlayback/Engine/VideoPlayerEngine.swift index 4ce3309..020fb7c 100644 --- a/Packages/FlixyKit/Sources/FlixyPlayback/Engine/VideoPlayerEngine.swift +++ b/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, -/// VLCKit über Delegat-Rückrufe. Beide in dieselbe Ereignisfolge zu -/// übersetzen hält den Unterschied an genau einer Stelle je Engine — statt in -/// jeder View, die den Zustand anzeigt. +/// Ein Stream statt beobachtbarer Eigenschaften: der Player meldet über +/// KVO, und das in eine Ereignisfolge zu übersetzen hält den Unterschied an +/// einer Stelle — statt in 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. -/// Was hier nicht steht, gibt es für die Views nicht; dadurch bleibt der -/// Austausch des Engine unsichtbar. +/// **Ein Protokoll für einen Spieler.** Es gab einmal zwei, und der Schnitt +/// ist geblieben: er hält die Oberfläche von AVFoundation fern, und was hier +/// nicht steht, gibt es für die Views nicht. @MainActor public protocol VideoPlayerEngine: AnyObject { var events: AsyncStream { 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 - /// Empfängerliste nicht — ein Knopf dafür führte dort ins Leere. + /// Ein Knopf dafür darf nur stehen, wo er auch etwas trifft. 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, - /// sonst behält besonders VLCKit den Speicher. + /// Gibt Puffer und Dekoder frei. Muss beim Verlassen des Players laufen. 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. diff --git a/Packages/FlixyKit/Sources/JellyfinKit/JellyfinBackend+Playback.swift b/Packages/FlixyKit/Sources/JellyfinKit/JellyfinBackend+Playback.swift index 21436cb..941eab1 100644 --- a/Packages/FlixyKit/Sources/JellyfinKit/JellyfinBackend+Playback.swift +++ b/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: [ diff --git a/Packages/FlixyKit/Tests/FlixyPlaybackTests/PlaybackDeciderTests.swift b/Packages/FlixyKit/Tests/FlixyPlaybackTests/PlaybackDeciderTests.swift index 8d893bb..eaf7580 100644 --- a/Packages/FlixyKit/Tests/FlixyPlaybackTests/PlaybackDeciderTests.swift +++ b/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") - func matroskaFallsBackToVLC() { + /// **Hier stand einmal VLC.** Eine zweite Engine nahm all das an, was + /// 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") - func unknownStreamsFallBackToVLC() { + @Test("Unanalysierte Dateien gehen an den Transcoder") + 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 - /// DTS-Ton deshalb beim vollen Neurechnen — Bild inbegriffen, obwohl mit - /// dem Bild nichts war. Jetzt bleibt es beim Umpacken, und nur der Ton - /// wird angefasst. - @Test("Ohne VLC reicht Umpacken, solange das Bild passt") - func withoutFallbackEngineRemuxIsEnough() { - let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false) + /// Früher landete eine Datei mit DTS-Ton beim vollen Neurechnen — Bild + /// inbegriffen, obwohl mit dem Bild nichts war. Jetzt bleibt es beim + /// Umpacken, und nur der Ton wird angefasst. + @Test("Umpacken reicht, solange das Bild passt") + func remuxIsEnough() { + let policy = PlaybackPolicy(allowsTranscoding: true) 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") - func withoutFallbackEngineTranscodingTakesOver() { - let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false) + @Test("Der Transcoder übernimmt, sobald das Bild nicht passt") + func transcodingTakesOver() { + 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. - let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false) + // automatischem Bitratenwechsel. + 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( - allowsTranscoding: true, allowsFallbackEngine: true, maximumBitrate: 8_000 - ) + policy: PlaybackPolicy(allowsTranscoding: 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") - func withoutServerHelpVLC() { + @Test("Ohne Serverhilfe bleibt nur der Versuch") + func withoutServerHelp() { let entscheidung = decider.decide( profile: MediaProfile( container: "mkv", videoCodec: "hevc", audioCodec: "ac3", bitrate: 20_000, hasKnownStreams: true ), - policy: PlaybackPolicy( - allowsTranscoding: false, allowsFallbackEngine: true - ) + policy: PlaybackPolicy(allowsTranscoding: false) ) - #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)) } } diff --git a/Packages/FlixyVLC/Package.swift b/Packages/FlixyVLC/Package.swift deleted file mode 100644 index ee0cda8..0000000 --- a/Packages/FlixyVLC/Package.swift +++ /dev/null @@ -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"), - ] - ), - ] -) diff --git a/Packages/FlixyVLC/Sources/FlixyVLC/VLCPlayerEngine.swift b/Packages/FlixyVLC/Sources/FlixyVLC/VLCPlayerEngine.swift deleted file mode 100644 index 5c62e37..0000000 --- a/Packages/FlixyVLC/Sources/FlixyVLC/VLCPlayerEngine.swift +++ /dev/null @@ -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 = { - AsyncStream { continuation in - self.continuation = continuation - } - }() - - private var continuation: AsyncStream.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 - } - } -} diff --git a/Tools/JellyfinStub/server.py b/Tools/JellyfinStub/server.py index 0c578b5..38259f6 100644 --- a/Tools/JellyfinStub/server.py +++ b/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 -# faellt die App auf VLCKit zurueck — und dieser Weg ist sonst mit der -# Beispieldatei gar nicht erreichbar. Die Datei selbst bleibt dieselbe; VLC -# spielt sie ebenso, und geprueft wird der Weg, nicht der Ton. -AS_VLC = "--vlc" in os.sys.argv -AUDIO_CODEC = "dts" if AS_VLC else "aac" +# Mit `--dts` melden die Quellen DTS-Ton. AVFoundation kann das nicht, also +# muss der Server umpacken — und dieser Weg ist sonst mit der Beispieldatei +# gar nicht erreichbar. Die Datei selbst bleibt dieselbe; geprueft wird die +# Entscheidung, nicht der Ton. +# +# 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."), diff --git a/project.yml b/project.yml index e01facc..f76aeab 100644 --- a/project.yml +++ b/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 - # und bringt eigene Netzwerkbibliotheken mit. Solange nur Dateien vom - # eigenen Server abgespielt werden, bleibt es bei Standardverfahren. - # Käme irgendwann etwas mit eigener Verschlüsselung dazu — DRM etwa —, + # Zu beachten, falls sich das ändert: solange nur Dateien vom eigenen + # Server abgespielt werden, bleibt es bei Standardverfahren. Käme + # irgendwann etwas mit eigener Verschlüsselung dazu — DRM etwa —, # gehört dieser Wert überprüft. ITSAppUsesNonExemptEncryption: false