Kaleido-Desktop/src/player/store.ts
Elijah 9fd2b0603e Add a Quality upscaling tier and make enhancement verifiable
Quality runs ArtCNN C4F32 (its denoising model when Denoising is on),
KrigBilateral, debanding and CAS. Its network runs at any enlargement,
so 1080p in a maximized 1440p window is doubled and scaled down; Balanced
keeps FSRCNNX's 1.3x threshold.

The enhancement pipeline moves to player/enhance.ts. Mode changes are
serialized (latest wins). Shader errors in mpv's log, or network passes
missing from vo-passes, drop to the tier below with a notice, and the
chosen and running tiers are shown separately. HDR is judged from the
decoded video. Debanding, sharpening and denoising have their own
toggles, B compares with enhancement off, and the panel shows the
renderer's actual stages, GPU time and dropped frames.

Compiled shaders persist in the app cache (gpu-shader-cache-dir):
ArtCNN's first Direct3D compile takes about a minute, which the player
now announces, and later launches start immediately.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 19:37:32 -07:00

804 lines
28 KiB
TypeScript

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, SUBTITLE_MARGIN, type Preferences, type Quality, type Upscaling } from '../app/settings';
import { noteMpvLog, requestEnhancement, watchPerformance } from './enhance';
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;
/** Playing in the corner while browsing. */
mini: boolean;
audioDelay: number;
/** The upscaling tier actually running (may be below the chosen one), and the before/after bypass. */
enhance: { active: Upscaling; bypass: boolean; preparing: boolean };
/** Transfer function of the decoded video ('pq', 'hlg', 'bt.1886'…), once known. */
videoGamma: string;
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;
setAudioDelay(s: number): void;
minimize(): Promise<void>;
expand(): 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;
/**
* mpv applies its volume on a cubic curve, so halfway on a linear slider was
* only an eighth of the amplitude. The slider follows a square law instead
* (halfway is about -12 dB, close to how loud it sounds).
*/
export const sliderToMpv = (v: number) => 100 * Math.pow(Math.max(0, v) / 100, 2 / 3);
const mpvToSlider = (v: number) => 100 * Math.pow(Math.max(0, v) / 100, 3 / 2);
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,
};
}
/** Sets the first property name this libmpv knows (some were renamed in 0.38). */
async function setAny(names: string[], value: unknown) {
for (const name of names) {
try {
await mpv.set(name, value);
return true;
} catch {
/* try the older name */
}
}
return false;
}
/** mpv colours are #AARRGGBB. */
const mpvColor = (hex: string, alpha = 1) => `#${Math.round(alpha * 255).toString(16).padStart(2, '0')}${hex.replace('#', '')}`.toUpperCase();
/** Applies the text subtitle look from preferences (image subtitles keep their own). */
async function applySubtitleStyle(prefs: Preferences = useSettings.getState()) {
const edge = prefs.subtitleEdge;
await mpv.set('sub-scale', prefs.subtitleScale).catch(() => {});
await mpv.set('sub-color', mpvColor(prefs.subtitleColor)).catch(() => {});
await mpv.set('sub-bold', prefs.subtitleBold).catch(() => {});
await mpv.set('sub-margin-y', SUBTITLE_MARGIN[prefs.subtitlePosition]).catch(() => {});
await setAny(['sub-outline-color', 'sub-border-color'], '#FF000000');
await setAny(['sub-outline-size', 'sub-border-size'], edge === 'outline' ? 1.8 : edge === 'raised' ? 1.3 : 0);
await mpv.set('sub-shadow-offset', edge === 'shadow' ? 2.2 : edge === 'raised' ? 1.6 : 0).catch(() => {});
await mpv.set('sub-shadow-color', '#B4000000').catch(() => {});
if (prefs.subtitleBox === 'none') {
await mpv.set('sub-border-style', 'outline-and-shadow').catch(() => {});
await mpv.set('sub-back-color', '#B4000000').catch(() => {});
return;
}
const box = prefs.subtitleBox === 'solid' ? '#FF000000' : '#A0000000';
await mpv.set('sub-back-color', box).catch(() => {});
if (!(await setAny(['sub-border-style'], 'background-box'))) {
// Before background-box, an opaque box is drawn in the outline colour.
await mpv.set('sub-border-style', 'opaque-box').catch(() => {});
await setAny(['sub-outline-color', 'sub-border-color'], box);
await setAny(['sub-outline-size', 'sub-border-size'], 3);
}
}
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: Math.round(mpvToSlider(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 'audio-delay':
if (typeof v === 'number') usePlayer.setState({ audioDelay: 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 } });
// Enhancement follows the decoded video's transfer (HDR skips SDR-tuned stages).
if (v?.gamma && v.gamma !== st.videoGamma) {
usePlayer.setState({ videoGamma: v.gamma });
requestEnhancement();
}
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':
noteMpvLog(e.level, e.prefix, e.text);
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,
mini: false,
audioDelay: 0,
enhance: { active: 'off', bypass: false, preparing: false },
videoGamma: '',
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,
mini: false,
videoGamma: '',
enhance: { ...previous.enhance, bypass: false, preparing: false },
});
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', sliderToMpv(prefs.volume));
await mpv.set('speed', 1);
await mpv.set('audio-delay', 0);
await applySubtitleStyle(prefs);
await requestEnhancement();
watchPerformance(true);
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);
watchPerformance(false);
if (isNative) {
await mpv.command('stop').catch(() => {});
await mpv.show(false).catch(() => {});
}
set({ open: false, mini: 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', sliderToMpv(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(() => {});
},
setAudioDelay(delay) {
mpv.set('audio-delay', delay).catch(() => {});
},
async minimize() {
const st = get();
if (!st.open || st.mini) return;
set({ mini: true });
// Full screen was for the video; browsing goes back to the window.
if (st.fullscreen && !wasFullscreenBeforePlay) {
await win.setFullscreen(false).catch(() => {});
set({ fullscreen: false });
}
},
expand() {
if (get().mini) set({ mini: false });
},
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. In the miniplayer the interface stays, with a hole for the video.
*/
usePlayer.subscribe((st, prev) => {
if (st.firstFrame !== prev.firstFrame || st.open !== prev.open || st.error !== prev.error || st.mini !== prev.mini) {
const html = document.documentElement.classList;
html.toggle('video-active', st.open && st.firstFrame && !st.error);
html.toggle('player-open', st.open && !st.mini);
html.toggle('player-mini', st.open && st.mini);
}
// However the miniplayer is left (expanding, playing another title, closing),
// the video returns to the whole window.
if (prev.mini && !st.mini && isNative) mpv.rect(null).catch(() => {});
});
/** Subtitle look changes apply to the playing video straight away. */
const SUBTITLE_PREFS = ['subtitleScale', 'subtitleColor', 'subtitleEdge', 'subtitleBox', 'subtitleBold', 'subtitlePosition'] as const;
useSettings.subscribe((prefs, prev) => {
if (isNative && usePlayer.getState().open && SUBTITLE_PREFS.some((k) => prefs[k] !== prev[k])) applySubtitleStyle(prefs);
});