Create Kaleido Desktop, a cinematic Plex client for Windows
Tauri 2 shell with a React/TypeScript interface and libmpv playback composed beneath the web view (DirectComposition on Windows). Shared code with per-OS platform modules and configs so macOS and Linux can follow. - Plex sign-in (browser, plex.tv/link or manual), server selection, Plex Home - Home, Movies and TV Shows (Discover, Library, Collections), search, people - Title pages with logos, ratings, cast, extras, seasons and episodes - Direct play with Plex conversion fallback, tracks, markers, autoplay - Metadata editing, artwork, fix match, refresh, analyze and deletion - Resumable offline downloads - App settings and Plex server administration with a live dashboard - Signed updater feed and Forgejo CI Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
commit
00d72e70f4
121 changed files with 25315 additions and 0 deletions
693
src/player/store.ts
Normal file
693
src/player/store.ts
Normal file
|
|
@ -0,0 +1,693 @@
|
|||
import { create } from 'zustand';
|
||||
import * as api from '../plex/api';
|
||||
import { directUrl, previewUrl, reportTimeline, stopTranscode, transcodeUrl, type Delivery } from '../plex/playback';
|
||||
import type { Item, Stream } from '../plex/types';
|
||||
import { useSession } from '../app/session';
|
||||
import { useSettings, type Quality } from '../app/settings';
|
||||
import { channelLabel } from '../app/format';
|
||||
import { invalidateLibrary } from '../app/queries';
|
||||
import { keepAwake, isNative, win } from '../platform/native';
|
||||
import { mpv, type MpvEvent, type MpvTrack } from './engine';
|
||||
import { toast } from '../ui/overlays';
|
||||
import { stopThemeMusic } from './theme';
|
||||
|
||||
export interface Track {
|
||||
key: string; // stable UI key
|
||||
mpvId: number | null; // null until loaded (external subs)
|
||||
stream?: Stream; // Plex stream, when known
|
||||
label: string;
|
||||
detail: string;
|
||||
language: string;
|
||||
forced: boolean;
|
||||
external: boolean;
|
||||
}
|
||||
|
||||
export interface PlayOptions {
|
||||
/** Start position in ms. Defaults to the saved resume point when `resume` is true. */
|
||||
offsetMs?: number;
|
||||
resume?: boolean;
|
||||
mediaIndex?: number;
|
||||
/** A local file path (offline download). */
|
||||
localFile?: string;
|
||||
quality?: Quality;
|
||||
}
|
||||
|
||||
interface PlayerState {
|
||||
open: boolean;
|
||||
item: Item | null;
|
||||
delivery: Delivery | null;
|
||||
mediaIndex: number;
|
||||
quality: Quality;
|
||||
firstFrame: boolean;
|
||||
error: string;
|
||||
position: number;
|
||||
duration: number;
|
||||
cacheTime: number;
|
||||
paused: boolean;
|
||||
buffering: boolean;
|
||||
seeking: boolean;
|
||||
volume: number;
|
||||
muted: boolean;
|
||||
speed: number;
|
||||
subDelay: number;
|
||||
audioTracks: Track[];
|
||||
subTracks: Track[];
|
||||
audioKey: string;
|
||||
subKey: string; // '' when off
|
||||
chapters: { title: string; time: number }[];
|
||||
video: { width: number; height: number; hwdec: string; codec: string } | null;
|
||||
ended: boolean;
|
||||
nextUp: Item | null;
|
||||
countdown: number | null;
|
||||
postPlayDismissed: boolean;
|
||||
fullscreen: boolean;
|
||||
|
||||
play(item: Item, opts?: PlayOptions): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
togglePause(): void;
|
||||
seek(seconds: number): void;
|
||||
seekBy(delta: number): void;
|
||||
setVolume(v: number): void;
|
||||
toggleMute(): void;
|
||||
setSpeed(s: number): void;
|
||||
setSubDelay(s: number): void;
|
||||
selectAudio(key: string): Promise<void>;
|
||||
selectSubtitle(key: string): Promise<void>;
|
||||
setQuality(q: Quality): Promise<void>;
|
||||
selectVersion(index: number): Promise<void>;
|
||||
playNext(): Promise<void>;
|
||||
cancelCountdown(): void;
|
||||
toggleFullscreen(): Promise<void>;
|
||||
previewAt(seconds: number): string;
|
||||
}
|
||||
|
||||
let session = '';
|
||||
let startOffsetMs = 0;
|
||||
let lastReport = 0;
|
||||
let reportTimer: ReturnType<typeof setInterval> | null = null;
|
||||
let countdownTimer: ReturnType<typeof setInterval> | null = null;
|
||||
let scrobbled = false;
|
||||
let unlisten: (() => void) | null = null;
|
||||
let loadToken = 0;
|
||||
let wasFullscreenBeforePlay = false;
|
||||
let pendingExternal: Track | null = null;
|
||||
|
||||
const server = () => useSession.getState().server;
|
||||
|
||||
function languageName(code: string, fallback: string) {
|
||||
if (!code) return fallback;
|
||||
try {
|
||||
return new Intl.DisplayNames([navigator.language || 'en'], { type: 'language' }).of(code) || fallback;
|
||||
} catch {
|
||||
return fallback;
|
||||
}
|
||||
}
|
||||
|
||||
function audioTrackFromStream(s: Stream): Track {
|
||||
const lang = s.language || languageName(s.languageCode, 'Unknown');
|
||||
const parts = [s.codec.toUpperCase().replace('DCA', 'DTS'), channelLabel(s.channels) || s.audioChannelLayout].filter(Boolean);
|
||||
const title = s.title && !s.title.toLowerCase().includes(lang.toLowerCase()) ? s.title : '';
|
||||
return {
|
||||
key: `p${s.id}`,
|
||||
mpvId: null,
|
||||
stream: s,
|
||||
label: lang,
|
||||
detail: title || parts.join(' '),
|
||||
language: s.languageCode,
|
||||
forced: false,
|
||||
external: false,
|
||||
};
|
||||
}
|
||||
|
||||
function subTrackFromStream(s: Stream): Track {
|
||||
const lang = s.language || languageName(s.languageCode, 'Unknown');
|
||||
const flags = [s.forced ? 'Forced' : '', s.hearingImpaired ? 'SDH' : ''].filter(Boolean);
|
||||
return {
|
||||
key: `p${s.id}`,
|
||||
mpvId: null,
|
||||
stream: s,
|
||||
label: [lang, ...flags].join(' · '),
|
||||
detail: [s.title && s.title !== lang ? s.title : '', s.codec.toUpperCase(), s.key ? 'External' : ''].filter(Boolean).join(' · '),
|
||||
language: s.languageCode,
|
||||
forced: s.forced,
|
||||
external: !!s.key,
|
||||
};
|
||||
}
|
||||
|
||||
function mpvTrackLabel(t: MpvTrack): Track {
|
||||
const lang = t.lang ? languageName(t.lang, t.lang) : t.type === 'sub' ? 'Subtitles' : 'Audio';
|
||||
return {
|
||||
key: `m${t.id}`,
|
||||
mpvId: t.id,
|
||||
label: t.title ? `${lang} · ${t.title}` : lang,
|
||||
detail: [t.codec?.toUpperCase(), t['demux-channel-count'] ? channelLabel(t['demux-channel-count']) : ''].filter(Boolean).join(' '),
|
||||
language: t.lang ?? '',
|
||||
forced: !!t.forced,
|
||||
external: !!t.external,
|
||||
};
|
||||
}
|
||||
|
||||
function report(state: 'playing' | 'paused' | 'buffering' | 'stopped') {
|
||||
const s = server();
|
||||
const { item, position, delivery } = usePlayer.getState();
|
||||
if (!s || !item || !session || item.type === 'clip') return;
|
||||
lastReport = Date.now();
|
||||
const extra: Record<string, string | number> = {};
|
||||
if (delivery?.mode === 'transcode' && delivery.session) extra['X-Plex-Session-Identifier'] = delivery.session;
|
||||
reportTimeline(s, item, state, position * 1000, session, extra).catch(() => {});
|
||||
}
|
||||
|
||||
function checkScrobble() {
|
||||
const { item, position, duration } = usePlayer.getState();
|
||||
const s = server();
|
||||
if (!item || !s || scrobbled || !duration || item.type === 'clip') return;
|
||||
const percent = useSettings.getState().watchedPercent;
|
||||
if (position / duration >= percent / 100) {
|
||||
scrobbled = true;
|
||||
api
|
||||
.setWatched(s, item.id, true)
|
||||
.then(() => invalidateLibrary())
|
||||
.catch(() => (scrobbled = false));
|
||||
}
|
||||
}
|
||||
|
||||
async function findNext(item: Item): Promise<Item | null> {
|
||||
const s = server();
|
||||
if (!s || item.type !== 'episode' || !item.grandparentId) return null;
|
||||
try {
|
||||
const leaves = await api.allLeaves(s, item.grandparentId);
|
||||
const i = leaves.findIndex((e) => e.id === item.id);
|
||||
return i >= 0 ? (leaves[i + 1] ?? null) : null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function startCountdown() {
|
||||
const st = usePlayer.getState();
|
||||
if (!st.nextUp || st.countdown !== null || st.postPlayDismissed) return;
|
||||
const settings = useSettings.getState();
|
||||
if (!settings.autoplayNext) {
|
||||
usePlayer.setState({ countdown: -1 });
|
||||
return;
|
||||
}
|
||||
usePlayer.setState({ countdown: settings.countdownSeconds });
|
||||
countdownTimer && clearInterval(countdownTimer);
|
||||
countdownTimer = setInterval(() => {
|
||||
const c = usePlayer.getState().countdown;
|
||||
if (c === null || c < 0) return;
|
||||
if (c <= 1) {
|
||||
clearInterval(countdownTimer!);
|
||||
countdownTimer = null;
|
||||
usePlayer.getState().playNext();
|
||||
} else usePlayer.setState({ countdown: c - 1 });
|
||||
}, 1000);
|
||||
}
|
||||
|
||||
function stopCountdown() {
|
||||
if (countdownTimer) clearInterval(countdownTimer);
|
||||
countdownTimer = null;
|
||||
}
|
||||
|
||||
/** Applies Plex/user track preferences once mpv has loaded the file. */
|
||||
async function applyInitialTracks(tracks: MpvTrack[]) {
|
||||
const st = usePlayer.getState();
|
||||
const prefs = useSettings.getState();
|
||||
const direct = st.delivery?.mode !== 'transcode';
|
||||
const byFF = (type: string, idx: number) => tracks.find((t) => t.type === type && t['ff-index'] === idx && !t.external);
|
||||
|
||||
let audio = st.audioTracks;
|
||||
let subs = st.subTracks;
|
||||
if (direct) {
|
||||
audio = audio.map((t) => ({ ...t, mpvId: t.stream ? (byFF('audio', t.stream.index)?.id ?? null) : t.mpvId }));
|
||||
subs = subs.map((t) => ({ ...t, mpvId: t.stream && !t.external ? (byFF('sub', t.stream.index)?.id ?? null) : t.mpvId }));
|
||||
// Files without Plex stream info (offline) use mpv's own list.
|
||||
if (!audio.length) audio = tracks.filter((t) => t.type === 'audio').map(mpvTrackLabel);
|
||||
if (!subs.length) subs = tracks.filter((t) => t.type === 'sub').map(mpvTrackLabel);
|
||||
}
|
||||
|
||||
// Audio: preferred language, else Plex's selection, else the file default.
|
||||
let audioKey = st.audioKey;
|
||||
if (!audioKey) {
|
||||
const lang = prefs.audioLanguage;
|
||||
audioKey =
|
||||
(lang && audio.find((t) => t.language === lang)?.key) ||
|
||||
audio.find((t) => t.stream?.selected)?.key ||
|
||||
audio.find((t) => t.stream?.default)?.key ||
|
||||
audio[0]?.key ||
|
||||
'';
|
||||
}
|
||||
// Subtitles: follow the subtitle mode.
|
||||
let subKey = st.subKey;
|
||||
if (subKey === '__init') {
|
||||
const lang = prefs.subtitleLanguage || audio.find((t) => t.key === audioKey)?.language || '';
|
||||
const inLang = subs.filter((t) => !lang || t.language === lang);
|
||||
switch (prefs.subtitleMode) {
|
||||
case 'off':
|
||||
subKey = '';
|
||||
break;
|
||||
case 'always':
|
||||
subKey = (inLang.find((t) => !t.forced) ?? inLang[0] ?? subs[0])?.key ?? '';
|
||||
break;
|
||||
case 'forced':
|
||||
subKey = inLang.find((t) => t.forced)?.key ?? '';
|
||||
break;
|
||||
default:
|
||||
subKey = subs.find((t) => t.stream?.selected)?.key ?? inLang.find((t) => t.forced)?.key ?? '';
|
||||
}
|
||||
}
|
||||
usePlayer.setState({ audioTracks: audio, subTracks: subs, audioKey, subKey });
|
||||
if (direct) {
|
||||
const a = audio.find((t) => t.key === audioKey);
|
||||
if (a?.mpvId) mpv.set('aid', a.mpvId).catch(() => {});
|
||||
await setMpvSubtitle(subKey);
|
||||
}
|
||||
}
|
||||
|
||||
async function setMpvSubtitle(key: string) {
|
||||
const st = usePlayer.getState();
|
||||
const t = st.subTracks.find((x) => x.key === key);
|
||||
if (!t) {
|
||||
await mpv.set('sid', 'no').catch(() => {});
|
||||
return;
|
||||
}
|
||||
if (t.mpvId) {
|
||||
await mpv.set('sid', t.mpvId).catch(() => {});
|
||||
} else if (t.external && t.stream?.key && server()) {
|
||||
pendingExternal = t;
|
||||
const url = server()!.signed(t.stream.key);
|
||||
await mpv.command('sub-add', url, 'select', t.label, t.language || 'und').catch(() => toast('This subtitle could not be loaded.', 'error'));
|
||||
}
|
||||
}
|
||||
|
||||
function onEvent(e: MpvEvent) {
|
||||
const st = usePlayer.getState();
|
||||
if (!st.open) return;
|
||||
switch (e.type) {
|
||||
case 'property': {
|
||||
const v = e.value;
|
||||
switch (e.name) {
|
||||
case 'time-pos':
|
||||
if (typeof v === 'number') {
|
||||
usePlayer.setState({ position: v });
|
||||
checkScrobble();
|
||||
if (Date.now() - lastReport > 10000) report(st.paused ? 'paused' : 'playing');
|
||||
maybeCredits(v);
|
||||
}
|
||||
break;
|
||||
case 'duration':
|
||||
if (typeof v === 'number' && v > 0) usePlayer.setState({ duration: v });
|
||||
break;
|
||||
case 'pause':
|
||||
usePlayer.setState({ paused: !!v });
|
||||
report(v ? 'paused' : 'playing');
|
||||
keepAwake(!v);
|
||||
break;
|
||||
case 'paused-for-cache':
|
||||
usePlayer.setState({ buffering: !!v });
|
||||
break;
|
||||
case 'seeking':
|
||||
usePlayer.setState({ seeking: !!v });
|
||||
break;
|
||||
case 'demuxer-cache-time':
|
||||
if (typeof v === 'number') usePlayer.setState({ cacheTime: v });
|
||||
break;
|
||||
case 'volume':
|
||||
if (typeof v === 'number') usePlayer.setState({ volume: v });
|
||||
break;
|
||||
case 'mute':
|
||||
usePlayer.setState({ muted: !!v });
|
||||
break;
|
||||
case 'speed':
|
||||
if (typeof v === 'number') usePlayer.setState({ speed: v });
|
||||
break;
|
||||
case 'sub-delay':
|
||||
if (typeof v === 'number') usePlayer.setState({ subDelay: v });
|
||||
break;
|
||||
case 'chapter-list':
|
||||
if (Array.isArray(v) && v.length > 1 && !st.chapters.length)
|
||||
usePlayer.setState({ chapters: v.map((c: any, i: number) => ({ title: c.title && !/^\d\d:\d\d/.test(c.title) ? c.title : `Chapter ${i + 1}`, time: c.time })) });
|
||||
break;
|
||||
case 'video-params':
|
||||
if (v?.w) usePlayer.setState({ video: { ...(st.video ?? { hwdec: '', codec: '' }), width: v.w, height: v.h } });
|
||||
break;
|
||||
case 'hwdec-current':
|
||||
usePlayer.setState({ video: { ...(st.video ?? { width: 0, height: 0, codec: '' }), hwdec: v ?? '' } });
|
||||
break;
|
||||
case 'track-list':
|
||||
if (Array.isArray(v)) {
|
||||
if (pendingExternal) {
|
||||
const ext = (v as MpvTrack[]).filter((t) => t.type === 'sub' && t.external).pop();
|
||||
if (ext) {
|
||||
const key = pendingExternal.key;
|
||||
pendingExternal = null;
|
||||
usePlayer.setState({ subTracks: usePlayer.getState().subTracks.map((t) => (t.key === key ? { ...t, mpvId: ext.id } : t)) });
|
||||
}
|
||||
}
|
||||
const video = (v as MpvTrack[]).find((t) => t.type === 'video' && t.selected);
|
||||
if (video) usePlayer.setState({ video: { ...(usePlayer.getState().video ?? { width: 0, height: 0, hwdec: '' }), codec: video.codec ?? '' } });
|
||||
}
|
||||
break;
|
||||
case 'eof-reached':
|
||||
if (v === true) onEnded();
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'file-loaded':
|
||||
mpv
|
||||
.get<MpvTrack[]>('track-list')
|
||||
.then(applyInitialTracks)
|
||||
.catch(() => {});
|
||||
break;
|
||||
case 'playback-restart':
|
||||
if (!st.firstFrame) usePlayer.setState({ firstFrame: true });
|
||||
usePlayer.setState({ buffering: false });
|
||||
break;
|
||||
case 'end-file':
|
||||
if (e.reason === 'error') {
|
||||
usePlayer.setState({ error: e.error ? `Playback failed: ${e.error}` : 'This video could not be played.' });
|
||||
fallbackAfterError();
|
||||
} else if (e.reason === 'eof') onEnded();
|
||||
break;
|
||||
case 'log':
|
||||
if (e.level === 'error' && /http|stream|open/i.test(e.prefix + e.text) && !st.firstFrame) console.warn('[mpv]', e.prefix, e.text);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/** Direct play failed: retry once through Plex's converter. */
|
||||
let triedFallback = false;
|
||||
function fallbackAfterError() {
|
||||
const st = usePlayer.getState();
|
||||
if (triedFallback || !st.item || st.delivery?.mode !== 'direct') return;
|
||||
triedFallback = true;
|
||||
toast('Direct playback failed. Asking Plex to convert this video.');
|
||||
usePlayer.setState({ error: '' });
|
||||
st.play(st.item, { offsetMs: st.position * 1000 || startOffsetMs, mediaIndex: st.mediaIndex, quality: '1080' });
|
||||
}
|
||||
|
||||
function maybeCredits(pos: number) {
|
||||
const st = usePlayer.getState();
|
||||
if (st.item?.type !== 'episode' || !st.nextUp || st.countdown !== null) return;
|
||||
const credits = st.item.markers.find((m) => m.type === 'credits' && (m.final || m.end >= st.item!.duration - 5000));
|
||||
if (credits && pos * 1000 >= credits.start && pos * 1000 < credits.end && useSettings.getState().skipCredits !== 'off') startCountdown();
|
||||
}
|
||||
|
||||
function onEnded() {
|
||||
const st = usePlayer.getState();
|
||||
if (st.ended) return;
|
||||
usePlayer.setState({ ended: true });
|
||||
report('stopped');
|
||||
checkScrobble();
|
||||
if (st.nextUp) startCountdown();
|
||||
}
|
||||
|
||||
export const usePlayer = create<PlayerState>((set, get) => ({
|
||||
open: false,
|
||||
item: null,
|
||||
delivery: null,
|
||||
mediaIndex: 0,
|
||||
quality: 'original',
|
||||
firstFrame: false,
|
||||
error: '',
|
||||
position: 0,
|
||||
duration: 0,
|
||||
cacheTime: 0,
|
||||
paused: false,
|
||||
buffering: false,
|
||||
seeking: false,
|
||||
volume: 100,
|
||||
muted: false,
|
||||
speed: 1,
|
||||
subDelay: 0,
|
||||
audioTracks: [],
|
||||
subTracks: [],
|
||||
audioKey: '',
|
||||
subKey: '',
|
||||
chapters: [],
|
||||
video: null,
|
||||
ended: false,
|
||||
nextUp: null,
|
||||
countdown: null,
|
||||
postPlayDismissed: false,
|
||||
fullscreen: false,
|
||||
|
||||
async play(input, opts = {}) {
|
||||
const token = ++loadToken;
|
||||
const s = server();
|
||||
const prefs = useSettings.getState();
|
||||
stopThemeMusic();
|
||||
stopCountdown();
|
||||
if (!isNative) {
|
||||
toast('Video playback is available in the Kaleido desktop app.', 'error');
|
||||
return;
|
||||
}
|
||||
const previous = get();
|
||||
if (previous.open && previous.item) {
|
||||
report('stopped');
|
||||
if (previous.delivery?.session && s) stopTranscode(s, previous.delivery.session);
|
||||
}
|
||||
if (!previous.open) {
|
||||
triedFallback = false;
|
||||
wasFullscreenBeforePlay = await win.isFullscreen().catch(() => false);
|
||||
}
|
||||
set({
|
||||
open: true,
|
||||
item: input,
|
||||
firstFrame: false,
|
||||
error: '',
|
||||
position: (opts.offsetMs ?? 0) / 1000,
|
||||
duration: input.duration / 1000,
|
||||
cacheTime: 0,
|
||||
paused: false,
|
||||
buffering: true,
|
||||
ended: false,
|
||||
nextUp: null,
|
||||
countdown: null,
|
||||
postPlayDismissed: false,
|
||||
chapters: [],
|
||||
audioTracks: [],
|
||||
subTracks: [],
|
||||
audioKey: '',
|
||||
subKey: '__init',
|
||||
video: null,
|
||||
fullscreen: wasFullscreenBeforePlay,
|
||||
});
|
||||
document.documentElement.classList.add('player-open');
|
||||
|
||||
try {
|
||||
// Full metadata: streams, markers and chapters.
|
||||
let item = input;
|
||||
if (!opts.localFile && s && (!input.media.length || !input.media[0].parts[0]?.streams.length || !input.raw?.Marker)) {
|
||||
item = await api.metadata(s, input.id).catch(() => input);
|
||||
}
|
||||
if (token !== loadToken) return;
|
||||
const mediaIndex = Math.min(opts.mediaIndex ?? 0, Math.max(0, item.media.length - 1));
|
||||
const media = item.media[mediaIndex];
|
||||
let offsetMs = opts.offsetMs ?? (opts.resume !== false && item.viewOffset && item.viewOffset < item.duration * 0.97 ? item.viewOffset : 0);
|
||||
startOffsetMs = offsetMs;
|
||||
const local = useSession.getState().connection?.local ?? true;
|
||||
const quality: Quality = opts.quality ?? (local ? prefs.quality : prefs.remoteQuality);
|
||||
session = crypto.randomUUID();
|
||||
scrobbled = false;
|
||||
|
||||
let delivery: Delivery;
|
||||
if (opts.localFile) {
|
||||
delivery = { url: opts.localFile, mode: 'local', label: 'Downloaded', absoluteTime: false };
|
||||
} else if (!s || !media) {
|
||||
throw new Error('This title has no playable media.');
|
||||
} else if (quality === 'original') {
|
||||
delivery = { url: directUrl(s, media), mode: 'direct', label: 'Original', absoluteTime: false };
|
||||
} else {
|
||||
const tsession = crypto.randomUUID();
|
||||
delivery = {
|
||||
url: transcodeUrl(s, item, { mediaIndex, quality, offsetMs, session: tsession, local }),
|
||||
mode: 'transcode',
|
||||
session: tsession,
|
||||
label: quality === '2160' ? '4K' : `${quality}p`,
|
||||
absoluteTime: true,
|
||||
};
|
||||
}
|
||||
|
||||
const streams = media?.parts.flatMap((p) => p.streams) ?? [];
|
||||
set({
|
||||
item,
|
||||
delivery,
|
||||
mediaIndex,
|
||||
quality,
|
||||
duration: (item.duration || media?.duration || 0) / 1000,
|
||||
audioTracks: streams.filter((x) => x.streamType === 2).map(audioTrackFromStream),
|
||||
subTracks: streams.filter((x) => x.streamType === 3).map(subTrackFromStream),
|
||||
});
|
||||
|
||||
await mpv.init({ hwdec: prefs.hwdec, hdr: prefs.hdrPassthrough });
|
||||
if (!unlisten) unlisten = await mpv.on(onEvent);
|
||||
if (token !== loadToken) return;
|
||||
await mpv.set('mute', false);
|
||||
await mpv.set('volume', prefs.volume);
|
||||
await mpv.set('speed', 1);
|
||||
await mpv.set('sub-scale', prefs.subtitleScale);
|
||||
await mpv.set('sub-back-color', prefs.subtitleBackground ? '#C0000000' : '#00000000');
|
||||
await mpv.set('sub-border-style', prefs.subtitleBackground ? 'opaque-box' : 'outline-and-shadow');
|
||||
await mpv.set('force-media-title', item.type === 'episode' ? `${item.grandparentTitle} — ${item.title}` : item.title);
|
||||
await mpv.show(true);
|
||||
const fileOpts = [
|
||||
delivery.mode === 'transcode' ? 'rebase-start-time=no' : 'rebase-start-time=yes',
|
||||
offsetMs > 0 && delivery.mode !== 'transcode' ? `start=${(offsetMs / 1000).toFixed(2)}` : 'start=none',
|
||||
].join(',');
|
||||
await mpv.command('loadfile', delivery.url, 'replace', -1, fileOpts);
|
||||
keepAwake(true);
|
||||
report('buffering');
|
||||
reportTimer && clearInterval(reportTimer);
|
||||
reportTimer = setInterval(() => {
|
||||
const st = get();
|
||||
if (st.open && !st.ended) report(st.paused ? 'paused' : st.buffering ? 'buffering' : 'playing');
|
||||
}, 10000);
|
||||
findNext(item).then((next) => token === loadToken && set({ nextUp: next }));
|
||||
} catch (e: any) {
|
||||
if (token !== loadToken) return;
|
||||
set({ error: e?.message ?? String(e), buffering: false });
|
||||
}
|
||||
},
|
||||
|
||||
async close() {
|
||||
loadToken++;
|
||||
const st = get();
|
||||
stopCountdown();
|
||||
if (reportTimer) clearInterval(reportTimer);
|
||||
reportTimer = null;
|
||||
if (st.item && !st.error) report('stopped');
|
||||
const s = server();
|
||||
if (st.delivery?.session && s) stopTranscode(s, st.delivery.session);
|
||||
keepAwake(false);
|
||||
if (isNative) {
|
||||
await mpv.command('stop').catch(() => {});
|
||||
await mpv.show(false).catch(() => {});
|
||||
}
|
||||
document.documentElement.classList.remove('player-open', 'video-active');
|
||||
set({ open: false, item: null, delivery: null, error: '', countdown: null, nextUp: null, firstFrame: false });
|
||||
const fs = await win.isFullscreen().catch(() => false);
|
||||
if (fs && !wasFullscreenBeforePlay) win.setFullscreen(false);
|
||||
if (st.item) invalidateLibrary();
|
||||
},
|
||||
|
||||
togglePause() {
|
||||
const st = get();
|
||||
if (st.ended) {
|
||||
st.seek(0);
|
||||
set({ ended: false });
|
||||
}
|
||||
mpv.command('cycle', 'pause').catch(() => {});
|
||||
},
|
||||
|
||||
seek(seconds) {
|
||||
const st = get();
|
||||
const target = Math.max(0, Math.min(seconds, (st.duration || seconds) - 0.5));
|
||||
set({ position: target, ended: false });
|
||||
if (st.countdown !== null) {
|
||||
stopCountdown();
|
||||
set({ countdown: null });
|
||||
}
|
||||
mpv.command('seek', target.toFixed(3), 'absolute+exact').catch(() => {});
|
||||
},
|
||||
|
||||
seekBy(delta) {
|
||||
const st = get();
|
||||
st.seek(st.position + delta);
|
||||
},
|
||||
|
||||
setVolume(v) {
|
||||
const volume = Math.max(0, Math.min(150, Math.round(v)));
|
||||
set({ volume });
|
||||
useSettings.getState().set('volume', Math.min(100, volume));
|
||||
mpv.set('volume', volume).catch(() => {});
|
||||
if (get().muted && volume > 0) mpv.set('mute', false).catch(() => {});
|
||||
},
|
||||
|
||||
toggleMute() {
|
||||
mpv.command('cycle', 'mute').catch(() => {});
|
||||
},
|
||||
|
||||
setSpeed(speed) {
|
||||
mpv.set('speed', speed).catch(() => {});
|
||||
},
|
||||
|
||||
setSubDelay(delay) {
|
||||
mpv.set('sub-delay', delay).catch(() => {});
|
||||
},
|
||||
|
||||
async selectAudio(key) {
|
||||
const st = get();
|
||||
const t = st.audioTracks.find((x) => x.key === key);
|
||||
if (!t) return;
|
||||
set({ audioKey: key });
|
||||
const s = server();
|
||||
const part = st.item?.media[st.mediaIndex]?.parts[0];
|
||||
if (s && part && t.stream) api.selectStreams(s, part.id, { audioStreamID: t.stream.id }).catch(() => {});
|
||||
if (st.delivery?.mode === 'transcode' && st.item) {
|
||||
await st.play(st.item, { offsetMs: st.position * 1000, mediaIndex: st.mediaIndex, quality: st.quality });
|
||||
return;
|
||||
}
|
||||
if (t.mpvId) await mpv.set('aid', t.mpvId).catch(() => {});
|
||||
},
|
||||
|
||||
async selectSubtitle(key) {
|
||||
const st = get();
|
||||
set({ subKey: key });
|
||||
const s = server();
|
||||
const part = st.item?.media[st.mediaIndex]?.parts[0];
|
||||
const t = st.subTracks.find((x) => x.key === key);
|
||||
if (s && part) api.selectStreams(s, part.id, { subtitleStreamID: t?.stream?.id ?? '0' }).catch(() => {});
|
||||
if (st.delivery?.mode === 'transcode' && st.item) {
|
||||
await st.play(st.item, { offsetMs: st.position * 1000, mediaIndex: st.mediaIndex, quality: st.quality });
|
||||
usePlayer.setState({ subKey: key });
|
||||
return;
|
||||
}
|
||||
await setMpvSubtitle(key);
|
||||
},
|
||||
|
||||
async setQuality(q) {
|
||||
const st = get();
|
||||
if (!st.item || q === st.quality) return;
|
||||
await st.play(st.item, { offsetMs: st.position * 1000, mediaIndex: st.mediaIndex, quality: q });
|
||||
},
|
||||
|
||||
async selectVersion(index) {
|
||||
const st = get();
|
||||
if (!st.item || index === st.mediaIndex) return;
|
||||
await st.play(st.item, { offsetMs: st.position * 1000, mediaIndex: index, quality: st.quality });
|
||||
},
|
||||
|
||||
async playNext() {
|
||||
const st = get();
|
||||
stopCountdown();
|
||||
if (!st.nextUp) return;
|
||||
await st.play(st.nextUp, { resume: true, quality: st.quality });
|
||||
},
|
||||
|
||||
cancelCountdown() {
|
||||
stopCountdown();
|
||||
set({ countdown: null, postPlayDismissed: true });
|
||||
},
|
||||
|
||||
async toggleFullscreen() {
|
||||
const fs = await win.isFullscreen().catch(() => false);
|
||||
await win.setFullscreen(!fs);
|
||||
set({ fullscreen: !fs });
|
||||
},
|
||||
|
||||
previewAt(seconds) {
|
||||
const st = get();
|
||||
const s = server();
|
||||
if (!s || !st.item || st.delivery?.mode === 'local') return '';
|
||||
return previewUrl(s, st.item.media[st.mediaIndex], seconds * 1000);
|
||||
},
|
||||
}));
|
||||
|
||||
/** Shown once the first frame is ready, the page turns transparent over the video. */
|
||||
usePlayer.subscribe((st, prev) => {
|
||||
if (st.firstFrame !== prev.firstFrame || st.open !== prev.open || st.error !== prev.error) {
|
||||
document.documentElement.classList.toggle('video-active', st.open && st.firstFrame && !st.error);
|
||||
}
|
||||
});
|
||||
Loading…
Add table
Add a link
Reference in a new issue