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:
Elijah 2026-10-30 16:26:37 -07:00
commit 00d72e70f4
121 changed files with 25315 additions and 0 deletions

View file

@ -0,0 +1,566 @@
import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react';
import { usePlayer } from './store';
import { useSession } from '../app/session';
import { useSettings, QUALITY_LABEL, type Quality } from '../app/settings';
import { clock, episodeLabel } from '../app/format';
import { Icon } from '../ui/Icon';
import { Facts, TitleArt } from '../ui/media';
import { Button, Spinner } from '../ui/primitives';
import { win, isNative } from '../platform/native';
import type { Item } from '../plex/types';
const HIDE_AFTER = 3000;
function useAutoHide(paused: boolean, pinned: boolean) {
const [visible, setVisible] = useState(true);
const timer = useRef<ReturnType<typeof setTimeout> | null>(null);
const poke = useCallback(() => {
setVisible(true);
if (timer.current) clearTimeout(timer.current);
timer.current = setTimeout(() => setVisible(false), HIDE_AFTER);
}, []);
useEffect(() => {
if (paused || pinned) {
if (timer.current) clearTimeout(timer.current);
setVisible(true);
} else poke();
}, [paused, pinned, poke]);
return { visible, poke };
}
function Timeline({ onScrub }: { onScrub: (active: boolean) => void }) {
const position = usePlayer((s) => s.position);
const duration = usePlayer((s) => s.duration);
const cacheTime = usePlayer((s) => s.cacheTime);
const chapters = usePlayer((s) => s.chapters);
const markers = usePlayer((s) => s.item?.markers ?? []);
const seek = usePlayer((s) => s.seek);
const previewAt = usePlayer((s) => s.previewAt);
const ref = useRef<HTMLDivElement>(null);
const [hover, setHover] = useState<{ x: number; t: number } | null>(null);
const [drag, setDrag] = useState<number | null>(null);
const timeAt = (clientX: number) => {
const r = ref.current!.getBoundingClientRect();
const f = Math.min(1, Math.max(0, (clientX - r.left) / r.width));
return { f, t: f * duration, x: clientX - r.left };
};
useEffect(() => {
if (drag === null) return;
const move = (e: PointerEvent) => {
const { t, x } = timeAt(e.clientX);
setDrag(t);
setHover({ x, t });
};
const up = (e: PointerEvent) => {
const { t } = timeAt(e.clientX);
seek(t);
setDrag(null);
setHover(null);
onScrub(false);
};
window.addEventListener('pointermove', move);
window.addEventListener('pointerup', up, { once: true });
return () => {
window.removeEventListener('pointermove', move);
window.removeEventListener('pointerup', up);
};
}, [drag !== null]);
const shown = drag ?? position;
const pct = duration ? (shown / duration) * 100 : 0;
const buffered = duration ? Math.min(100, (Math.max(cacheTime, position) / duration) * 100) : 0;
const preview = hover ? previewAt(hover.t) : '';
const chapter = hover ? [...chapters].reverse().find((c) => c.time <= hover.t) : null;
const width = ref.current?.clientWidth ?? 0;
return (
<div
className={`timeline${drag !== null ? ' dragging' : ''}`}
ref={ref}
onPointerMove={(e) => {
if (drag === null && duration) {
const { t, x } = timeAt(e.clientX);
setHover({ x, t });
}
}}
onPointerLeave={() => drag === null && setHover(null)}
onPointerDown={(e) => {
if (!duration) return;
e.preventDefault();
const { t, x } = timeAt(e.clientX);
setDrag(t);
setHover({ x, t });
onScrub(true);
}}
role="slider"
aria-label="Seek"
aria-valuemin={0}
aria-valuemax={Math.round(duration)}
aria-valuenow={Math.round(position)}
>
<div className="timeline-track">
<div className="timeline-buffered" style={{ width: `${buffered}%` }} />
<div className="timeline-played" style={{ width: `${pct}%` }} />
{duration > 0 &&
markers
.filter((m) => m.type === 'intro' || m.type === 'credits')
.map((m) => <div key={m.id + m.start} className={`timeline-marker ${m.type}`} style={{ left: `${(m.start / 1000 / duration) * 100}%`, width: `${((m.end - m.start) / 1000 / duration) * 100}%` }} />)}
{duration > 0 && chapters.slice(1).map((c) => <div key={c.time} className="timeline-chapter" style={{ left: `${(c.time / duration) * 100}%` }} />)}
</div>
<div className="timeline-thumb" style={{ left: `${pct}%` }} />
{hover && (
<div className="timeline-preview" style={{ left: Math.min(Math.max(hover.x, 110), width - 110) }}>
{preview && <img src={preview} alt="" draggable={false} />}
<div className="timeline-preview-text">
{chapter && chapters.length > 1 && <span>{chapter.title}</span>}
<b>{clock(hover.t, duration >= 3600)}</b>
</div>
</div>
)}
</div>
);
}
function Panel({ title, onClose, children, className = '' }: { title: string; onClose: () => void; children: ReactNode; className?: string }) {
useEffect(() => {
const onKey = (e: KeyboardEvent) => {
if (e.key === 'Escape') {
e.stopPropagation();
onClose();
}
};
window.addEventListener('keydown', onKey, true);
return () => window.removeEventListener('keydown', onKey, true);
}, [onClose]);
return (
<div className={`player-panel ${className}`} onClick={(e) => e.stopPropagation()} onDoubleClick={(e) => e.stopPropagation()}>
<div className="player-panel-title">{title}</div>
{children}
</div>
);
}
function Option({ selected, label, detail, onClick }: { selected: boolean; label: string; detail?: string; onClick: () => void }) {
return (
<button className={`panel-option${selected ? ' selected' : ''}`} onClick={onClick}>
<span className="panel-check">{selected && <Icon name="check" size={16} />}</span>
<span className="panel-label">
{label}
{detail && <small>{detail}</small>}
</span>
</button>
);
}
function TracksPanel({ onClose }: { onClose: () => void }) {
const st = usePlayer();
return (
<Panel title="Audio & Subtitles" onClose={onClose} className="tracks">
<div className="panel-columns">
<div>
<h4>Audio</h4>
{st.audioTracks.map((t) => (
<Option key={t.key} selected={t.key === st.audioKey} label={t.label} detail={t.detail} onClick={() => st.selectAudio(t.key)} />
))}
{!st.audioTracks.length && <div className="panel-empty">No audio tracks</div>}
</div>
<div>
<h4>Subtitles</h4>
<Option selected={!st.subKey} label="Off" onClick={() => st.selectSubtitle('')} />
{st.subTracks.map((t) => (
<Option key={t.key} selected={t.key === st.subKey} label={t.label} detail={t.detail} onClick={() => st.selectSubtitle(t.key)} />
))}
{st.subKey && st.delivery?.mode !== 'transcode' && (
<div className="panel-delay">
<span>Timing</span>
<button onClick={() => st.setSubDelay(st.subDelay - 0.1)}>−</button>
<b>{st.subDelay > 0 ? '+' : ''}{st.subDelay.toFixed(1)}s</b>
<button onClick={() => st.setSubDelay(st.subDelay + 0.1)}>+</button>
</div>
)}
</div>
</div>
</Panel>
);
}
function SettingsPanel({ onClose }: { onClose: () => void }) {
const st = usePlayer();
const [view, setView] = useState<'main' | 'quality' | 'speed' | 'version' | 'chapters'>('main');
const speeds = [0.5, 0.75, 1, 1.25, 1.5, 2];
const media = st.item?.media ?? [];
const local = st.delivery?.mode === 'local';
if (view === 'quality')
return (
<Panel title="Quality" onClose={onClose}>
{(Object.keys(QUALITY_LABEL) as Quality[]).map((q) => (
<Option key={q} selected={st.quality === q} label={QUALITY_LABEL[q]} detail={q === 'original' ? 'Direct play of the source file' : 'Converted by your Plex server'} onClick={() => (st.setQuality(q), onClose())} />
))}
</Panel>
);
if (view === 'speed')
return (
<Panel title="Playback speed" onClose={onClose}>
{speeds.map((s) => (
<Option key={s} selected={Math.abs(st.speed - s) < 0.01} label={s === 1 ? 'Normal' : `${s}×`} onClick={() => (st.setSpeed(s), onClose())} />
))}
</Panel>
);
if (view === 'version')
return (
<Panel title="Version" onClose={onClose}>
{media.map((m, i) => (
<Option key={m.id} selected={st.mediaIndex === i} label={m.title || `${m.videoResolution.toUpperCase()} ${m.videoCodec.toUpperCase()}`} detail={[m.container.toUpperCase(), m.bitrate ? `${Math.round(m.bitrate / 1000)} Mbps` : ''].filter(Boolean).join(' · ')} onClick={() => (st.selectVersion(i), onClose())} />
))}
</Panel>
);
if (view === 'chapters')
return (
<Panel title="Chapters" onClose={onClose} className="chapters">
{st.chapters.map((c) => (
<Option key={c.time} selected={false} label={c.title} detail={clock(c.time)} onClick={() => (st.seek(c.time), onClose())} />
))}
</Panel>
);
const row = (label: string, value: string, go: () => void, disabled = false) => (
<button className="panel-row" onClick={go} disabled={disabled}>
<span>{label}</span>
<b>{value}</b>
<Icon name="next" size={14} />
</button>
);
return (
<Panel title="Playback" onClose={onClose}>
{!local && row('Quality', QUALITY_LABEL[st.quality], () => setView('quality'))}
{row('Speed', st.speed === 1 ? 'Normal' : `${st.speed}×`, () => setView('speed'))}
{media.length > 1 && !local && row('Version', `${st.mediaIndex + 1} of ${media.length}`, () => setView('version'))}
{st.chapters.length > 1 && row('Chapters', `${st.chapters.length}`, () => setView('chapters'))}
<div className="panel-info">
{st.delivery?.mode === 'direct' && 'Direct play'}
{st.delivery?.mode === 'transcode' && `Converting to ${st.delivery.label}`}
{st.delivery?.mode === 'local' && 'Playing from this computer'}
{st.video && st.video.width > 0 && ` · ${st.video.width}×${st.video.height}`}
{st.video?.codec && ` · ${st.video.codec.toUpperCase()}`}
{st.video?.hwdec && st.video.hwdec !== 'no' ? ' · Hardware decoding' : ''}
</div>
</Panel>
);
}
function Volume() {
const volume = usePlayer((s) => s.volume);
const muted = usePlayer((s) => s.muted);
const setVolume = usePlayer((s) => s.setVolume);
const toggleMute = usePlayer((s) => s.toggleMute);
const icon = muted || volume === 0 ? 'mute' : volume < 50 ? 'volumeLow' : 'volume';
return (
<div className="volume">
<button className="player-icon" aria-label={muted ? 'Unmute' : 'Mute'} onClick={toggleMute}>
<Icon name={icon} size={22} />
</button>
<input
type="range"
min={0}
max={100}
value={muted ? 0 : Math.min(100, volume)}
onChange={(e) => setVolume(Number(e.target.value))}
style={{ ['--v' as string]: `${muted ? 0 : Math.min(100, volume)}%` }}
aria-label="Volume"
/>
</div>
);
}
function SkipButton() {
const item = usePlayer((s) => s.item);
const position = usePlayer((s) => s.position);
const seek = usePlayer((s) => s.seek);
const nextUp = usePlayer((s) => s.nextUp);
const countdown = usePlayer((s) => s.countdown);
const skipIntro = useSettings((s) => s.skipIntro);
const skipCredits = useSettings((s) => s.skipCredits);
const autoSkipped = useRef(new Set<string>());
const ms = position * 1000;
const marker = item?.markers.find((m) => (m.type === 'intro' || m.type === 'credits') && ms >= m.start && ms < m.end - 1000);
const mode = marker?.type === 'intro' ? skipIntro : skipCredits;
useEffect(() => {
if (marker && mode === 'auto' && !autoSkipped.current.has(marker.id + marker.start) && !(marker.type === 'credits' && nextUp)) {
autoSkipped.current.add(marker.id + marker.start);
seek(marker.end / 1000);
}
}, [marker?.id, marker?.start, mode]);
if (!marker || mode === 'off' || countdown !== null) return null;
if (marker.type === 'credits' && nextUp) return null;
return (
<button className="skip-button" onClick={() => seek(marker.end / 1000)}>
{marker.type === 'intro' ? 'Skip intro' : 'Skip credits'}
<Icon name="skipNext" size={16} />
</button>
);
}
function PostPlay() {
const server = useSession((s) => s.server);
const nextUp = usePlayer((s) => s.nextUp);
const countdown = usePlayer((s) => s.countdown);
const playNext = usePlayer((s) => s.playNext);
const cancel = usePlayer((s) => s.cancelCountdown);
if (!nextUp || countdown === null || !server) return null;
return (
<div className="post-play" onClick={(e) => e.stopPropagation()} onDoubleClick={(e) => e.stopPropagation()}>
<div className="post-play-art">
<img src={server.image(nextUp.thumb, 360, 202)} alt="" draggable={false} />
{countdown > 0 && (
<svg className="post-play-ring" viewBox="0 0 40 40">
<circle cx="20" cy="20" r="17" />
</svg>
)}
</div>
<div className="post-play-text">
<span className="micro">Next episode{countdown > 0 ? ` in ${countdown}` : ''}</span>
<b>
{episodeLabel(nextUp)} · {nextUp.title}
</b>
<div className="actions">
<Button variant="primary" size="sm" icon="play" onClick={playNext}>
Play now
</Button>
<Button variant="ghost" size="sm" onClick={cancel}>
{countdown > 0 ? 'Cancel' : 'Dismiss'}
</Button>
</div>
</div>
</div>
);
}
function TitleBlock({ item }: { item: Item }) {
return (
<div className="player-title">
<TitleArt item={item.type === 'episode' ? { ...item, logo: item.raw?.Image?.find?.((i: any) => i.type === 'clearLogo')?.url ?? '' } : item} maxWidth={240} maxHeight={60} as="h2" />
{item.type === 'episode' && (
<div className="player-episode">
{episodeLabel(item)} · {item.title}
</div>
)}
{item.type !== 'clip' && <Facts item={item} withFormats={false} episode={false} />}
</div>
);
}
export function PlayerOverlay() {
const st = usePlayer();
const server = useSession((s) => s.server);
const [panel, setPanel] = useState<'' | 'tracks' | 'settings'>('');
const [scrubbing, setScrubbing] = useState(false);
const [flash, setFlash] = useState<{ icon: string; key: number } | null>(null);
const { visible, poke } = useAutoHide(st.paused || st.ended, !!panel || scrubbing || st.countdown !== null);
const clickTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
const seekStep = useSettings((s) => s.seekStep);
const showFlash = (icon: string) => setFlash({ icon, key: Date.now() });
useEffect(() => {
if (!st.open) setPanel('');
}, [st.open]);
useEffect(() => {
if (!st.open) return;
const onKey = async (e: KeyboardEvent) => {
if ((e.target as HTMLElement)?.tagName === 'INPUT' && (e.target as HTMLInputElement).type !== 'range') return;
const p = usePlayer.getState();
let handled = true;
switch (e.key) {
case ' ':
case 'k':
case 'K':
p.togglePause();
showFlash(p.paused ? 'play' : 'pause');
break;
case 'ArrowLeft':
case 'j':
case 'J':
p.seekBy(e.shiftKey ? -60 : e.key === 'ArrowLeft' ? -seekStep : -10);
showFlash('replay10');
break;
case 'ArrowRight':
case 'l':
case 'L':
p.seekBy(e.shiftKey ? 60 : e.key === 'ArrowRight' ? seekStep : 10);
showFlash('forward10');
break;
case 'ArrowUp':
p.setVolume(p.volume + 5);
break;
case 'ArrowDown':
p.setVolume(p.volume - 5);
break;
case 'm':
case 'M':
p.toggleMute();
break;
case 'f':
case 'F':
case 'F11':
p.toggleFullscreen();
break;
case 'n':
case 'N':
if (e.shiftKey && p.nextUp) p.playNext();
else handled = false;
break;
case 'c':
case 'C': {
const subs = p.subTracks;
const i = subs.findIndex((t) => t.key === p.subKey);
p.selectSubtitle(i + 1 < subs.length ? subs[i + 1].key : '');
break;
}
case 'Escape': {
const fs = await win.isFullscreen().catch(() => false);
if (fs) p.toggleFullscreen();
else p.close();
break;
}
case 'Backspace':
p.close();
break;
case 'Home':
p.seek(0);
break;
default:
if (/^[0-9]$/.test(e.key) && p.duration) p.seek((Number(e.key) / 10) * p.duration);
else handled = false;
}
if (handled) {
e.preventDefault();
e.stopPropagation();
poke();
}
};
window.addEventListener('keydown', onKey);
return () => window.removeEventListener('keydown', onKey);
}, [st.open, seekStep, poke]);
if (!st.open || !st.item) return null;
const item = st.item;
const loading = !st.firstFrame && !st.error;
const art = item.type === 'episode' ? item.grandparentArt || item.art : item.art;
const hideChrome = !visible && !loading && !st.error;
return (
<div
className={`player${hideChrome ? ' idle' : ''}${loading ? ' loading' : ''}`}
onMouseMove={poke}
onClick={() => {
if (panel) return setPanel('');
if (clickTimer.current) return;
clickTimer.current = setTimeout(() => {
clickTimer.current = null;
if (!loading && !st.error) {
st.togglePause();
showFlash(st.paused ? 'play' : 'pause');
}
}, 220);
}}
onDoubleClick={() => {
if (clickTimer.current) clearTimeout(clickTimer.current);
clickTimer.current = null;
st.toggleFullscreen();
}}
onWheel={(e) => st.setVolume(st.volume + (e.deltaY < 0 ? 5 : -5))}
>
{(loading || st.error) && server && (
<div className="player-cover">
{art && <img src={server.image(art, 1280, 720, { blur: 0 })} alt="" />}
<div className="player-cover-scrim" />
</div>
)}
<div className="player-gradient top" />
<div className="player-gradient bottom" />
<div className="player-top" data-tauri-drag-region={isNative ? true : undefined} onClick={(e) => e.stopPropagation()} onDoubleClick={(e) => e.stopPropagation()}>
<button className="player-back" onClick={() => st.close()} aria-label="Back">
<Icon name="arrowLeft" size={22} />
</button>
</div>
{(loading || st.buffering || st.seeking) && !st.error && (
<div className="player-center">
<Spinner size={44} />
</div>
)}
{flash && !loading && (
<div className="player-flash" key={flash.key}>
<Icon name={flash.icon} size={34} />
</div>
)}
{st.error && (
<div className="player-error" onClick={(e) => e.stopPropagation()}>
<Icon name="alert" size={28} />
<h2>Playback stopped</h2>
<p>{st.error}</p>
<div className="actions">
<Button variant="primary" icon="refresh" onClick={() => st.play(item, { offsetMs: st.position * 1000, quality: st.quality === 'original' ? '1080' : st.quality })}>
Try converting
</Button>
<Button variant="ghost" onClick={() => st.close()}>
Close
</Button>
</div>
</div>
)}
<SkipButton />
<PostPlay />
{!st.error && (
<div className="player-bottom" onClick={(e) => e.stopPropagation()} onDoubleClick={(e) => e.stopPropagation()}>
<div className="player-bottom-head">
<TitleBlock item={item} />
<div className="player-delivery">{st.delivery?.mode === 'transcode' ? st.delivery.label : st.delivery?.mode === 'local' ? 'Offline' : ''}</div>
</div>
<Timeline onScrub={setScrubbing} />
<div className="player-controls">
<div className="player-controls-left">
<button className="player-icon big" aria-label={st.paused ? 'Play' : 'Pause'} onClick={() => st.togglePause()}>
<Icon name={st.paused || st.ended ? 'play' : 'pause'} size={26} />
</button>
<button className="player-icon" aria-label="Back 10 seconds" onClick={() => st.seekBy(-10)}>
<Icon name="replay10" size={24} />
</button>
<button className="player-icon" aria-label="Forward 10 seconds" onClick={() => st.seekBy(10)}>
<Icon name="forward10" size={24} />
</button>
{st.nextUp && (
<button className="player-icon" aria-label="Next episode" title={`Next: ${episodeLabel(st.nextUp)} ${st.nextUp.title}`} onClick={() => st.playNext()}>
<Icon name="skipNext" size={22} />
</button>
)}
<Volume />
<span className="player-time">
{clock(st.position, st.duration >= 3600)} <span className="dim">/ {clock(st.duration, st.duration >= 3600)}</span>
</span>
</div>
<div className="player-controls-right">
<button className={`player-icon${panel === 'tracks' ? ' on' : ''}${st.subKey ? ' lit' : ''}`} aria-label="Audio and subtitles" onClick={() => setPanel(panel === 'tracks' ? '' : 'tracks')}>
<Icon name="captions" size={23} />
</button>
<button className={`player-icon${panel === 'settings' ? ' on' : ''}`} aria-label="Playback settings" onClick={() => setPanel(panel === 'settings' ? '' : 'settings')}>
<Icon name="settings" size={22} />
</button>
<button className="player-icon" aria-label={st.fullscreen ? 'Exit full screen' : 'Full screen'} onClick={() => st.toggleFullscreen()}>
<Icon name={st.fullscreen ? 'collapse' : 'expand'} size={21} />
</button>
</div>
</div>
{panel === 'tracks' && <TracksPanel onClose={() => setPanel('')} />}
{panel === 'settings' && <SettingsPanel onClose={() => setPanel('')} />}
</div>
)}
</div>
);
}

43
src/player/engine.ts Normal file
View file

@ -0,0 +1,43 @@
/** Thin typed wrapper over the native mpv commands and its event stream. */
import { invoke, isNative, listen } from '../platform/native';
export interface MpvTrack {
id: number;
type: 'video' | 'audio' | 'sub';
title?: string;
lang?: string;
codec?: string;
default?: boolean;
forced?: boolean;
external?: boolean;
selected?: boolean;
'ff-index'?: number;
'demux-channel-count'?: number;
'external-filename'?: string;
}
export type MpvEvent =
| { type: 'property'; name: string; value: any }
| { type: 'start-file' | 'file-loaded' | 'playback-restart' | 'seek' }
| { type: 'end-file'; reason: string; error?: string | null }
| { type: 'log'; level: string; prefix: string; text: string };
let initialized: Promise<void> | null = null;
export const mpv = {
available: isNative,
init(options: { hwdec: boolean; hdr: boolean }) {
if (!initialized) {
initialized = invoke<void>('player_init', { options: { hwdec: options.hwdec ? 'auto-safe' : 'no', hdr: options.hdr, extra: [] } }).catch((e) => {
initialized = null;
throw e;
});
}
return initialized;
},
command: (...args: (string | number)[]) => invoke<void>('player_command', { args: args.map(String) }),
set: (name: string, value: unknown) => invoke<void>('player_set', { name, value }),
get: <T = any>(name: string) => invoke<T>('player_get', { name }),
show: (visible: boolean) => invoke<void>('player_show', { visible }),
on: (handler: (e: MpvEvent) => void) => listen<MpvEvent>('mpv', handler),
};

693
src/player/store.ts Normal file
View 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);
}
});

52
src/player/theme.ts Normal file
View file

@ -0,0 +1,52 @@
/** Optional title theme music on detail pages, faded in and out. */
import { useSession } from '../app/session';
import { useSettings } from '../app/settings';
let audio: HTMLAudioElement | null = null;
let current = '';
let fade: ReturnType<typeof setInterval> | null = null;
function fadeTo(target: number, done?: () => void) {
if (!audio) return;
if (fade) clearInterval(fade);
const a = audio;
fade = setInterval(() => {
const step = 0.02;
if (Math.abs(a.volume - target) <= step) {
a.volume = target;
clearInterval(fade!);
fade = null;
done?.();
} else a.volume += a.volume < target ? step : -step;
}, 40);
}
export function playThemeMusic(path: string) {
const prefs = useSettings.getState();
const server = useSession.getState().server;
if (!prefs.themeMusic || !path || !server || document.documentElement.classList.contains('player-open')) return;
if (path === current && audio && !audio.paused) return;
stopThemeMusic(true);
current = path;
audio = new Audio(server.signed(path));
audio.volume = 0;
audio.loop = false;
audio.play().then(() => fadeTo(prefs.themeVolume / 100), () => {});
}
export function stopThemeMusic(immediate = false) {
current = '';
if (!audio) return;
const a = audio;
audio = null;
if (immediate) {
a.pause();
return;
}
const prev = audio;
audio = a;
fadeTo(0, () => {
a.pause();
if (audio === a) audio = prev;
});
}