fix(jellyfin): show overlay, inject plugin, and fix stats title on playback (#77)

* fix(jellyfin): show overlay, inject plugin, and fix stats title on playb - Show visible overlay automatically during Jellyfin playback so subtitleStyle applies - Inject bundled mpv plugin on auto-launch so keybindings work without overlay focus - Group Jellyfin playback stats under item metadata (jellyfin://host/item/id) instead of stream URLs so episodes merge with matching local titles - Mark ffsubsync unavailable in subsync modal for remote media paths - Drain queued second-instance commands even when onReady throws * fix(overlay): stabilize macOS focus handoff and sidebar Yomitan pause - Keep overlay visible during macOS foreground probe after overlay blur - Hold sidebar hover-pause while a Yomitan lookup popup remains open * fix(jellyfin): fix discovery loop, device identity, tray state, and Disc - Derive device identity from OS hostname; remove legacy configurable client/device fields - Prevent discovery playback from reloading active item, misreporting pause state, and duplicate overlay restores - Restart stale tray discovery sessions without re-login when server drops SubMiner cast target - Sync tray discovery checkbox state on Linux after CLI/startup/remote-session changes - Stop Discord presence falling back to stream URLs; prime title before tokenized stream loads - Fix picker library discovery when log level is above info - Fix config.example.jsonc trailing commas and array formatting * docs(release): trim and consolidate prerelease notes for 0.15.0 - Remove breaking changes section and several redundant bullet points - Consolidate per-platform updater notes into a single entry - Normalize em-dash separators to hyphens in section headers * fix(config): remove trailing commas from config.example.jsonc - Strip trailing commas throughout both config.example.jsonc copies - Reformat inline arrays to multi-line for JSON strictness - Update Jellyfin subtitle preload and playback launch tests and impl * fix(tokenizer): preserve known-word highlight when POS filters suppress - Known-word cache matches now set isKnown=true even for tokens excluded by POS filters - POS exclusion gate suppresses N+1, frequency, and JLPT only; known status is computed before the gate - Jellyfin subtitle preload continues after cleanup failures instead of aborting - Update config docs and option description to document the known-word bypass behavior * fix(jellyfin): send explicit hide/show overlay instead of toggle - Track overlay visibility in plugin state; y-t uses explicit hide/show commands when state is known - Prevent paused Jellyfin playback from resuming on overlay hide - Fix subtitle cache cleanup to only remove dirs after successful cleanup * fix(jellyfin): fix remote progress sync, seek reporting, and startup sto - arm active playback before loadfile with loadedMediaPath: null to suppress premature stop events - force immediate progress report on seek-like position jumps at the mpv time-pos level - send positionTicks and failed=false in reportStopped payload - remove EventName from HTTP timeline payloads (websocket-only field) - add startup grace window to drop stop events before media finishes loading * fix(jellyfin): fix overlay toggle sync, redirect reload, and AppImage bi - Sync visible-overlay state back to plugin via script messages to avoid toggle/hide drift - Collapse duplicate toggle events within 250ms to prevent hide-then-show on single keypress - Preserve manual hide across Jellyfin path-changing redirects even when media-title drops - Rearm managed subtitle defaults on path-changing redirects - Route toggleVisibleOverlay session binding through plugin toggle instead of app-side IPC - Show Linux/Hyprland overlay passively (showInactive) to avoid stealing mpv keyboard focus - Fix AppImage binary resolution to prefer $APPIMAGE env over mounted inner binary - Add stats window layer management so delete/update dialogs appear above stats window - Fix Jellyfin remote progress sync during Linux websocket reconnect windows * Fix CodeRabbit review feedback * fix(jellyfin): subtitle timing, resume progress, and overlay sync - Add per-stream subtitle delay persistence and auto timeline-offset correction - Strip server-selected subtitle stream from mpv load URL; suppress plugin subtitle rearm and auto-start during app-managed preload - Fix resume position lost when mpv resets on stop; use last known position for final progress/stopped reports - Keep Play vs Resume distinct to avoid early seek race on normal play - Fix discovery resume when remote play sends StartPositionTicks=0 despite saved progress - Deduplicate show/hide overlay commands using recorded visibility state - Rewrite docs-site Jellyfin page around cast-to-device UX * test: update lifecycle cleanup assertion * fix: clear aborted playback state, fix overlay passthrough, and guard du - Reset app_managed_playback_pending on lifecycle cleanup to prevent state leak into next item - Record visible overlay action only after command succeeds, not before - Non-native passive overlay now always click-through on re-show (fix isNonNativePassiveOverlay ordering) - Defer activeParsedSubtitleMediaPath assignment until after prefetch completes - Move autoplay gate release into the hide branch of toggleVisibleOverlay - Clear active Jellyfin playback when stopping media that never loaded - Reset managed subtitle delay and delay key when no external tracks are available - Await async removeDir in subtitle cache cleanup - Guard duplicate delete clicks in MediaDetailView and SessionsTab with refs - Escape key in DeleteConfirmDialog now calls stopPropagation and stopImmediatePropagation
2026-05-26 12:55:16 -07:00 · 2026-05-24 18:40:56 -07:00
parent da3c971ee6
commit b1bdeabca8
193 changed files with 7975 additions and 771 deletions
@@ -0,0 +1,153 @@
+import type { SubtitleCue } from './subtitle-cue-parser';
+
+export type SubtitleTimingOffsetResult = {
+  offsetSeconds: number;
+  matchCount: number;
+  meanErrorSeconds: number;
+  maxErrorSeconds: number;
+};
+
+export type SubtitleTimingOffsetOptions = {
+  maxCueCount?: number;
+  maxOffsetSeconds?: number;
+  matchThresholdSeconds?: number;
+  maxMeanErrorSeconds?: number;
+  minMatchCount?: number;
+  minMatchRatio?: number;
+  minUsefulOffsetSeconds?: number;
+};
+
+type OffsetScore = SubtitleTimingOffsetResult;
+
+const DEFAULT_MAX_CUE_COUNT = 60;
+const DEFAULT_MAX_OFFSET_SECONDS = 180;
+const DEFAULT_MATCH_THRESHOLD_SECONDS = 1;
+const DEFAULT_MAX_MEAN_ERROR_SECONDS = 0.75;
+const DEFAULT_MIN_MATCH_COUNT = 8;
+const DEFAULT_MIN_MATCH_RATIO = 0.25;
+const DEFAULT_MIN_USEFUL_OFFSET_SECONDS = 0.25;
+
+function normalizeCueStarts(cues: SubtitleCue[], maxCueCount: number): number[] {
+  const starts = cues
+    .map((cue) => cue.startTime)
+    .filter((start) => Number.isFinite(start) && start >= 0)
+    .sort((a, b) => a - b);
+  const deduped: number[] = [];
+  for (const start of starts) {
+    const previous = deduped[deduped.length - 1];
+    if (previous === undefined || Math.abs(start - previous) > 0.05) {
+      deduped.push(start);
+    }
+    if (deduped.length >= maxCueCount) {
+      break;
+    }
+  }
+  return deduped;
+}
+
+function roundToMillis(value: number): number {
+  return Math.round(value * 1000) / 1000;
+}
+
+function scoreOffset(
+  primaryStarts: number[],
+  referenceStarts: number[],
+  offsetSeconds: number,
+  matchThresholdSeconds: number,
+): OffsetScore {
+  let primaryIndex = 0;
+  let referenceIndex = 0;
+  let matchCount = 0;
+  let totalErrorSeconds = 0;
+  let maxErrorSeconds = 0;
+
+  while (primaryIndex < primaryStarts.length && referenceIndex < referenceStarts.length) {
+    const shiftedPrimary = primaryStarts[primaryIndex]! + offsetSeconds;
+    const reference = referenceStarts[referenceIndex]!;
+    const errorSeconds = Math.abs(shiftedPrimary - reference);
+    if (errorSeconds <= matchThresholdSeconds) {
+      matchCount += 1;
+      totalErrorSeconds += errorSeconds;
+      maxErrorSeconds = Math.max(maxErrorSeconds, errorSeconds);
+      primaryIndex += 1;
+      referenceIndex += 1;
+      continue;
+    }
+
+    if (shiftedPrimary < reference) {
+      primaryIndex += 1;
+    } else {
+      referenceIndex += 1;
+    }
+  }
+
+  return {
+    offsetSeconds,
+    matchCount,
+    meanErrorSeconds: matchCount > 0 ? totalErrorSeconds / matchCount : Number.POSITIVE_INFINITY,
+    maxErrorSeconds,
+  };
+}
+
+function isBetterScore(next: OffsetScore, current: OffsetScore | null): boolean {
+  if (current === null) return true;
+  if (next.matchCount !== current.matchCount) return next.matchCount > current.matchCount;
+  if (next.meanErrorSeconds !== current.meanErrorSeconds) {
+    return next.meanErrorSeconds < current.meanErrorSeconds;
+  }
+  return Math.abs(next.offsetSeconds) < Math.abs(current.offsetSeconds);
+}
+
+export function estimateSubtitleTimingOffset(
+  primaryCues: SubtitleCue[],
+  referenceCues: SubtitleCue[],
+  options: SubtitleTimingOffsetOptions = {},
+): SubtitleTimingOffsetResult | null {
+  const maxCueCount = options.maxCueCount ?? DEFAULT_MAX_CUE_COUNT;
+  const maxOffsetSeconds = options.maxOffsetSeconds ?? DEFAULT_MAX_OFFSET_SECONDS;
+  const matchThresholdSeconds = options.matchThresholdSeconds ?? DEFAULT_MATCH_THRESHOLD_SECONDS;
+  const maxMeanErrorSeconds = options.maxMeanErrorSeconds ?? DEFAULT_MAX_MEAN_ERROR_SECONDS;
+  const minMatchCount = options.minMatchCount ?? DEFAULT_MIN_MATCH_COUNT;
+  const minMatchRatio = options.minMatchRatio ?? DEFAULT_MIN_MATCH_RATIO;
+  const minUsefulOffsetSeconds =
+    options.minUsefulOffsetSeconds ?? DEFAULT_MIN_USEFUL_OFFSET_SECONDS;
+
+  const primaryStarts = normalizeCueStarts(primaryCues, maxCueCount);
+  const referenceStarts = normalizeCueStarts(referenceCues, maxCueCount);
+  const comparableCueCount = Math.min(primaryStarts.length, referenceStarts.length);
+  if (comparableCueCount < minMatchCount) {
+    return null;
+  }
+
+  const candidates = new Set<number>();
+  for (const primaryStart of primaryStarts) {
+    for (const referenceStart of referenceStarts) {
+      const offsetSeconds = roundToMillis(referenceStart - primaryStart);
+      if (Math.abs(offsetSeconds) <= maxOffsetSeconds) {
+        candidates.add(offsetSeconds);
+      }
+    }
+  }
+
+  let best: OffsetScore | null = null;
+  for (const offsetSeconds of candidates) {
+    if (Math.abs(offsetSeconds) < minUsefulOffsetSeconds) {
+      continue;
+    }
+    const score = scoreOffset(primaryStarts, referenceStarts, offsetSeconds, matchThresholdSeconds);
+    if (score.matchCount < minMatchCount) {
+      continue;
+    }
+    if (score.matchCount / comparableCueCount < minMatchRatio) {
+      continue;
+    }
+    if (score.meanErrorSeconds > maxMeanErrorSeconds) {
+      continue;
+    }
+    if (isBetterScore(score, best)) {
+      best = score;
+    }
+  }
+
+  return best;
+}