lzc-video-player 0.0.0

package/src/components/Video/useSource.ts

@@ -0,0 +1,1431 @@
+import type {
+  Subtitle,
+  VideoInfo,
+  VideoQualityLevel,
+  VideoResolution,
+} from "@/model"
+import { ref } from "vue"
+import throttle from "lodash.throttle"
+import { getFileLinkWithDefault } from "@/use/useVideoFrame"
+import { LzcApp } from "@/use/useSdk"
+import { getSubtitleInfo } from "./getSubtitleInfo"
+import { join } from "path-browserify"
+import type { LzcPlayer, SourceObject } from "./player"
+import { subtitleDB } from "@/use/useSubtitle"
+import { useHistoryInfo } from "@/stores/playlist"
+import { isSourceEqual } from "@/use/useUtils"
+import {
+  fetchOriginPlaybackDecision,
+  fetchOriginHlsLevels,
+  type OriginPlaybackDecision,
+} from "./directPlay"
+
+// 后端定义好的参数
+const previewConfig = {
+  width: 120,
+  height: 96,
+  interval: 5, // 缩略图的时间间隔
+  tile: 4, // 缩略图的个数 16, tile=4x4
+  len: 16,
+}
+
+const LEGACY_SUBTITLE_TYPE_PARAM = "sub_type"
+const LEGACY_SUBTITLE_INDEX_PARAM = "subtitle"
+const LEGACY_SUBTITLE_CUSTOM_PARAM = "custom_sub"
+
+export function useVideoPreview(baseUrlPrefix: string, player: LzcPlayer) {
+  const cache: Map<string, HTMLImageElement> = new Map()
+  let loading: boolean = false
+
+  function currentPage() {
+    return Math.trunc(
+      player.currentTime()! / (previewConfig.len * previewConfig.interval),
+    )
+  }
+
+  function genPreviewUrl(info: VideoInfo, page = 0): string | undefined {
+    const pageStart = page * previewConfig.len * previewConfig.interval
+    const filename = info.path
+    if (filename == undefined) {
+      return
+    }
+    const uri = `${baseUrlPrefix}/screenshot/${encodeURIComponent(
+      filename,
+    )}?start=${pageStart}`
+    uri.replace(/\/\//, "/")
+    return uri
+  }
+
+  function _loadPreview(page: number): any {
+    if (loading) {
+      return
+    }
+    const totalPage = Math.ceil(
+      player.duration()! / (previewConfig.len * previewConfig.interval),
+    )
+    if (page > totalPage) {
+      return
+    }
+
+    const info = player.currentVideoInfo()
+    if (!info) {
+      return
+    }
+    if (!info.fromNetdisk && !info.path) {
+      return
+    }
+
+    const url = genPreviewUrl(info, page)
+    if (url == undefined) {
+      return
+    }
+
+    if (cache.has(url)) {
+      return _loadPreview(page + 1)
+    }
+
+    const img = new Image()
+    img.src = url
+
+    loading = true
+    img.onload = () => {
+      cache.set(url, img)
+      loading = false
+    }
+  }
+
+  function loadPreview() {
+    const page = currentPage()
+    return _loadPreview(page)
+  }
+
+  function getPreview() {
+    const page = currentPage()
+    const info = player.currentVideoInfo()
+    if (!info) {
+      return
+    }
+    if (!info.fromNetdisk && !info.path) {
+      return
+    }
+    const url = genPreviewUrl(info, page)
+    if (url == undefined) {
+      return
+    }
+    return cache.get(url)
+  }
+
+  return { loadPreview, getPreview, currentPage }
+}
+
+interface UseSourceInternalOptions {
+  externalPrevNextControl?: {
+    prev?: boolean
+    next?: boolean
+  }
+}
+
+export function useSource(
+  player: LzcPlayer,
+  options: UseSourceInternalOptions = {},
+) {
+  const isDirectPlayerMode = player.options_.playMode === "direct"
+  const store = useHistoryInfo()
+  const externalPrevNextControl = {
+    prev: options.externalPrevNextControl?.prev === true,
+    next: options.externalPrevNextControl?.next === true,
+  }
+  let openVideoSeq = 0
+  let loadedMetadataSeekSeq = 0
+  const safePlay = () => {
+    void Promise.resolve(player.play()).catch((err: any) => {
+      if (err?.name !== "AbortError") {
+        console.error("play failed after source update", err)
+      }
+    })
+  }
+  const invalidateLoadedMetadataSeek = () => {
+    loadedMetadataSeekSeq += 1
+  }
+  const isSameVideo = (a?: VideoInfo | null, b?: VideoInfo | null) => {
+    if (!a || !b) return false
+    if (a.path && b.path) {
+      return a.path === b.path
+    }
+    try {
+      return isSourceEqual(a.sourceUrl, b)
+    } catch {
+      return a.sourceUrl === b.sourceUrl
+    }
+  }
+  const mergeHistoryInfo = (
+    incoming: VideoInfo,
+    history?: VideoInfo | null,
+  ): VideoInfo => {
+    if (!history) {
+      return incoming
+    }
+    return {
+      ...history,
+      ...incoming,
+      _id: history._id,
+      updateTime: history.updateTime,
+      currentTime:
+        typeof incoming.currentTime === "number" && incoming.currentTime > 0
+          ? incoming.currentTime
+          : history.currentTime,
+      duration:
+        typeof incoming.duration === "number" && incoming.duration > 0
+          ? incoming.duration
+          : history.duration,
+      invalid: history.invalid,
+      subtitles: history.subtitles ?? incoming.subtitles,
+      beforeHiddenSubtitle:
+        history.beforeHiddenSubtitle ?? incoming.beforeHiddenSubtitle,
+      path: incoming.path || history.path,
+      fromNetdisk: incoming.fromNetdisk || history.fromNetdisk,
+      name: incoming.name || history.name,
+    }
+  }
+  const scheduleLoadedMetadataSeek = (
+    seekTo: number,
+    expectedInfo?: VideoInfo | null,
+    afterLoadedMetadata?: () => void,
+  ) => {
+    invalidateLoadedMetadataSeek()
+    const seq = loadedMetadataSeekSeq
+    player.one("loadedmetadata", () => {
+      if (seq !== loadedMetadataSeekSeq) return
+      if (expectedInfo) {
+        const currentInfo = player.currentVideoInfo?.()
+        if (!isSameVideo(currentInfo, expectedInfo)) {
+          return
+        }
+      }
+      player.currentTime(seekTo)
+      afterLoadedMetadata?.()
+    })
+  }
+  const normalizeQualityToMaster = (url: string) => {
+    if (!/\.m3u8(\?|$)/i.test(url)) return url
+    const [base, search] = url.split("?")
+    const replaced = base.replace(/\/quality-[^/]*\.m3u8$/i, "/master.m3u8")
+    if (!search) return replaced
+    return `${replaced}?${search}`
+  }
+
+  let videoDisplayName: string = ""
+  let autoSwitchResolution: boolean = false
+  let subtitleLoading = false
+  let baseUrlPrefix = "/_lzc/media"
+  if (player.options_.mediaPrefix) {
+    if (player.options_.mediaPrefix.endsWith("/")) {
+      baseUrlPrefix = player.options_.mediaPrefix.substring(
+        0,
+        player.options_.mediaPrefix.length - 1,
+      )
+    } else {
+      baseUrlPrefix = player.options_.mediaPrefix
+    }
+  }
+
+  const previewImageCache = useVideoPreview(baseUrlPrefix, player)
+  const qualityLevels = player.qualityLevels()
+
+  function autoEnableAndDisableResolution(
+    index?: number,
+    options: { trigger?: boolean } = {},
+  ) {
+    if (index !== undefined) {
+      autoSwitchResolution = false
+    } else {
+      // autoSwitchResolution = true;
+      return
+    }
+    for (let i = 0; i < qualityLevels.levels_.length; i++) {
+      if (autoSwitchResolution) {
+        qualityLevels.levels_[i].enabled = true
+      } else {
+        if (i == index) {
+          qualityLevels.levels_[i].enabled = true
+        } else {
+          qualityLevels.levels_[i].enabled = false
+        }
+      }
+    }
+    if (options.trigger !== false) {
+      qualityLevels.trigger({ type: "change", selectedIndex: index })
+    }
+  }
+
+  // 注意 player 中的函数重新保存到其他变量上需要 bind 函数的上下文
+  function init(info: VideoInfo) {
+    getFileLinkWithDefault(info._id).then((link) => {
+      player.poster(link)
+    })
+    const normalizedSrc =
+      isDirectPlayerMode
+        ? (info.resolvedSourceUrl || "").trim() ||
+          normalizeQualityToMaster(info.sourceUrl)
+        : (info.resolvedSourceUrl || "").trim() ||
+          (originDecision?.originMode === "direct"
+            ? originDecision.originDirectUrl
+            : originDecision?.originHlsUrl) ||
+          normalizeQualityToMaster(info.sourceUrl)
+    currentTransportMode = /\.m3u8(\?|$)/i.test(normalizedSrc)
+      ? "hls"
+      : "direct"
+    restorePlaybackRateAfterSourceReload()
+    player.src(normalizedSrc)
+
+    store.ready.then(() => {
+      const currentIndex = store.infos.findIndex((i: VideoInfo) =>
+        isSourceEqual(i.sourceUrl, info),
+      )
+      const total = store.infos.length
+      if (!externalPrevNextControl.prev) {
+        player.enablePrev(currentIndex !== 0)
+      }
+      if (!externalPrevNextControl.next) {
+        player.enableNext(currentIndex !== total - 1)
+      }
+    })
+
+    if (info.name) {
+      videoDisplayName = info.name
+    }
+    if (info.fromNetdisk && !LzcApp.isTvOsWebShell()) {
+      player.on(
+        "timeupdate",
+        throttle(() => {
+          // HaveEnoughData = 4, Idle = 1, Loading = 2
+          if (player.networkState() == 1 || player.networkState() == 2) {
+            previewImageCache.loadPreview()
+          }
+        }, 2000),
+      )
+    }
+  }
+
+  function videoSrc() {
+    const src = player.currentSrc()
+    return src.split("?")[0]
+  }
+
+  function videoName() {
+    if (videoDisplayName !== "") {
+      return videoDisplayName
+    }
+    const currSrc = videoSrc()
+    return currSrc?.split("/").slice(-1)[0]
+  }
+
+  function currentPreview() {
+    const image = previewImageCache.getPreview()
+    if (!image) {
+      return
+    }
+    const page = previewImageCache.currentPage()
+    return {
+      ...previewConfig,
+      page,
+      image,
+    }
+  }
+
+  const defaultAvaliableSub = ref<Subtitle | undefined>()
+  let subtitleHidden = false
+  let lastVisibleSubtitle: Subtitle | undefined = undefined
+  let netdiskPath: string | undefined = undefined
+  let resolvedPlayableSource: string | undefined = undefined
+  let subtitleSourceOverride: string | undefined = undefined
+  let resolutionDisplayLock: VideoResolution | null = null
+  let resolutionDisplayLockTimer: ReturnType<typeof setTimeout> | null = null
+  let originDecision: OriginPlaybackDecision | undefined = undefined
+  let currentTransportMode: "hls" | "direct" = "hls"
+  let logicalResolutionLevels: VideoQualityLevel[] = []
+  let manifestResolutionLevels: VideoQualityLevel[] = []
+  let directOriginFallbackPending = false
+
+  const setSubtitleLoading = (value: boolean) => {
+    if (subtitleLoading === value) {
+      return
+    }
+    subtitleLoading = value
+    player.trigger("subtitleloadingchange")
+  }
+
+  player.isSubtitleLoading = () => subtitleLoading
+  player.logicalQualityLevels = () => logicalResolutionLevels
+
+  const refreshLogicalResolutionLevels = () => {
+    if (isDirectPlayerMode) {
+      logicalResolutionLevels = []
+      return
+    }
+    const rawLevels =
+      qualityLevels.levels_.length > 0 ? qualityLevels.levels_ : manifestResolutionLevels
+
+    const hlsLevels: VideoQualityLevel[] = [...rawLevels]
+      .map((level) => ({
+        ...level,
+        transport: "hls" as "hls" | "direct",
+      }))
+      .sort((a, b) => {
+        if (b.height === a.height) {
+          return b.bitrate - a.bitrate
+        }
+        return b.height - a.height
+      })
+
+    if (originDecision) {
+      const hasOrigin = hlsLevels.some((level) => level.label === "origin")
+      if (!hasOrigin) {
+        hlsLevels.unshift({
+          id: "origin",
+          label: "origin",
+          height: originDecision.mediaSource.height || 0,
+          width: originDecision.mediaSource.width || 0,
+          bitrate: originDecision.mediaSource.bitrate || 0,
+          transport: originDecision.originMode,
+        })
+      } else {
+        const originLevel = hlsLevels.find((level) => level.label === "origin")
+        if (originLevel) {
+          originLevel.transport = originDecision.originMode
+        }
+      }
+    }
+    logicalResolutionLevels = hlsLevels
+  }
+
+  const syncManifestResolutionLevels = (levels: VideoQualityLevel[]) => {
+    manifestResolutionLevels = levels.map((level, index) => ({
+      ...level,
+      id: `manifest-${level.label || "level"}-${level.height}-${level.width}-${level.bitrate}-${index}`,
+      enabled: level.enabled ?? true,
+    }))
+    refreshLogicalResolutionLevels()
+  }
+
+  const clearResolutionDisplayLockTimer = () => {
+    if (resolutionDisplayLockTimer) {
+      clearTimeout(resolutionDisplayLockTimer)
+      resolutionDisplayLockTimer = null
+    }
+  }
+
+  const setResolutionDisplayLock = (snapshot?: VideoResolution) => {
+    clearResolutionDisplayLockTimer()
+    if (!snapshot) {
+      resolutionDisplayLock = null
+      return
+    }
+    resolutionDisplayLock = { ...snapshot }
+    // Fallback unlock to avoid stale lock if source reload fails unexpectedly.
+    resolutionDisplayLockTimer = setTimeout(() => {
+      resolutionDisplayLock = null
+      resolutionDisplayLockTimer = null
+    }, 8000)
+  }
+
+  const releaseResolutionDisplayLock = () => {
+    clearResolutionDisplayLockTimer()
+    resolutionDisplayLock = null
+  }
+
+  const buildSubtitleInfoUrl = (
+    path: string | undefined,
+    search = "",
+  ): string | undefined => {
+    if (!path) {
+      return undefined
+    }
+    const base = join(baseUrlPrefix, "hls", path, "subtitle-info")
+    if (!search) {
+      return base
+    }
+    return `${base}${search.startsWith("?") ? search : `?${search}`}`
+  }
+
+  const escapeRegExp = (value: string) => {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  }
+
+  const normalizeSubtitleMediaUrl = (url?: string): string | undefined => {
+    const raw = (url || "").trim()
+    if (!raw) {
+      return raw
+    }
+    if (/^(https?:)?\/\//i.test(raw) || /^(blob:|data:)/i.test(raw)) {
+      return raw
+    }
+    const mediaHlsPrefix = `${baseUrlPrefix}/hls/`
+    if (raw.startsWith(mediaHlsPrefix)) {
+      return raw
+    }
+    if (raw.startsWith("/hls/")) {
+      return `${baseUrlPrefix}${raw}`
+    }
+    if (raw.startsWith("hls/")) {
+      return `${baseUrlPrefix}/${raw}`
+    }
+    return raw
+  }
+
+  const normalizeSubtitle = (subtitle: Subtitle): Subtitle => {
+    return {
+      ...subtitle,
+      vtt_url: normalizeSubtitleMediaUrl(subtitle.vtt_url),
+      ass_url: normalizeSubtitleMediaUrl(subtitle.ass_url),
+      ass_fonts: (subtitle.ass_fonts || [])
+        .map((item) => normalizeSubtitleMediaUrl(item))
+        .filter((item): item is string => !!item),
+    }
+  }
+
+  const hasRenderableSubtitleSource = (subtitle?: Subtitle): boolean => {
+    return !!((subtitle?.vtt_url || subtitle?.ass_url || "").trim())
+  }
+
+  const isSelectableSubtitle = (subtitle?: Subtitle): subtitle is Subtitle => {
+    if (!subtitle) {
+      return false
+    }
+    return (
+      hasRenderableSubtitleSource(subtitle) ||
+      canUseLegacySubtitleProtocol(subtitle)
+    )
+  }
+
+  const canUseLegacySubtitleProtocol = (subtitle?: Subtitle): boolean => {
+    if (!subtitle) {
+      return false
+    }
+    if (hasRenderableSubtitleSource(subtitle)) {
+      return false
+    }
+    return Number.isInteger(subtitle.stream_index) && subtitle.stream_index >= 0
+  }
+
+  const getLegacySubtitleTypeValue = (subtitle: Subtitle): string => {
+    // media legacy protocol: 1 => internal, 2 => external
+    return subtitle.is_external ? "2" : "1"
+  }
+
+  const getLegacyProbeSubtitle = () => {
+    if (subtitleHidden) {
+      return lastVisibleSubtitle ?? defaultAvaliableSub.value
+    }
+    return defaultAvaliableSub.value
+  }
+
+  player.isUsingNativeSubtitleFallback = () => {
+    return canUseLegacySubtitleProtocol(getLegacyProbeSubtitle())
+  }
+
+  /**
+   * 修改字幕初始化时间，防止changeSubtitle中loadedmetadata在配置未加载前改变播放时间
+   */
+  function initSubtitles() {
+    const seq = openVideoSeq
+    const info = player.currentVideoInfo()
+    if (!info) {
+      setSubtitleLoading(false)
+      return
+    }
+    let SubtitlePath: string | undefined = undefined
+
+    if (info.subtitleInfoUrl) {
+      SubtitlePath = info.subtitleInfoUrl
+      if (info.path) {
+        netdiskPath = info.path
+        if (netdiskPath?.startsWith("/")) {
+          netdiskPath = encodeURIComponent(netdiskPath.substring(1))
+        }
+      }
+    } else if (info.path) {
+      netdiskPath = info.path
+      if (netdiskPath?.startsWith("/")) {
+        netdiskPath = encodeURIComponent(netdiskPath.substring(1))
+      }
+      SubtitlePath = buildSubtitleInfoUrl(netdiskPath)
+    } else {
+      const originPath = new URL(info.sourceUrl)
+      const url = originPath.origin + originPath.pathname
+      const searchPath = originPath.search || ""
+      const mediaHlsPrefixPattern = new RegExp(
+        `^https?:\\/\\/[^/]+${escapeRegExp(`${baseUrlPrefix}/hls`)}`,
+      )
+      netdiskPath = decodeURIComponent(url)
+        .replace(mediaHlsPrefixPattern, "")
+        .replace(/\/[^/]*\.m3u8$/, "")
+      if (netdiskPath?.startsWith("/")) {
+        netdiskPath = encodeURIComponent(netdiskPath.substring(1))
+      }
+      SubtitlePath = buildSubtitleInfoUrl(netdiskPath, searchPath)
+    }
+    const subtitleHistory = subtitleDB.findOne(netdiskPath || "")
+    const lastSelectedSubtitle = subtitleDB.findLastSelected()
+
+    player.getAvaliableSubtitles = () => []
+
+    player.currentSubtitle = () => undefined
+
+    setSubtitleLoading(true)
+
+    void getSubtitleInfo(SubtitlePath)
+      .then(async (subtitles?) => {
+        if (seq !== openVideoSeq) {
+          return
+        }
+        if (subtitles === undefined || subtitles.length === 0) {
+          console.info("No subtitles found")
+          return
+        }
+        const normalizedSubtitles = subtitles.map(normalizeSubtitle)
+
+        player.getAvaliableSubtitles = () => {
+          return normalizedSubtitles
+        }
+
+        const fallbackSubtitle =
+          normalizedSubtitles.find((i) => isSelectableSubtitle(i)) ??
+          normalizedSubtitles[0]
+        if (!fallbackSubtitle) {
+          return
+        }
+        const [subtitleHistoryResult, lastSelectedSubtitleResult] =
+          await Promise.all([subtitleHistory, lastSelectedSubtitle])
+        if (seq !== openVideoSeq) {
+          return
+        }
+
+        const subtitleByHistory = normalizedSubtitles.find(
+          (i) =>
+            i.name === subtitleHistoryResult?.name &&
+            i.stream_index === subtitleHistoryResult?.index,
+        )
+        const subtitleByLastName = subtitleByHistory
+          ? undefined
+          : normalizedSubtitles.find(
+              (i) =>
+                isSelectableSubtitle(i) &&
+                i.name === lastSelectedSubtitleResult?.name,
+            )
+        const subtitleByLastType =
+          subtitleByHistory || subtitleByLastName
+            ? undefined
+            : typeof lastSelectedSubtitleResult?.is_external === "boolean"
+              ? normalizedSubtitles.find(
+                  (i) =>
+                    isSelectableSubtitle(i) &&
+                    i.is_external === lastSelectedSubtitleResult.is_external,
+                )
+              : undefined
+
+        const defaultSubtitle =
+          subtitleByHistory ??
+          subtitleByLastName ??
+          subtitleByLastType ??
+          fallbackSubtitle
+        defaultAvaliableSub.value = defaultSubtitle
+        lastVisibleSubtitle = defaultSubtitle
+
+        player.currentSubtitle = () => {
+          const current = defaultAvaliableSub.value
+          if (!current) return undefined
+          return {
+            name: current.name,
+            language: current.language,
+            stream_index: current.stream_index,
+            codec_name: current.codec_name,
+            is_external: current.is_external,
+            path: current.path,
+            vtt_url: normalizeSubtitleMediaUrl(current.vtt_url),
+            track_id: current.track_id,
+            ass_url: normalizeSubtitleMediaUrl(current.ass_url),
+            ass_fonts: (current.ass_fonts || [])
+              .map((item) => normalizeSubtitleMediaUrl(item))
+              .filter((item): item is string => !!item),
+            ass_renderable: current.ass_renderable,
+            ass_unavailable_reason: current.ass_unavailable_reason,
+          }
+        }
+
+        setSubtitleLoading(false)
+        player.trigger("subtitleReady")
+
+        if (defaultAvaliableSub.value && !player.isSubtitleHidden?.()) {
+          player.changeSubtitle(defaultAvaliableSub.value)
+        }
+      })
+      .finally(() => {
+        if (seq !== openVideoSeq) {
+          return
+        }
+        setSubtitleLoading(false)
+      })
+  }
+
+  const _src = player.src.bind(player)
+
+  const getOriginPreferredSource = () => {
+    if (!originDecision) {
+      return undefined
+    }
+    return originDecision.originMode === "direct"
+      ? originDecision.originDirectUrl
+      : originDecision.originHlsUrl
+  }
+
+  const forceOriginFallbackToHLS = () => {
+    if (isDirectPlayerMode) {
+      return
+    }
+    if (!originDecision) {
+      return
+    }
+    originDecision = {
+      ...originDecision,
+      originMode: "hls",
+    }
+    const current = player.currentVideoInfo?.()
+    if (current) {
+      current.playMode = "hls"
+      current.resolvedSourceUrl = originDecision.originHlsUrl
+    }
+    currentTransportMode = "hls"
+    refreshLogicalResolutionLevels()
+  }
+
+  const getCurrentPlayableSourceUrl = () => {
+    const preferred = (subtitleSourceOverride || resolvedPlayableSource || "").trim()
+    if (preferred) {
+      return preferred
+    }
+    const source = (player.currentSource?.().src || player.currentSrc() || "").trim()
+    if (source && !/^blob:/i.test(source)) {
+      return source
+    }
+    const infoSource = (player.currentVideoInfo?.()?.sourceUrl || "").trim()
+    if (infoSource) {
+      return normalizeQualityToMaster(infoSource)
+    }
+    return ""
+  }
+
+  const parseSourceUrl = (raw: string) => {
+    if (!raw) return undefined
+    try {
+      const baseHref =
+        typeof window !== "undefined"
+          ? window.location.href
+          : "http://localhost/"
+      return new URL(raw, baseHref)
+    } catch (err) {
+      console.error("Failed to parse current source url", { raw, err })
+      return undefined
+    }
+  }
+
+  const toOutputSourceUrl = (parsed: URL, raw: string) => {
+    if (/^(https?:)?\/\//i.test(raw)) {
+      return parsed.toString()
+    }
+    if (raw.startsWith("//")) {
+      return parsed.toString().replace(/^[^:]+:/, "")
+    }
+    return `${parsed.pathname}${parsed.search}${parsed.hash}`
+  }
+
+  const hasLegacySubtitleParamsInSource = () => {
+    const raw = getCurrentPlayableSourceUrl()
+    const parsed = parseSourceUrl(raw)
+    if (!parsed) {
+      return false
+    }
+    return (
+      parsed.searchParams.has(LEGACY_SUBTITLE_TYPE_PARAM) ||
+      parsed.searchParams.has(LEGACY_SUBTITLE_INDEX_PARAM) ||
+      parsed.searchParams.has(LEGACY_SUBTITLE_CUSTOM_PARAM)
+    )
+  }
+
+  const buildLegacySubtitleSwitchUrl = (
+    mode: "select" | "clear",
+    subtitle?: Subtitle,
+  ): string | undefined => {
+    const raw = getCurrentPlayableSourceUrl()
+    const parsed = parseSourceUrl(raw)
+    if (!parsed) {
+      return undefined
+    }
+
+    parsed.searchParams.delete(LEGACY_SUBTITLE_CUSTOM_PARAM)
+
+    if (mode === "select") {
+      if (!subtitle) {
+        return undefined
+      }
+      parsed.searchParams.set(
+        LEGACY_SUBTITLE_TYPE_PARAM,
+        getLegacySubtitleTypeValue(subtitle),
+      )
+      parsed.searchParams.set(
+        LEGACY_SUBTITLE_INDEX_PARAM,
+        `${subtitle.stream_index}`,
+      )
+    } else {
+      parsed.searchParams.delete(LEGACY_SUBTITLE_TYPE_PARAM)
+      parsed.searchParams.delete(LEGACY_SUBTITLE_INDEX_PARAM)
+    }
+
+    return toOutputSourceUrl(parsed, raw)
+  }
+
+  const getPreservedPlaybackRate = () => {
+    const playbackRateValue = player.playbackRate?.()
+    const preservedPlaybackRate =
+      typeof playbackRateValue === "number" && Number.isFinite(playbackRateValue)
+        ? playbackRateValue
+        : undefined
+    if (preservedPlaybackRate == null || preservedPlaybackRate <= 0) {
+      return undefined
+    }
+    return preservedPlaybackRate
+  }
+
+  const restorePlaybackRateAfterSourceReload = () => {
+    const preservedPlaybackRate = getPreservedPlaybackRate()
+    if (preservedPlaybackRate === undefined || preservedPlaybackRate === 1) {
+      return
+    }
+    player.one("loadedmetadata", () => {
+      player.playbackRate?.(preservedPlaybackRate)
+    })
+  }
+
+  const reloadSourceWithSeek = (nextSrc: string) => {
+    const seekTo = (player.duration() !== Infinity && player.currentTime()) || 0
+    const expectedInfo = player.currentVideoInfo?.()
+    scheduleLoadedMetadataSeek(seekTo, expectedInfo)
+    restorePlaybackRateAfterSourceReload()
+    resolvedPlayableSource = nextSrc
+    subtitleSourceOverride = nextSrc
+    currentTransportMode = /\.m3u8(\?|$)/i.test(nextSrc) ? "hls" : "direct"
+    _src({
+      src: nextSrc,
+      type: currentTransportMode === "hls" ? "application/x-mpegURL" : "",
+    })
+    safePlay()
+  }
+
+  const reloadSourceWithSeekAndResolution = (
+    nextSrc: string,
+    level: VideoQualityLevel,
+  ) => {
+    const seekTo = (player.duration() !== Infinity && player.currentTime()) || 0
+    const expectedInfo = player.currentVideoInfo?.()
+    scheduleLoadedMetadataSeek(seekTo, expectedInfo, () => {
+      const index = findCurrentQualityLevelIndex(level)
+      if (index >= 0) {
+        autoEnableAndDisableResolution(index, { trigger: false })
+        baseChangeResolution(qualityLevels.levels_[index] || level)
+      } else {
+        baseChangeResolution(level)
+      }
+      releaseResolutionDisplayLock()
+    })
+    restorePlaybackRateAfterSourceReload()
+    resolvedPlayableSource = nextSrc
+    subtitleSourceOverride = nextSrc
+    currentTransportMode = /\.m3u8(\?|$)/i.test(nextSrc) ? "hls" : "direct"
+    _src({
+      src: nextSrc,
+      type: currentTransportMode === "hls" ? "application/x-mpegURL" : "",
+    })
+    if (currentTransportMode === "hls") {
+      baseChangeResolution(level)
+    }
+    safePlay()
+  }
+
+  const applyLegacySubtitleSelection = (subtitle: Subtitle) => {
+    if (!canUseLegacySubtitleProtocol(subtitle)) {
+      return false
+    }
+    const nextSrc = buildLegacySubtitleSwitchUrl("select", subtitle)
+    if (!nextSrc) {
+      return false
+    }
+    const currentSrc = getCurrentPlayableSourceUrl()
+    if (currentSrc === nextSrc) {
+      return true
+    }
+    reloadSourceWithSeek(nextSrc)
+    return true
+  }
+
+  const clearLegacySubtitleSelection = () => {
+    if (
+      !canUseLegacySubtitleProtocol(getLegacyProbeSubtitle()) &&
+      !hasLegacySubtitleParamsInSource()
+    ) {
+      return false
+    }
+    const nextSrc = buildLegacySubtitleSwitchUrl("clear")
+    if (!nextSrc) {
+      return false
+    }
+    const currentSrc = getCurrentPlayableSourceUrl()
+    if (currentSrc === nextSrc) {
+      return true
+    }
+    reloadSourceWithSeek(nextSrc)
+    return true
+  }
+
+  player.changeSubtitle = (sub: Subtitle | number) => {
+    if (isDirectPlayerMode) {
+      return
+    }
+    const subs = player.getAvaliableSubtitles()
+    if (subs === undefined) {
+      return
+    }
+    let selectedSubtitle: Subtitle | undefined
+    const updateSelection = (sub: Subtitle) => {
+      if (netdiskPath) {
+        subtitleDB.update(netdiskPath, {
+          name: sub.name,
+          index: sub.stream_index,
+        })
+      }
+      subtitleDB.updateLastSelected({
+        name: sub.name,
+        is_external: sub.is_external,
+      })
+      defaultAvaliableSub.value = sub
+    }
+
+    if (typeof sub == "number") {
+      if (sub >= subs.length) {
+        return
+      }
+      selectedSubtitle = subs[sub]
+      if (selectedSubtitle) {
+        updateSelection(selectedSubtitle)
+      }
+    } else {
+      const canonicalSubtitle = subs.find(
+        (item) =>
+          item.name === sub.name && item.stream_index === sub.stream_index,
+      )
+      if (canonicalSubtitle) {
+        selectedSubtitle = canonicalSubtitle
+        updateSelection(canonicalSubtitle)
+      }
+    }
+    if (selectedSubtitle) {
+      subtitleHidden = false
+      lastVisibleSubtitle = selectedSubtitle
+      if (!applyLegacySubtitleSelection(selectedSubtitle)) {
+        if (hasRenderableSubtitleSource(selectedSubtitle)) {
+          clearLegacySubtitleSelection()
+        }
+      }
+    }
+    player.trigger("subtitlechange")
+  }
+
+  player.clearSubtitle = () => {
+    if (isDirectPlayerMode) {
+      return
+    }
+    if (netdiskPath) {
+      subtitleDB.update(netdiskPath, {})
+    }
+    clearLegacySubtitleSelection()
+    player.trigger("subtitlechange")
+  }
+
+  player.isSubtitleHidden = () => subtitleHidden
+
+  player.setSubtitleHidden = (value: boolean) => {
+    if (isDirectPlayerMode) return
+    if (subtitleHidden === value) return
+    subtitleHidden = value
+    if (value) {
+      const current = player.currentSubtitle?.()
+      if (current) {
+        lastVisibleSubtitle = current
+      }
+      player.clearSubtitle()
+    }
+    player.trigger("subtitlevisibilitychange")
+  }
+
+  player.toggleSubtitleVisibility = () => {
+    if (isDirectPlayerMode) return
+    if (subtitleHidden) {
+      subtitleHidden = false
+      player.trigger("subtitlevisibilitychange")
+      const next = lastVisibleSubtitle ?? defaultAvaliableSub.value
+      if (next) {
+        player.changeSubtitle(next)
+      }
+      return
+    }
+    player.setSubtitleHidden(true)
+  }
+
+  function src2(): string
+  function src2(sources: string | SourceObject | SourceObject[]): void
+  function src2(sources?: any): any {
+    if (!sources || sources == null || sources == undefined) {
+      return player.currentSrc()
+    }
+
+    const format = (url: string, stype = "") => {
+      const info = player.currentVideoInfo()
+      if (!info) {
+        return {
+          src: normalizeQualityToMaster(url),
+          type: stype,
+        }
+      }
+      if (
+        isDirectPlayerMode ||
+        (info.fromNetdisk && info.path) ||
+        (url.startsWith("/") && !url.startsWith(baseUrlPrefix)) // 兼容代码
+      ) {
+        const resolved = (
+          isDirectPlayerMode ? info.sourceUrl : info.resolvedSourceUrl || ""
+        ).trim()
+        if (resolved) {
+          return {
+            src: resolved,
+            type: /\.m3u8(\?|$)/i.test(resolved) ? "application/x-mpegURL" : "",
+          }
+        }
+        let path = info.path
+        if (path?.startsWith("/")) {
+          path = path.substring(1)
+        }
+        if (path != null) {
+          path = encodeURIComponent(path)
+        }
+        return {
+          src: `${baseUrlPrefix}/hls/${path || url}/master.m3u8`.replace(
+            /\/\//,
+            "/",
+          ),
+          type: "application/x-mpegURL",
+        }
+      } else {
+        return {
+          src: normalizeQualityToMaster(url),
+          type: stype,
+        }
+      }
+    }
+
+    let newSources: SourceObject[] = []
+    if (Array.isArray(sources)) {
+      newSources = sources.map((s: SourceObject) => {
+        return format(s.src, s.type)
+      })
+    } else if (typeof sources == "string") {
+      newSources.push(format(sources, ""))
+    } else {
+      newSources.push(format(sources.src, sources.type))
+    }
+    if (newSources[0]?.src) {
+      resolvedPlayableSource = `${newSources[0].src}`.trim()
+      currentTransportMode = /\.m3u8(\?|$)/i.test(resolvedPlayableSource)
+        ? "hls"
+        : "direct"
+    }
+    _src(newSources)
+  }
+  player.src = src2
+
+  player.currentResolution = () => {
+    if (resolutionDisplayLock) {
+      return resolutionDisplayLock
+    }
+    if (currentTransportMode === "direct" && originDecision) {
+      return {
+        id: "origin",
+        res: Math.min(
+          originDecision.mediaSource.height || 0,
+          originDecision.mediaSource.width || 0,
+        ),
+        auto: false,
+        origin: true,
+        width: originDecision.mediaSource.width || 0,
+        height: originDecision.mediaSource.height || 0,
+      }
+    }
+    const quality = player.qualityLevels()
+    const idx = quality.selectedIndex_
+    if (idx === -1) {
+      const en = quality.levels_.find((level) => level.enabled === true)
+      if (!en) {
+        return undefined
+      }
+      return {
+        id: en.id,
+        res: Math.min(en.height, en.width),
+        auto: autoSwitchResolution,
+        origin: en.label === "origin",
+        width: en.width,
+        height: en.height,
+      }
+    }
+    const res = quality.levels_[idx]
+    if (res) {
+      return {
+        id: res.id,
+        res: Math.min(res.height, res.width),
+        auto: autoSwitchResolution,
+        origin: res.label === "origin",
+        width: res.width,
+        height: res.height,
+      }
+    }
+    const fallback = quality.levels_.find((level) => level.enabled === true)
+    if (!fallback) {
+      return undefined
+    }
+    return {
+      id: fallback.id,
+      res: Math.min(fallback.height, fallback.width),
+      auto: autoSwitchResolution,
+      origin: fallback.label === "origin",
+      width: fallback.width,
+      height: fallback.height,
+    }
+  }
+
+  const baseChangeResolution = player.changeResolution.bind(player)
+
+  const findCurrentQualityLevelIndex = (level: VideoQualityLevel) => {
+    const levels = player.qualityLevels().levels_
+    if (level.label === "origin" || level.id === "origin") {
+      const originIndex = levels.findIndex((item) => item.label === "origin")
+      if (originIndex >= 0) {
+        return originIndex
+      }
+    }
+
+    const exactMatchIndex = levels.findIndex(
+      (l: VideoQualityLevel) =>
+        l.label === level.label &&
+        l.height == level.height &&
+        l.width == level.width &&
+        l.bitrate == level.bitrate,
+    )
+    if (exactMatchIndex >= 0) {
+      return exactMatchIndex
+    }
+
+    const shapeMatchIndex = levels.findIndex(
+      (l: VideoQualityLevel) =>
+        l.label === level.label &&
+        l.height == level.height &&
+        l.width == level.width,
+    )
+    if (shapeMatchIndex >= 0) {
+      return shapeMatchIndex
+    }
+
+    const bitrateMatchIndex = levels.findIndex(
+      (l: VideoQualityLevel) =>
+        l.height == level.height &&
+        l.width == level.width &&
+        l.bitrate == level.bitrate,
+    )
+    if (bitrateMatchIndex >= 0) {
+      return bitrateMatchIndex
+    }
+
+    return levels.findIndex((l: VideoQualityLevel) => l.id == level.id)
+  }
+
+  if (autoSwitchResolution == false) {
+    qualityLevels.on("addqualitylevel", (event: any) => {
+      const level = event.qualityLevel
+      if (Math.min(level.height, level.width) > 720) {
+        level.enabled = false
+      } else {
+        level.enabled = true
+      }
+
+      const selectedIndex = qualityLevels.levels_.findIndex(
+        (l) => l.enabled === true,
+      )
+      qualityLevels.selectedIndex_ = selectedIndex
+      if (selectedIndex !== -1) {
+        const selectedLevel = qualityLevels.levels_[selectedIndex]
+        if (selectedLevel) {
+          baseChangeResolution(selectedLevel)
+        }
+      }
+      refreshLogicalResolutionLevels()
+    })
+  }
+  qualityLevels.on("change", () => {
+    refreshLogicalResolutionLevels()
+  })
+  player.supportResolution = () => {
+    if (isDirectPlayerMode) {
+      return []
+    }
+    refreshLogicalResolutionLevels()
+    let arr: VideoQualityLevel[] = autoSwitchResolution
+      ? [
+          ...logicalResolutionLevels,
+          { id: "auto", label: "auto", height: 0, width: 0, bitrate: 0 },
+        ]
+      : [...logicalResolutionLevels]
+    arr.sort((a, b) => {
+      if (b.height == a.height) {
+        return b.bitrate - a.bitrate
+      }
+      return b.height - a.height
+    })
+    if (arr.length === 0) {
+      arr = [
+        {
+          id: "auto",
+          label: "auto",
+          height: 0,
+          width: 0,
+          bitrate: 0,
+        },
+      ]
+    }
+    return arr
+  }
+
+  player.changeResolution = function (level: VideoQualityLevel) {
+    if (isDirectPlayerMode) {
+      return
+    }
+    if (level.id == "auto") {
+      autoSwitchResolution = true
+      baseChangeResolution(level)
+      return
+    } else if (level.label === "origin" || level.id === "origin") {
+      autoSwitchResolution = false
+      const originSrc = getOriginPreferredSource()
+      if (originSrc && originDecision?.originMode === "direct") {
+        setResolutionDisplayLock({
+          id: "origin",
+          res: Math.min(level.height, level.width),
+          auto: false,
+          origin: true,
+          width: level.width,
+          height: level.height,
+        })
+        reloadSourceWithSeek(originSrc)
+        return
+      }
+
+      const originIndex = findCurrentQualityLevelIndex(level)
+      if (originIndex >= 0) {
+        autoEnableAndDisableResolution(originIndex, { trigger: false })
+        baseChangeResolution(qualityLevels.levels_[originIndex] || level)
+        releaseResolutionDisplayLock()
+        return
+      }
+
+      if (originSrc) {
+        setResolutionDisplayLock({
+          id: "origin",
+          res: Math.min(level.height, level.width),
+          auto: false,
+          origin: true,
+          width: level.width,
+          height: level.height,
+        })
+        reloadSourceWithSeekAndResolution(originSrc, level)
+        return
+      }
+    } else {
+      autoSwitchResolution = false
+      const index = findCurrentQualityLevelIndex(level)
+      if (currentTransportMode === "direct" && originDecision?.originHlsUrl) {
+        setResolutionDisplayLock({
+          id: level.id,
+          res: Math.min(level.height, level.width),
+          auto: false,
+          origin: false,
+          width: level.width,
+          height: level.height,
+        })
+        reloadSourceWithSeekAndResolution(originDecision.originHlsUrl, level)
+        return
+      }
+      autoEnableAndDisableResolution(index, { trigger: false })
+      baseChangeResolution(level)
+    }
+  }
+
+  player.on("error", () => {
+    if (isDirectPlayerMode) {
+      return
+    }
+    const currentResolution = player.currentResolution()
+    if (
+      currentTransportMode === "direct" &&
+      currentResolution?.origin &&
+      originDecision?.originHlsUrl &&
+      !directOriginFallbackPending
+    ) {
+      directOriginFallbackPending = true
+      forceOriginFallbackToHLS()
+      reloadSourceWithSeekAndResolution(originDecision.originHlsUrl, {
+        id: "origin",
+        label: "origin",
+        height: originDecision.mediaSource.height || 0,
+        width: originDecision.mediaSource.width || 0,
+        bitrate: originDecision.mediaSource.bitrate || 0,
+      })
+      setTimeout(() => {
+        directOriginFallbackPending = false
+      }, 0)
+    }
+  })
+  // player 加载视频唯一的入口
+  player.on("openVideo", async (e: any) => {
+    openVideoSeq += 1
+    const seq = openVideoSeq
+    invalidateLoadedMetadataSeek()
+    let info = e.info as VideoInfo
+
+    subtitleHidden = false
+    lastVisibleSubtitle = undefined
+    defaultAvaliableSub.value = undefined
+    netdiskPath = undefined
+    resolvedPlayableSource = undefined
+    subtitleSourceOverride = undefined
+    originDecision = undefined
+    currentTransportMode = "direct"
+    logicalResolutionLevels = []
+    manifestResolutionLevels = []
+    directOriginFallbackPending = false
+    player.getAvaliableSubtitles = () => []
+    player.currentSubtitle = () => undefined
+    setSubtitleLoading(false)
+    releaseResolutionDisplayLock()
+
+    if (info.requestHistory) {
+      await store.ready
+      const result = store.getHistoryInfo(info.sourceUrl)
+      if (result) {
+        info = mergeHistoryInfo(info, result)
+      }
+    }
+    videoDisplayName = info.name
+
+    player.currentVideoInfo = () => {
+      return info
+    }
+
+    if (!player.isCastMode()) {
+      if (isDirectPlayerMode) {
+        info.playMode = "direct"
+        info.originDirectUrl = (info.sourceUrl || "").trim()
+        info.resolvedSourceUrl = info.originDirectUrl
+      } else if (info.fromNetdisk && info.path) {
+        try {
+          originDecision = await fetchOriginPlaybackDecision(
+            info,
+            player.options_.mediaPrefix,
+          )
+          if (originDecision) {
+            info.playMode = originDecision.originMode
+            info.resolvedSourceUrl =
+              originDecision.originMode === "direct"
+                ? originDecision.originDirectUrl
+                : originDecision.originHlsUrl
+            info.originDirectUrl = originDecision.originDirectUrl
+            info.originHlsUrl = originDecision.originHlsUrl
+            info.subtitleInfoUrl = originDecision.subtitleInfoUrl
+            try {
+              const manifestLevels = await fetchOriginHlsLevels(
+                originDecision.originHlsUrl,
+              )
+              if (seq === openVideoSeq) {
+                syncManifestResolutionLevels(manifestLevels)
+              }
+            } catch (err) {
+              console.error("Failed to load origin hls levels", err)
+            }
+          }
+        } catch (err) {
+          console.error("Failed to resolve origin playback decision", err)
+        }
+      }
+      init(info)
+      refreshLogicalResolutionLevels()
+
+      player.isNetdiskSource = () => !!info.fromNetdisk
+
+      if (info.duration - info.currentTime >= 3) {
+        player.one("canplay", function () {
+          if (seq !== openVideoSeq) return
+          player.currentTime(info.currentTime)
+          if (!isDirectPlayerMode) {
+            initSubtitles()
+          }
+          player.currentVideoInfo = () => {
+            return {
+              ...info,
+              duration: player.duration() ?? info.duration,
+              currentTime: player.currentTime() ?? info.currentTime,
+              name: player.currentVideoName() ?? info.name,
+            }
+          }
+        })
+      } else {
+        player.one("canplay", () => {
+          if (seq !== openVideoSeq) return
+          if (!isDirectPlayerMode) {
+            initSubtitles()
+          }
+          player.currentVideoInfo = () => {
+            return {
+              ...info,
+              duration: player.duration() ?? info.duration,
+              currentTime: player.currentTime() ?? info.currentTime,
+              name: player.currentVideoName() ?? info.name,
+            }
+          }
+        })
+      }
+    }
+  })
+
+  player.currentVideoName = videoName
+  player.currentPreview = currentPreview
+  player.isCastMode = function () {
+    return player.currentType() === "video/lzc-cast"
+  }
+  player.reloadSource = function (index?: number) {
+    const seekTo = (player.duration() !== Infinity && player.currentTime()) || 0
+    const expectedInfo = player.currentVideoInfo?.()
+    scheduleLoadedMetadataSeek(seekTo, expectedInfo)
+    restorePlaybackRateAfterSourceReload()
+    player.one("loadedmetadata", function () {
+      if (index != undefined) {
+        autoEnableAndDisableResolution(index)
+      }
+    })
+    player.src(player.currentSource())
+    safePlay()
+  }
+}