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
Flixy.xcworkspace/xcshareddata/swiftpm/Package.resolved
-15
View File
@@ -1,15 +0,0 @@
{
"originHash" : "8b778ccd4dce9d26be9db57d4587b19c4a4366fcdaf8b6017e1df36fa1eddb4f",
"pins" : [
{
"identity" : "vlckit",
"kind" : "remoteSourceControl",
"location" : "https://github.com/videolan/vlckit.git",
"state" : {
"revision" : "6cbc4e7b248aa51ec0906697abb30ecae47194b7",
"version" : "4.0.0-a24"
}
}
],
"version" : 3
}
Flixy/Resources/Localizable.xcstrings
-17
View File
@@ -7326,23 +7326,6 @@
}
}
},
"technical.directPlayVLC": {
"extractionState": "stale",
"localizations": {
"de": {
"stringUnit": {
"state": "translated",
"value": "Direkt (VLC)"
}
},
"en": {
"stringUnit": {
"state": "translated",
"value": "Direct (VLC)"
}
}
}
},
"technical.file": {
"localizations": {
"de": {
Flixy/Session/NowPlaying.swift
+1 -1
View File
@@ -133,7 +133,7 @@ final class NowPlaying {
///
/// Die Handlung läuft über einen Sprung auf den Hauptakteur statt über
/// `assumeIsolated`: dass diese Rückrufe dort ankommen, ist nirgends
/// zugesagt, und dieselbe Annahme hat die App im VLC-Engine schon einmal
/// zugesagt, und dieselbe Annahme hat die App schon einmal
/// zum Absturz gebracht. Der Umweg kostet einen Durchlauf — unbemerkbar
/// neben dem Tastendruck, der ihn ausgelöst hat.
private func add(
Flixy/Session/PlaybackDiagnostics.swift
+4 -7
View File
@@ -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"
Flixy/Session/PlaybackSettings.swift
-31
View File
@@ -1,12 +1,4 @@
import Foundation
// **`!os(tvOS)` und nicht nur `canImport`.** Der Fernseher verlinkt FlixyVLC
// nicht, aber der Abhängigkeits-Sucher von Clang prüft den Import trotzdem —
// und bricht dann an VLCKit ab, das für dieses Ziel gar nicht gebaut wird.
// „Unable to resolve module dependency: VLCKit" nennt dabei weder diese Datei
// noch VLC als Grund.
#if canImport(FlixyVLC) && !os(tvOS)
import FlixyVLC
#endif
import Observation
import FlixyPlayback
@@ -60,25 +52,6 @@ final class PlaybackSettings {
/// Die Geschwindigkeiten, mit denen eine Wiedergabe beginnen kann.
static let rateChoices: [Double] = [0.75, 1.0, 1.25, 1.5, 1.75, 2.0]
/// Ob ein zweiter Spieler zur Verfügung steht.
///
/// VLC steckt in einem eigenen Paket, das nur für iOS gebaut wird — sein
/// Binärpaket hat keinen Teil für Mac Catalyst. Wo es fehlt, übernimmt der
/// Server: MKV und DTS werden dann umgerechnet statt unverändert
/// übertragen. Das kostet ihn Rechenzeit und sieht man nicht, aber es
/// spielt.
///
/// Auf dem Fernseher ebenfalls nicht: 920 MB Binärpaket für einen
/// Rückfallweg, der auf einem Apple TV selten greift, sind die Bauzeit
/// nicht wert.
static var hasFallbackEngine: Bool {
#if canImport(FlixyVLC) && !os(tvOS)
true
#else
false
#endif
}
private let defaults: UserDefaults
var wifiQuality: Quality { didSet { defaults.set(wifiQuality.rawValue, forKey: Key.wifiQuality) } }
@@ -165,10 +138,6 @@ final class PlaybackSettings {
return PlaybackPolicy(
allowsTranscoding: true,
// Nur, wenn es ihn auf dieser Plattform gibt. Ohne VLC wählte die
// Entscheidung sonst einen Spieler, den es nicht gibt — und die
// Wiedergabe bliebe schwarz, statt dass der Server umrechnet.
allowsFallbackEngine: Self.hasFallbackEngine,
maximumBitrate: quality.bitrateLimit
)
}
Flixy/Session/PlexWebAuthenticator.swift
+1 -1
View File
@@ -90,7 +90,7 @@ final class PlexWebAuthenticator: NSObject {
callbackURLScheme: callbackScheme
) { [weak self] _, error in
// ASWebAuthenticationSession ruft den Abschlussblock auf dem
// Hauptthread auf — anders als VLCKit, wo dieselbe Annahme die App
// Hauptthread auf — anders als mancher Rückruf, wo dieselbe Annahme die App
// zum Absturz gebracht hat. Hier ist sie dokumentiert.
MainActor.assumeIsolated {
guard let self else { return }
Flixy/Session/TopShelfWriter.swift
+1 -1
View File
@@ -5,7 +5,7 @@
// einen Import genügte dabei nicht: der Abhängigkeits-Sucher von Clang prüft
// ihn trotzdem und bricht mit „Unable to resolve module dependency:
// TVServices" ab, ohne den Fernseher zu erwähnen. Dieselbe Falle wie bei
// VLCKit, siehe `PlaybackSettings`.
// siehe `PlaybackSettings`.
#if os(tvOS)
import Foundation
import MediaKit
Flixy/Views/Detail/TechnicalDetails.swift
+2 -5
View File
@@ -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:
Flixy/Views/Player/PlayerModel.swift
+32 -69
View File
@@ -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
Flixy/Views/Player/PlayerView.swift
+2 -4
View File
@@ -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()
Flixy/Views/Player/VideoSurface.swift
+1 -23
View File
@@ -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
}
}
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
}
}
}
Tools/JellyfinStub/server.py
+9 -6
View File
@@ -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."),
project.yml
+3 -10
View File
@@ -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