MediaKit: die Grundschicht, auf der Plex und Jellyfin dasselbe meinen
Erster Schritt zu Jellyfin, und er besteht vor allem aus Wegnehmen. `PlaybackDecider` nahm bisher Plex-Modelle entgegen und las daraus sechs Felder. Das band die Entscheidung an einen bestimmten Server, obwohl an der Frage „kann iOS das öffnen?" nichts serverspezifisch ist. Jetzt nimmt er ein `MediaProfile` — Container, Codecs, Bitrate, ob die Datei untersucht ist. Wie ernst die Kopplung war, zeigte der Player selbst: für die Offline-Wiedergabe baute er sich **erfundene** Plex-Werte zusammen — eine Media mit Kennung 0, ein Part mit dem Dateinamen als Schlüssel, zusammengesetzte Spurlisten —, nur damit die Signatur passte. Für eine Datei, die längst auf dem Gerät lag und mit Plex nichts mehr zu tun hatte. Dieser Hack ist weg. Neu ist das Target `MediaKit`: Typen und Rechnungen, die für jeden Server gelten, ohne eine einzige Abhängigkeit. Darin `MediaProfile` und die `Duration`-Brücke, die bisher in PlexKit stand — „weil es die unterste Schicht ist". Das stimmte, solange es nur einen Server gab. Damit kennen Wiedergabe und Downloads Plex nicht mehr. Zwei der Abhängigkeiten waren ohnehin tot; die dritte trug nur diese Brücke. Die wichtigste Testtabelle des Projekts ist mitgewandert und dabei kürzer geworden: dort steht jetzt, worauf es ankommt, statt vollständiger Modelle mit Kennungen und Dateipfaden, von denen niemand etwas las. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
co-authored by
Claude Opus 5
Claude Opus 5
parent
33dfac352a
commit
5b2b86b66b
@@ -11,6 +11,7 @@ let package = Package(
|
||||
// Die App selbst ist iOS-only; das legt project.yml fest.
|
||||
platforms: [.iOS(.v26), .macOS(.v26)],
|
||||
products: [
|
||||
.library(name: "MediaKit", targets: ["MediaKit"]),
|
||||
.library(name: "PlexKit", targets: ["PlexKit"]),
|
||||
.library(name: "FlixyDesign", targets: ["FlixyDesign"]),
|
||||
.library(name: "FlixyPlayback", targets: ["FlixyPlayback"]),
|
||||
@@ -19,7 +20,14 @@ let package = Package(
|
||||
targets: [
|
||||
// Sprechen mit dem Server: Anmeldung, Endpunkte, Modelle. Kein SwiftUI,
|
||||
// damit die gesamte Protokoll-Schicht ohne Oberfläche testbar bleibt.
|
||||
.target(name: "PlexKit"),
|
||||
// Die neutrale Grundschicht: Typen und Rechnungen, die für jeden
|
||||
// Server gelten. Hängt von nichts ab — genau das macht sie zur
|
||||
// Grundlage, auf der Plex, Jellyfin und später das Web-Projekt
|
||||
// dasselbe meinen.
|
||||
.target(name: "MediaKit"),
|
||||
.testTarget(name: "MediaKitTests", dependencies: ["MediaKit"]),
|
||||
|
||||
.target(name: "PlexKit", dependencies: ["MediaKit"]),
|
||||
|
||||
// Ein Werkzeug für die Fragen, die reines HTTP sind — ohne Oberfläche,
|
||||
// ohne Gerät, ohne Upload. Eine Runde dauert damit Sekunden statt
|
||||
@@ -44,12 +52,11 @@ let package = Package(
|
||||
// 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.
|
||||
.target(name: "FlixyPlayback", dependencies: ["PlexKit"]),
|
||||
.target(name: "FlixyPlayback", dependencies: ["MediaKit"]),
|
||||
.testTarget(name: "FlixyPlaybackTests", dependencies: ["FlixyPlayback"]),
|
||||
|
||||
// Warteschlange, Hintergrundübertragung, Offline-Bestand.
|
||||
.target(name: "FlixyDownloads", dependencies: ["PlexKit"],
|
||||
resources: [.process("Localizable.xcstrings")]),
|
||||
.target(name: "FlixyDownloads", dependencies: ["MediaKit"], resources: [.process("Localizable.xcstrings")]),
|
||||
.testTarget(name: "FlixyDownloadsTests", dependencies: ["FlixyDownloads"]),
|
||||
]
|
||||
)
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
import Observation
|
||||
import SwiftData
|
||||
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import Foundation
|
||||
import PlexKit
|
||||
import MediaKit
|
||||
|
||||
/// Die Regeln, nach denen Downloads von selbst entstehen und verschwinden.
|
||||
///
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import Foundation
|
||||
import PlexKit
|
||||
import MediaKit
|
||||
|
||||
/// Entscheidet, wie ein Titel abgespielt wird.
|
||||
///
|
||||
@@ -15,8 +15,7 @@ public struct PlaybackDecider: Sendable {
|
||||
}
|
||||
|
||||
public func decide(
|
||||
media: PlexMedia,
|
||||
part: PlexPart,
|
||||
profile: MediaProfile,
|
||||
policy: PlaybackPolicy
|
||||
) -> PlaybackDecision {
|
||||
var rationale: [PlaybackDecision.Rationale] = []
|
||||
@@ -36,7 +35,7 @@ public struct PlaybackDecider: Sendable {
|
||||
// 1. Reicht die Leitung? Das kommt zuerst, weil es unabhängig vom
|
||||
// Format ist: eine 80-Mbit-Datei über Mobilfunk ist auch dann keine
|
||||
// gute Idee, wenn AVPlayer sie problemlos öffnen könnte.
|
||||
if let limit = policy.maximumBitrate, let bitrate = media.bitrate, bitrate > limit {
|
||||
if let limit = policy.maximumBitrate, let bitrate = profile.bitrate, bitrate > limit {
|
||||
rationale.append(.bitrateExceedsLimit(mediaBitrate: bitrate, limit: limit))
|
||||
if policy.allowsTranscoding {
|
||||
return PlaybackDecision(method: .transcode(maximumBitrate: limit), rationale: rationale)
|
||||
@@ -48,8 +47,8 @@ public struct PlaybackDecider: Sendable {
|
||||
}
|
||||
|
||||
// 2. Kennt der Server die Datei überhaupt?
|
||||
let container = normalized(part.container ?? media.container)
|
||||
guard !part.streams.isEmpty, let videoCodec = normalized(media.videoCodec ?? part.videoStream?.codec) else {
|
||||
let container = normalized(profile.container)
|
||||
guard profile.hasKnownStreams, let videoCodec = normalized(profile.videoCodec) else {
|
||||
rationale.append(.streamsUnknown)
|
||||
return fallback(policy: policy, rationale: rationale)
|
||||
}
|
||||
@@ -62,10 +61,9 @@ public struct PlaybackDecider: Sendable {
|
||||
if !capabilities.videoCodecs.contains(videoCodec) {
|
||||
blockers.append(.videoCodecUnsupported(videoCodec))
|
||||
}
|
||||
// Geprüft wird die Spur, die tatsächlich klingen soll. Eine Datei mit
|
||||
// deutschem AAC und englischem DTS ist für AVPlayer in Ordnung,
|
||||
// solange Deutsch gewählt ist.
|
||||
if let audioCodec = normalized(part.selectedAudioStream?.codec ?? media.audioCodec),
|
||||
// Geprüft wird die Spur, die tatsächlich klingen soll — welche das
|
||||
// ist, hat der Aufrufer beim Bauen des Profils entschieden.
|
||||
if let audioCodec = normalized(profile.audioCodec),
|
||||
!capabilities.audioCodecs.contains(audioCodec) {
|
||||
blockers.append(.audioCodecUnsupported(audioCodec))
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import AVFoundation
|
||||
import Foundation
|
||||
import PlexKit
|
||||
import MediaKit
|
||||
|
||||
/// Wiedergabe über den Systemplayer.
|
||||
///
|
||||
|
||||
@@ -1,12 +1,11 @@
|
||||
import Foundation
|
||||
import PlexKit
|
||||
|
||||
/// Eine wählbare Ton- oder Untertitelspur.
|
||||
///
|
||||
/// Bewusst getrennt von `PlexStream`: VLCKit und AVPlayer nummerieren ihre
|
||||
/// Spuren selbst, und die Nummern stimmen nicht mit denen von Plex überein.
|
||||
/// `engineIdentifier` hält deshalb fest, wie der jeweilige Engine die Spur
|
||||
/// nennt, während `plexStreamID` für den Server gedacht ist.
|
||||
/// 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.
|
||||
public struct MediaTrack: Sendable, Equatable, Identifiable {
|
||||
public enum Kind: Sendable, Equatable { case audio, subtitle }
|
||||
|
||||
@@ -14,7 +13,7 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
|
||||
public let kind: Kind
|
||||
public let displayName: String
|
||||
public let languageCode: String?
|
||||
public let plexStreamID: Int?
|
||||
public let serverStreamID: Int?
|
||||
/// Die Nummer, unter der der laufende Engine die Spur führt.
|
||||
public let engineIdentifier: Int?
|
||||
public let isForced: Bool
|
||||
@@ -24,7 +23,7 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
|
||||
kind: Kind,
|
||||
displayName: String,
|
||||
languageCode: String? = nil,
|
||||
plexStreamID: Int? = nil,
|
||||
serverStreamID: Int? = nil,
|
||||
engineIdentifier: Int? = nil,
|
||||
isForced: Bool = false
|
||||
) {
|
||||
@@ -32,40 +31,9 @@ public struct MediaTrack: Sendable, Equatable, Identifiable {
|
||||
self.kind = kind
|
||||
self.displayName = displayName
|
||||
self.languageCode = languageCode
|
||||
self.plexStreamID = plexStreamID
|
||||
self.serverStreamID = serverStreamID
|
||||
self.engineIdentifier = engineIdentifier
|
||||
self.isForced = isForced
|
||||
}
|
||||
}
|
||||
|
||||
extension MediaTrack {
|
||||
/// Baut eine Spur aus dem, was Plex gemeldet hat.
|
||||
///
|
||||
/// `displayTitle` ist das, was Plex selbst in seinen Oberflächen zeigt
|
||||
/// (etwa „Deutsch (AC3 5.1)"). Fehlt es, wird aus Sprache und Codec etwas
|
||||
/// Brauchbares gebaut, statt „Spur 3" anzuzeigen.
|
||||
public init?(stream: PlexStream) {
|
||||
guard let kind = stream.kind else { return nil }
|
||||
let trackKind: Kind
|
||||
switch kind {
|
||||
case .audio: trackKind = .audio
|
||||
case .subtitle: trackKind = .subtitle
|
||||
case .video: return nil
|
||||
}
|
||||
|
||||
let name = stream.displayTitle
|
||||
?? stream.title
|
||||
?? [stream.language, stream.codec?.uppercased()]
|
||||
.compactMap(\.self)
|
||||
.joined(separator: " · ")
|
||||
|
||||
self.init(
|
||||
id: "plex-\(stream.id)",
|
||||
kind: trackKind,
|
||||
displayName: name.isEmpty ? "—" : name,
|
||||
languageCode: stream.languageCode,
|
||||
plexStreamID: stream.id,
|
||||
isForced: stream.isForced
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
import Foundation
|
||||
|
||||
extension Duration {
|
||||
/// Die Dauer als Gleitkommazahl in Sekunden.
|
||||
///
|
||||
/// Foundation und AVFoundation rechnen in `TimeInterval`; `Duration` ist
|
||||
/// der genauere Typ, den der übrige Code verwendet.
|
||||
///
|
||||
/// Diese Brücke stand bis eben in `PlexKit` — „weil es die unterste
|
||||
/// Schicht ist". Das stimmte, solange es nur einen Server gab. Sie hier
|
||||
/// zu haben ist der Grund, warum Downloads und Wiedergabe jetzt ohne
|
||||
/// jeden Serverbezug übersetzen.
|
||||
public var seconds: Double {
|
||||
Double(components.seconds) + Double(components.attoseconds) / 1e18
|
||||
}
|
||||
|
||||
/// Die Dauer in ganzen Millisekunden.
|
||||
///
|
||||
/// Die Einheit, in der sowohl Plex als auch Jellyfin Fortschritt melden —
|
||||
/// Jellyfin allerdings in Ticks zu 100 Nanosekunden, was der jeweilige
|
||||
/// Server-Adapter umrechnet.
|
||||
public var milliseconds: Int {
|
||||
Int(components.seconds * 1000 + components.attoseconds / 1_000_000_000_000_000)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
import Foundation
|
||||
|
||||
/// Was der `PlaybackDecider` über eine Datei wissen muss — und nicht mehr.
|
||||
///
|
||||
/// Vorher nahm er die Plex-Modelle entgegen und las daraus sechs Felder.
|
||||
/// Das band die Entscheidung an einen bestimmten Server, obwohl an ihr nichts
|
||||
/// serverspezifisch ist: ob iOS eine Datei öffnen kann, hängt an Container und
|
||||
/// Codecs, nicht daran, wer sie ausliefert.
|
||||
///
|
||||
/// Wie ernst die Kopplung war, zeigt der Player selbst: für die
|
||||
/// Offline-Wiedergabe baute er sich **erfundene** Plex-Werte zusammen, nur um
|
||||
/// diese Signatur zu bedienen — für eine Datei, die längst auf dem Gerät lag
|
||||
/// und mit Plex nichts mehr zu tun hatte.
|
||||
public struct MediaProfile: Sendable, Equatable {
|
||||
/// Der Behälter, etwa `mkv` oder `mp4`.
|
||||
public let container: String?
|
||||
public let videoCodec: String?
|
||||
/// Der Codec der Tonspur, die tatsächlich klingen soll.
|
||||
///
|
||||
/// Nicht irgendeiner: eine Datei mit deutschem AAC und englischem DTS ist
|
||||
/// für AVPlayer in Ordnung, solange Deutsch gewählt ist.
|
||||
public let audioCodec: String?
|
||||
/// Gesamtbitrate in Kilobit je Sekunde.
|
||||
public let bitrate: Int?
|
||||
/// Ob der Server die Datei überhaupt schon untersucht hat.
|
||||
///
|
||||
/// Ohne bekannte Spuren lässt sich nichts entscheiden — dann ist der
|
||||
/// Ersatzplayer die sichere Wahl.
|
||||
public let hasKnownStreams: Bool
|
||||
|
||||
public init(
|
||||
container: String? = nil,
|
||||
videoCodec: String? = nil,
|
||||
audioCodec: String? = nil,
|
||||
bitrate: Int? = nil,
|
||||
hasKnownStreams: Bool = true
|
||||
) {
|
||||
self.container = container
|
||||
self.videoCodec = videoCodec
|
||||
self.audioCodec = audioCodec
|
||||
self.bitrate = bitrate
|
||||
self.hasKnownStreams = hasKnownStreams
|
||||
}
|
||||
}
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
/// Führt die Anmeldung bei plex.tv durch.
|
||||
public actor PlexAuthenticator {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
/// Der schmale Spalt, durch den PlexKit ans Netz kommt.
|
||||
///
|
||||
@@ -89,14 +90,3 @@ public struct PlexRequest: Sendable, Equatable {
|
||||
return request
|
||||
}
|
||||
}
|
||||
|
||||
extension Duration {
|
||||
/// Die Dauer als Gleitkommazahl in Sekunden.
|
||||
///
|
||||
/// Foundation und AVFoundation rechnen in `TimeInterval`; `Duration` ist
|
||||
/// der genauere Typ, den der übrige Code verwendet. Diese Brücke steht in
|
||||
/// PlexKit, weil es die unterste Schicht ist — die darüber erben sie.
|
||||
public var seconds: Double {
|
||||
Double(components.seconds) + Double(components.attoseconds) / 1e18
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
/// Sucht den besten erreichbaren Weg zu einem Server.
|
||||
///
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
/// Was beim Live-TV herauskommen kann.
|
||||
public enum LiveTVAvailability: Sendable, Equatable {
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
extension PlexServer {
|
||||
// MARK: - Transcoding
|
||||
@@ -235,13 +236,6 @@ public enum PlaybackReportState: String, Sendable {
|
||||
case buffering
|
||||
}
|
||||
|
||||
extension Duration {
|
||||
/// Die Dauer in ganzen Millisekunden — die Einheit, in der Plex rechnet.
|
||||
public var milliseconds: Int {
|
||||
Int(components.seconds * 1000 + components.attoseconds / 1_000_000_000_000_000)
|
||||
}
|
||||
}
|
||||
|
||||
extension PlexServer {
|
||||
/// Die nächste Folge nach der angegebenen.
|
||||
///
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
/// Ein Fernsehempfänger am Server.
|
||||
///
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
import Foundation
|
||||
import MediaKit
|
||||
|
||||
extension PlexMedia {
|
||||
/// Was die Wiedergabe-Entscheidung über diese Fassung wissen muss.
|
||||
///
|
||||
/// Die eine Stelle, an der Plex-Modelle in die neutrale Form übersetzt
|
||||
/// werden. Vorher stand diese Auswahl im Entscheider selbst — und band
|
||||
/// ihn damit an einen bestimmten Server, obwohl an der Frage „kann iOS
|
||||
/// das öffnen?" nichts serverspezifisch ist.
|
||||
public func profile(part: PlexPart) -> MediaProfile {
|
||||
MediaProfile(
|
||||
container: part.container ?? container,
|
||||
videoCodec: videoCodec ?? part.videoStream?.codec,
|
||||
// Die **gewählte** Tonspur, nicht irgendeine: eine Datei mit
|
||||
// deutschem AAC und englischem DTS ist für AVPlayer in Ordnung,
|
||||
// solange Deutsch klingt.
|
||||
audioCodec: part.selectedAudioStream?.codec ?? audioCodec,
|
||||
bitrate: bitrate,
|
||||
hasKnownStreams: !part.streams.isEmpty
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
import Testing
|
||||
import PlexKit
|
||||
import MediaKit
|
||||
@testable import FlixyPlayback
|
||||
|
||||
/// Die Tabelle, die festhält, welche Datei auf welchem Weg landet.
|
||||
@@ -9,27 +9,24 @@ import PlexKit
|
||||
@Suite("Wiedergabe-Entscheidung")
|
||||
struct PlaybackDeciderTests {
|
||||
|
||||
/// Baut eine Datei mit den angegebenen Eigenschaften.
|
||||
private func media(
|
||||
/// Beschreibt eine Datei mit den angegebenen Eigenschaften.
|
||||
///
|
||||
/// Seit die Entscheidung `MediaProfile` entgegennimmt, steht hier genau
|
||||
/// das, worauf es ankommt. Vorher mussten vollständige Plex-Modelle
|
||||
/// gebaut werden — mit Kennungen, Dateipfaden und Spurlisten, von denen
|
||||
/// die Entscheidung nichts las.
|
||||
private func profile(
|
||||
container: String,
|
||||
video: String,
|
||||
audio: String,
|
||||
bitrate: Int? = nil
|
||||
) -> (PlexMedia, PlexPart) {
|
||||
let streams = [
|
||||
PlexStream(id: 1, streamType: 1, codec: video),
|
||||
PlexStream(id: 2, streamType: 2, codec: audio, selected: true),
|
||||
]
|
||||
let part = PlexPart(id: 10, key: "/library/parts/10/1/file", container: container, streams: streams)
|
||||
let media = PlexMedia(
|
||||
id: 100,
|
||||
) -> MediaProfile {
|
||||
MediaProfile(
|
||||
container: container,
|
||||
videoCodec: video,
|
||||
audioCodec: audio,
|
||||
bitrate: bitrate,
|
||||
parts: [part]
|
||||
bitrate: bitrate
|
||||
)
|
||||
return (media, part)
|
||||
}
|
||||
|
||||
// MARK: - Was AVPlayer nativ kann
|
||||
@@ -47,8 +44,10 @@ struct PlaybackDeciderTests {
|
||||
]
|
||||
)
|
||||
func nativeFormatsUseAVPlayer(container: String, video: String, audio: String) {
|
||||
let (media, part) = media(container: container, video: video, audio: audio)
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: container, video: video, audio: audio),
|
||||
policy: .directPlayOnly
|
||||
)
|
||||
|
||||
#expect(decision.method == .directPlay(engine: .avPlayer))
|
||||
#expect(decision.rationale.contains(.nativelySupported))
|
||||
@@ -58,8 +57,10 @@ struct PlaybackDeciderTests {
|
||||
|
||||
@Test("Matroska geht an VLC, auch bei nativen Codecs")
|
||||
func matroskaFallsBackToVLC() {
|
||||
let (media, part) = media(container: "mkv", video: "h264", audio: "aac")
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mkv", video: "h264", audio: "aac"),
|
||||
policy: .directPlayOnly
|
||||
)
|
||||
|
||||
#expect(decision.method == .directPlay(engine: .vlc))
|
||||
#expect(decision.rationale.contains(.containerUnsupported("mkv")))
|
||||
@@ -70,8 +71,10 @@ struct PlaybackDeciderTests {
|
||||
arguments: ["dts", "dca", "truehd", "vorbis", "opus"]
|
||||
)
|
||||
func unsupportedAudioFallsBackToVLC(codec: String) {
|
||||
let (media, part) = media(container: "mp4", video: "h264", audio: codec)
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mp4", video: "h264", audio: codec),
|
||||
policy: .directPlayOnly
|
||||
)
|
||||
|
||||
#expect(decision.method == .directPlay(engine: .vlc))
|
||||
#expect(decision.rationale.contains(.audioCodecUnsupported(codec)))
|
||||
@@ -82,8 +85,10 @@ struct PlaybackDeciderTests {
|
||||
arguments: ["av1", "vp9", "mpeg2video", "vc1", "wmv3"]
|
||||
)
|
||||
func unsupportedVideoFallsBackToVLC(codec: String) {
|
||||
let (media, part) = media(container: "mp4", video: codec, audio: "aac")
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mp4", video: codec, audio: "aac"),
|
||||
policy: .directPlayOnly
|
||||
)
|
||||
|
||||
#expect(decision.method == .directPlay(engine: .vlc))
|
||||
#expect(decision.rationale.contains(.videoCodecUnsupported(codec)))
|
||||
@@ -94,24 +99,24 @@ struct PlaybackDeciderTests {
|
||||
// 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.
|
||||
let streams = [
|
||||
PlexStream(id: 1, streamType: 1, codec: "h264"),
|
||||
PlexStream(id: 2, streamType: 2, codec: "dts", language: "English"),
|
||||
PlexStream(id: 3, streamType: 2, codec: "aac", language: "Deutsch", selected: true),
|
||||
]
|
||||
let part = PlexPart(id: 10, key: "/p", container: "mp4", streams: streams)
|
||||
let media = PlexMedia(id: 100, container: "mp4", videoCodec: "h264", audioCodec: "dts", parts: [part])
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
|
||||
// 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.
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mp4", video: "h264", audio: "aac"),
|
||||
policy: .directPlayOnly
|
||||
)
|
||||
#expect(decision.method == .directPlay(engine: .avPlayer))
|
||||
}
|
||||
|
||||
@Test("Unanalysierte Dateien gehen an den toleranteren Engine")
|
||||
func unknownStreamsFallBackToVLC() {
|
||||
let part = PlexPart(id: 10, key: "/p", container: "mp4", streams: [])
|
||||
let media = PlexMedia(id: 100, container: "mp4", parts: [part])
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: .directPlayOnly)
|
||||
// Der Server hat die Datei noch nicht untersucht: keine Spuren, kein
|
||||
// bekannter Codec. Dann ist Raten die falsche Antwort.
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: MediaProfile(container: "mp4", hasKnownStreams: false),
|
||||
policy: .directPlayOnly
|
||||
)
|
||||
#expect(decision.method == .directPlay(engine: .vlc))
|
||||
#expect(decision.rationale.contains(.streamsUnknown))
|
||||
}
|
||||
@@ -120,10 +125,12 @@ struct PlaybackDeciderTests {
|
||||
|
||||
@Test("Über der Grenze wird umgerechnet, sobald das erlaubt ist")
|
||||
func exceedingBitrateTranscodesWhenAllowed() {
|
||||
let (media, part) = media(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000)
|
||||
let policy = PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 8_000)
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000),
|
||||
policy: policy
|
||||
)
|
||||
|
||||
#expect(decision.method == .transcode(maximumBitrate: 8_000))
|
||||
#expect(decision.rationale.contains(.bitrateExceedsLimit(mediaBitrate: 80_000, limit: 8_000)))
|
||||
@@ -133,10 +140,12 @@ struct PlaybackDeciderTests {
|
||||
func exceedingBitrateStillPlaysInPhaseOne() {
|
||||
// Das ist die Lage in Phase 1. Abbrechen wäre falsch: im WLAN läuft
|
||||
// auch ein 80-Mbit-Remux, die Grenze ist nur eine Vorsichtsmaßnahme.
|
||||
let (media, part) = media(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000)
|
||||
let policy = PlaybackPolicy(allowsTranscoding: false, maximumBitrate: 8_000)
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 80_000),
|
||||
policy: policy
|
||||
)
|
||||
|
||||
#expect(decision.isDirectPlay)
|
||||
#expect(decision.rationale.contains(.transcodingUnavailable))
|
||||
@@ -144,19 +153,23 @@ struct PlaybackDeciderTests {
|
||||
|
||||
@Test("Unter der Grenze bleibt alles beim Direktabspielen")
|
||||
func withinBitrateLimitPlaysDirectly() {
|
||||
let (media, part) = media(container: "mp4", video: "h264", audio: "aac", bitrate: 4_000)
|
||||
let policy = PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 8_000)
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 4_000),
|
||||
policy: policy
|
||||
)
|
||||
#expect(decision.method == .directPlay(engine: .avPlayer))
|
||||
}
|
||||
|
||||
@Test("Ohne VLC übernimmt der Transcoder")
|
||||
func withoutFallbackEngineTranscodingTakesOver() {
|
||||
let (media, part) = media(container: "mkv", video: "h264", audio: "dts")
|
||||
let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mkv", video: "h264", audio: "dts"),
|
||||
policy: policy
|
||||
)
|
||||
#expect(decision.method == .transcode(maximumBitrate: nil))
|
||||
}
|
||||
|
||||
@@ -164,10 +177,12 @@ struct PlaybackDeciderTests {
|
||||
func transcodingUsesAVPlayer() {
|
||||
// HLS ist genau die Kost, für die AVPlayer gebaut ist — inklusive
|
||||
// automatischem Bitratenwechsel. Deshalb darf VLC hier nicht greifen.
|
||||
let (media, part) = media(container: "mkv", video: "h264", audio: "dts")
|
||||
let policy = PlaybackPolicy(allowsTranscoding: true, allowsFallbackEngine: false)
|
||||
|
||||
let decision = PlaybackDecider().decide(media: media, part: part, policy: policy)
|
||||
let decision = PlaybackDecider().decide(
|
||||
profile: profile(container: "mkv", video: "h264", audio: "dts"),
|
||||
policy: policy
|
||||
)
|
||||
#expect(decision.engine == .avPlayer)
|
||||
}
|
||||
|
||||
@@ -176,22 +191,8 @@ struct PlaybackDeciderTests {
|
||||
// Ohne das verpuffte die Wahl im Player: wer für eine 8-Mbit-Datei
|
||||
// „12 Mbit" wählt, bekam DirectPlay, weil die Datei ja unter der
|
||||
// Grenze liegt. Gemeint ist aber „rechne es mir auf diese Stufe um".
|
||||
let media = PlexMedia(
|
||||
id: 1,
|
||||
container: "mp4",
|
||||
videoCodec: "h264",
|
||||
audioCodec: "aac",
|
||||
bitrate: 8_000,
|
||||
parts: []
|
||||
)
|
||||
let part = PlexPart(id: 1, key: "/library/parts/1", container: "mp4", streams: [
|
||||
PlexStream(id: 1, streamType: 1, codec: "h264"),
|
||||
PlexStream(id: 2, streamType: 2, codec: "aac", selected: true),
|
||||
])
|
||||
|
||||
let decision = PlaybackDecider().decide(
|
||||
media: media,
|
||||
part: part,
|
||||
profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 8_000),
|
||||
policy: PlaybackPolicy(
|
||||
allowsTranscoding: true,
|
||||
allowsFallbackEngine: false,
|
||||
@@ -206,22 +207,8 @@ struct PlaybackDeciderTests {
|
||||
|
||||
@Test("Ohne ausdrückliche Wahl bleibt es bei DirectPlay")
|
||||
func leavesAutomaticAlone() {
|
||||
let media = PlexMedia(
|
||||
id: 1,
|
||||
container: "mp4",
|
||||
videoCodec: "h264",
|
||||
audioCodec: "aac",
|
||||
bitrate: 8_000,
|
||||
parts: []
|
||||
)
|
||||
let part = PlexPart(id: 1, key: "/library/parts/1", container: "mp4", streams: [
|
||||
PlexStream(id: 1, streamType: 1, codec: "h264"),
|
||||
PlexStream(id: 2, streamType: 2, codec: "aac", selected: true),
|
||||
])
|
||||
|
||||
let decision = PlaybackDecider().decide(
|
||||
media: media,
|
||||
part: part,
|
||||
profile: profile(container: "mp4", video: "h264", audio: "aac", bitrate: 8_000),
|
||||
policy: PlaybackPolicy(allowsTranscoding: true, maximumBitrate: 12_000)
|
||||
)
|
||||
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
import Foundation
|
||||
import Testing
|
||||
@testable import MediaKit
|
||||
|
||||
/// Die Umrechnung von `Duration` in die Einheiten der Server.
|
||||
@Suite("Dauer in Zahlen")
|
||||
struct DurationUnitsTests {
|
||||
|
||||
@Test("Sekunden als Kommazahl")
|
||||
func convertsToSeconds() {
|
||||
#expect(Duration.seconds(90).seconds == 90.0)
|
||||
#expect(Duration.milliseconds(1_500).seconds == 1.5)
|
||||
}
|
||||
|
||||
@Test("Millisekunden ganzzahlig")
|
||||
func convertsToMilliseconds() {
|
||||
#expect(Duration.seconds(2).milliseconds == 2_000)
|
||||
#expect(Duration.milliseconds(1_234).milliseconds == 1_234)
|
||||
}
|
||||
|
||||
@Test("Bruchteile gehen nicht verloren")
|
||||
func keepsFractions() {
|
||||
// Der Fortschritt wird in Millisekunden gemeldet; würde hier
|
||||
// abgeschnitten, verlöre man bei jedem Bericht bis zu einer Sekunde.
|
||||
#expect(Duration.milliseconds(1).milliseconds == 1)
|
||||
#expect(Duration.milliseconds(1).seconds == 0.001)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user