working subs

utils/jellyfin/getDefaultPlaySettings.ts

@@ -1,4 +1,13 @@
-// utils/getDefaultPlaySettings.ts
+/**
+ * getDefaultPlaySettings.ts
+ *
+ * Determines default audio/subtitle tracks and bitrate for playback.
+ *
+ * Two use cases:
+ * 1. INITIAL PLAY: No previous state, uses media defaults + user language preferences
+ * 2. SEQUENTIAL PLAY: Has previous state (e.g., next episode), uses StreamRanker
+ *    to find matching tracks in the new media
+ */
 
 import type {
   BaseItemDto,
@@ -12,86 +21,83 @@ import {
   SubtitleStreamRanker,
 } from "../streamRanker";
 
-interface PlaySettings {
+export interface PlaySettings {
   item: BaseItemDto;
   bitrate: (typeof BITRATES)[0];
   mediaSource?: MediaSourceInfo | null;
-  audioIndex?: number | undefined;
-  subtitleIndex?: number | undefined;
-}
-
-export interface previousIndexes {
   audioIndex?: number;
   subtitleIndex?: number;
 }
 
-interface TrackOptions {
-  DefaultAudioStreamIndex: number | undefined;
-  DefaultSubtitleStreamIndex: number | undefined;
+export interface PreviousIndexes {
+  audioIndex?: number;
+  subtitleIndex?: number;
 }
 
-// Used getting default values for the next player.
+/**
+ * Get default play settings for an item.
+ *
+ * @param item - The media item to play
+ * @param settings - User settings (language preferences, bitrate, etc.)
+ * @param previous - Optional previous track selections to carry over (for sequential play)
+ */
 export function getDefaultPlaySettings(
   item: BaseItemDto,
-  settings: Settings,
-  previousIndexes?: previousIndexes,
-  previousSource?: MediaSourceInfo,
+  settings: Settings | null,
+  previous?: { indexes?: PreviousIndexes; source?: MediaSourceInfo },
 ): PlaySettings {
-  if (item.Type === "Program") {
-    return {
-      item,
-      bitrate: BITRATES[0],
-      mediaSource: undefined,
-      audioIndex: undefined,
-      subtitleIndex: undefined,
-    };
-  }
+  const bitrate = settings?.defaultBitrate ?? BITRATES[0];
 
-  // 1. Get first media source
+  // Live TV programs don't have media sources
+  if (item.Type === "Program") {
+    return { item, bitrate };
+  }
 
   const mediaSource = item.MediaSources?.[0];
+  const streams = mediaSource?.MediaStreams ?? [];
 
-  // We prefer the previous track over the default track.
-  const trackOptions: TrackOptions = {
-    DefaultAudioStreamIndex: mediaSource?.DefaultAudioStreamIndex ?? -1,
-    DefaultSubtitleStreamIndex: mediaSource?.DefaultSubtitleStreamIndex ?? -1,
-  };
+  // Start with media source defaults
+  let audioIndex = mediaSource?.DefaultAudioStreamIndex;
+  let subtitleIndex = mediaSource?.DefaultSubtitleStreamIndex ?? -1;
 
-  const mediaStreams = mediaSource?.MediaStreams ?? [];
-  if (settings?.rememberSubtitleSelections && previousIndexes) {
-    if (previousIndexes.subtitleIndex !== undefined && previousSource) {
-      const subtitleRanker = new SubtitleStreamRanker();
-      const ranker = new StreamRanker(subtitleRanker);
+  // Try to match previous selections (sequential play)
+  if (previous?.indexes && previous?.source && settings) {
+    if (
+      settings.rememberSubtitleSelections &&
+      previous.indexes.subtitleIndex !== undefined
+    ) {
+      const ranker = new StreamRanker(new SubtitleStreamRanker());
+      const result = { DefaultSubtitleStreamIndex: subtitleIndex };
       ranker.rankStream(
-        previousIndexes.subtitleIndex,
-        previousSource,
-        mediaStreams,
-        trackOptions,
+        previous.indexes.subtitleIndex,
+        previous.source,
+        streams,
+        result,
       );
+      subtitleIndex = result.DefaultSubtitleStreamIndex;
+    }
+
+    if (
+      settings.rememberAudioSelections &&
+      previous.indexes.audioIndex !== undefined
+    ) {
+      const ranker = new StreamRanker(new AudioStreamRanker());
+      const result = { DefaultAudioStreamIndex: audioIndex };
+      ranker.rankStream(
+        previous.indexes.audioIndex,
+        previous.source,
+        streams,
+        result,
+      );
+      audioIndex = result.DefaultAudioStreamIndex;
     }
   }
 
-  if (settings?.rememberAudioSelections && previousIndexes) {
-    if (previousIndexes.audioIndex !== undefined && previousSource) {
-      const audioRanker = new AudioStreamRanker();
-      const ranker = new StreamRanker(audioRanker);
-      ranker.rankStream(
-        previousIndexes.audioIndex,
-        previousSource,
-        mediaStreams,
-        trackOptions,
-      );
-    }
-  }
-
-  // 4. Get default bitrate from settings or fallback to max
-  const bitrate = settings.defaultBitrate ?? BITRATES[0];
-
   return {
     item,
     bitrate,
     mediaSource,
-    audioIndex: trackOptions.DefaultAudioStreamIndex,
-    subtitleIndex: trackOptions.DefaultSubtitleStreamIndex,
+    audioIndex: audioIndex ?? undefined,
+    subtitleIndex: subtitleIndex ?? undefined,
   };
 }

utils/jellyfin/session/capabilities.ts

@@ -1,7 +1,7 @@
 import type { Api } from "@jellyfin/sdk";
 import type { AxiosResponse } from "axios";
-import type { Settings } from "@/utils/atoms/settings";
-import { generateDeviceProfile } from "@/utils/profiles/native";
+import type { Settings } from "../../atoms/settings";
+import { generateDeviceProfile } from "../../profiles/native";
 import { getAuthHeaders } from "../jellyfin";
 
 interface PostCapabilitiesParams {

utils/jellyfin/subtitleUtils.ts

@@ -0,0 +1,115 @@
+/**
+ * Subtitle utility functions for mapping between Jellyfin and MPV track indices.
+ *
+ * Jellyfin uses server-side indices (e.g., 3, 4, 5 for subtitles in MediaStreams).
+ * MPV uses its own track IDs starting from 1, only counting tracks loaded into MPV.
+ *
+ * Image-based subtitles (PGS, VOBSUB) during transcoding are burned into the video
+ * and NOT available in MPV's track list.
+ */
+
+import {
+  type MediaSourceInfo,
+  type MediaStream,
+  SubtitleDeliveryMethod,
+} from "@jellyfin/sdk/lib/generated-client";
+
+/** Check if subtitle is image-based (PGS, VOBSUB, etc.) */
+export const isImageBasedSubtitle = (sub: MediaStream): boolean =>
+  sub.IsTextSubtitleStream === false;
+
+/**
+ * Determine if a subtitle will be available in MPV's track list.
+ *
+ * A subtitle is in MPV if:
+ * - Delivery is Embed/Hls/External AND not an image-based sub during transcode
+ */
+export const isSubtitleInMpv = (
+  sub: MediaStream,
+  isTranscoding: boolean,
+): boolean => {
+  // During transcoding, image-based subs are burned in, not in MPV
+  if (isTranscoding && isImageBasedSubtitle(sub)) {
+    return false;
+  }
+
+  // Embed/Hls/External methods mean the sub is loaded into MPV
+  return (
+    sub.DeliveryMethod === SubtitleDeliveryMethod.Embed ||
+    sub.DeliveryMethod === SubtitleDeliveryMethod.Hls ||
+    sub.DeliveryMethod === SubtitleDeliveryMethod.External
+  );
+};
+
+/**
+ * Calculate the MPV track ID for a given Jellyfin subtitle index.
+ *
+ * MPV track IDs are 1-based and only count subtitles that are actually in MPV.
+ * We iterate through all subtitles, counting only those in MPV, until we find
+ * the one matching the Jellyfin index.
+ *
+ * @param mediaSource - The media source containing subtitle streams
+ * @param jellyfinSubtitleIndex - The Jellyfin server-side subtitle index (-1 = disabled)
+ * @param isTranscoding - Whether the stream is being transcoded
+ * @returns MPV track ID (1-based), or -1 if disabled, or undefined if not in MPV
+ */
+export const getMpvSubtitleId = (
+  mediaSource: MediaSourceInfo | null | undefined,
+  jellyfinSubtitleIndex: number | undefined,
+  isTranscoding: boolean,
+): number | undefined => {
+  // -1 or undefined means disabled
+  if (jellyfinSubtitleIndex === undefined || jellyfinSubtitleIndex === -1) {
+    return -1;
+  }
+
+  const allSubs =
+    mediaSource?.MediaStreams?.filter((s) => s.Type === "Subtitle") || [];
+
+  // Find the subtitle with the matching Jellyfin index
+  const targetSub = allSubs.find((s) => s.Index === jellyfinSubtitleIndex);
+
+  // If the target subtitle isn't in MPV (e.g., image-based during transcode), return undefined
+  if (!targetSub || !isSubtitleInMpv(targetSub, isTranscoding)) {
+    return undefined;
+  }
+
+  // Count MPV track position (1-based)
+  let mpvIndex = 0;
+  for (const sub of allSubs) {
+    if (isSubtitleInMpv(sub, isTranscoding)) {
+      mpvIndex++;
+      if (sub.Index === jellyfinSubtitleIndex) {
+        return mpvIndex;
+      }
+    }
+  }
+
+  return undefined;
+};
+
+/**
+ * Calculate the MPV track ID for a given Jellyfin audio index.
+ *
+ * Audio tracks are simpler - they're always in MPV (no burn-in like image subs).
+ * MPV track IDs are 1-based.
+ *
+ * @param mediaSource - The media source containing audio streams
+ * @param jellyfinAudioIndex - The Jellyfin server-side audio index
+ * @returns MPV track ID (1-based), or undefined if not found
+ */
+export const getMpvAudioId = (
+  mediaSource: MediaSourceInfo | null | undefined,
+  jellyfinAudioIndex: number | undefined,
+): number | undefined => {
+  if (jellyfinAudioIndex === undefined) {
+    return undefined;
+  }
+
+  const allAudio =
+    mediaSource?.MediaStreams?.filter((s) => s.Type === "Audio") || [];
+
+  // Find position in audio list (1-based for MPV)
+  const position = allAudio.findIndex((a) => a.Index === jellyfinAudioIndex);
+  return position >= 0 ? position + 1 : undefined;
+};

utils/profiles/native.d.ts

@@ -4,8 +4,4 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-export interface DeviceProfileOptions {
-  transcode?: boolean;
-}
-
-export function generateDeviceProfile(options?: DeviceProfileOptions): any;
+export function generateDeviceProfile(): any;

utils/profiles/native.js

@@ -6,12 +6,12 @@
 import MediaTypes from "../../constants/MediaTypes";
 import { getSubtitleProfiles } from "./subtitles";
 
-export const generateDeviceProfile = ({ transcode = false } = {}) => {
+export const generateDeviceProfile = () => {
   /**
    * Device profile for Native video player
    */
   const profile = {
-    Name: `1. Vlc Player${transcode ? " (Transcoding)" : ""}`,
+    Name: `1. MPV Player`,
     MaxStaticBitrate: 999_999_999,
     MaxStreamingBitrate: 999_999_999,
     CodecProfiles: [
@@ -48,7 +48,7 @@ export const generateDeviceProfile = ({ transcode = false } = {}) => {
         Container: "mp4,mkv,avi,mov,flv,ts,m2ts,webm,ogv,3gp,hls",
         VideoCodec:
           "h264,hevc,mpeg4,divx,xvid,wmv,vc1,vp8,vp9,av1,avi,mpeg,mpeg2video",
-        AudioCodec: "aac,ac3,eac3,mp3,flac,alac,opus,vorbis,wma,dts",
+        AudioCodec: "aac,ac3,eac3,mp3,flac,alac,opus,vorbis,wma,dts,truehd",
       },
       {
         Type: MediaTypes.Audio,
@@ -75,7 +75,7 @@ export const generateDeviceProfile = ({ transcode = false } = {}) => {
         MaxAudioChannels: "2",
       },
     ],
-    SubtitleProfiles: getSubtitleProfiles(transcode ? "hls" : "External"),
+    SubtitleProfiles: getSubtitleProfiles(),
   };
 
   return profile;

utils/profiles/subtitles.js

@@ -4,26 +4,19 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-const COMMON_SUBTITLE_PROFILES = [
-  // Official formats
-
-  { Format: "dvdsub", Method: "Embed" },
-  { Format: "dvdsub", Method: "Encode" },
-
-  { Format: "idx", Method: "Embed" },
-  { Format: "idx", Method: "Encode" },
-
-  { Format: "pgs", Method: "Embed" },
-  { Format: "pgs", Method: "Encode" },
-
-  { Format: "pgssub", Method: "Embed" },
-  { Format: "pgssub", Method: "Encode" },
-
-  { Format: "teletext", Method: "Embed" },
-  { Format: "teletext", Method: "Encode" },
+// Image-based formats - these need to be burned in by Jellyfin (Encode method)
+// because MPV cannot load them externally over HTTP
+const IMAGE_BASED_FORMATS = [
+  "dvdsub",
+  "idx",
+  "pgs",
+  "pgssub",
+  "teletext",
+  "vobsub",
 ];
 
-const VARYING_SUBTITLE_FORMATS = [
+// Text-based formats - these can be loaded externally by MPV
+const TEXT_BASED_FORMATS = [
   "webvtt",
   "vtt",
   "srt",
@@ -46,11 +39,23 @@ const VARYING_SUBTITLE_FORMATS = [
   "xsub",
 ];
 
-export const getSubtitleProfiles = (secondaryMethod) => {
-  const profiles = [...COMMON_SUBTITLE_PROFILES];
-  for (const format of VARYING_SUBTITLE_FORMATS) {
+export const getSubtitleProfiles = () => {
+  const profiles = [];
+
+  // Image-based formats: Embed or Encode (burn-in), NOT External
+  for (const format of IMAGE_BASED_FORMATS) {
     profiles.push({ Format: format, Method: "Embed" });
-    profiles.push({ Format: format, Method: secondaryMethod });
+    profiles.push({ Format: format, Method: "Encode" });
   }
+
+  // Text-based formats: Embed or External
+  for (const format of TEXT_BASED_FORMATS) {
+    profiles.push({ Format: format, Method: "Embed" });
+    profiles.push({ Format: format, Method: "External" });
+  }
+
   return profiles;
 };
+
+// Export for use in player filtering
+export const IMAGE_SUBTITLE_CODECS = IMAGE_BASED_FORMATS;