Scarriffle/Flaro
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

VLC ist weg — es gibt nur noch einen Spieler

Browse Source 
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>
This commit is contained in:
Scarriffle
2026-10-03 08:04:23 +02:00
co-authored by Claude Opus 5
parent ef2596e2bb
commit 6b927c21b0
26 changed files with 147 additions and 744 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Packages/FlixyKit/Package.swift
+1 -3
View File
@@ -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"]),
Packages/FlixyKit/Sources/FlixyPlayback/Decision/DeviceCapabilities.swift
+5 -5
View File
@@ -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<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
+10 -12
View File
@@ -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
Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackDecision.swift
+4 -27
View File
@@ -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
Packages/FlixyKit/Sources/FlixyPlayback/Decision/PlaybackPolicy.swift
-4
View File
@@ -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
+1 -5
View File
@@ -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
+2 -2
View File
@@ -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 {
Packages/FlixyKit/Sources/FlixyPlayback/Engine/MediaTrack.swift
+4 -4
View File
@@ -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 }
Packages/FlixyKit/Sources/FlixyPlayback/Engine/VideoPlayerEngine.swift
+9 -27
View File
@@ -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<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
/// 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.
Packages/FlixyKit/Sources/JellyfinKit/JellyfinBackend+Playback.swift
+1 -1
View File
@@ -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
+54 -58
View File
@@ -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))
}
}
Packages/FlixyVLC/Package.swift
-31
View File
@@ -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
-375
View File
@@ -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
}
}
}