lzc-video-player 0.0.0

package/src/components/Video/directPlay.ts

@@ -0,0 +1,345 @@
+import type { VideoInfo, VideoQualityLevel } from "@/model"
+
+export interface DirectPlayProfile {
+  Container: string
+  Type: string
+  VideoCodec?: string
+  AudioCodec?: string
+}
+
+export interface CodecProfileCondition {
+  Condition: string
+  Property: string
+  Value: string
+}
+
+export interface CodecProfile {
+  Type: string
+  Codec?: string
+  Conditions?: CodecProfileCondition[]
+}
+
+export interface DeviceProfile {
+  Name: string
+  DirectPlayProfiles: DirectPlayProfile[]
+  CodecProfiles: CodecProfile[]
+  MaxStreamingBitrate?: number
+  MaxStaticBitrate?: number
+}
+
+export interface OriginPlaybackDecision {
+  originMode: "direct" | "hls"
+  originDirectUrl: string
+  originHlsUrl: string
+  subtitleInfoUrl: string
+  reasons: string[]
+  mediaSource: {
+    container?: string
+    videoCodec?: string
+    audioCodec?: string
+    bitrate?: number
+    width?: number
+    height?: number
+    fps?: number
+  }
+}
+
+function canPlayType(type: string): boolean {
+  if (typeof document === "undefined") {
+    return false
+  }
+  const video = document.createElement("video")
+  return !!video.canPlayType?.(type).replace(/no/i, "")
+}
+
+function canPlayAudioType(type: string): boolean {
+  if (typeof document === "undefined") {
+    return false
+  }
+  const audio = document.createElement("audio")
+  return !!audio.canPlayType?.(type).replace(/no/i, "")
+}
+
+function detectBrowserName() {
+  const ua = typeof navigator !== "undefined" ? navigator.userAgent : ""
+  if (/Firefox/i.test(ua)) return "Firefox"
+  if (/Safari/i.test(ua) && !/Chrome|Chromium|Edg/i.test(ua)) return "Safari"
+  return "Chromium"
+}
+
+function buildVideoDirectPlayProfiles(): DirectPlayProfile[] {
+  const profiles: DirectPlayProfile[] = []
+  const mp4VideoCodecs: string[] = []
+  const webmVideoCodecs: string[] = []
+  const mp4AudioCodecs: string[] = []
+  const webmAudioCodecs: string[] = []
+
+  if (
+    canPlayType('video/mp4; codecs="avc1.42E01E, mp4a.40.2"') ||
+    canPlayType('video/mp4; codecs="avc1.64001F, mp4a.40.2"')
+  ) {
+    mp4VideoCodecs.push("h264")
+    mp4AudioCodecs.push("aac")
+  }
+  if (
+    canPlayType('video/mp4; codecs="hvc1.1.L120"') ||
+    canPlayType('video/mp4; codecs="hev1.1.L120"')
+  ) {
+    mp4VideoCodecs.push("hevc")
+  }
+  if (canPlayType('video/mp4; codecs="vp09.00.10.08, mp4a.40.2"')) {
+    mp4VideoCodecs.push("vp9")
+  }
+  if (canPlayType('video/mp4; codecs="av01.0.05M.08, mp4a.40.2"')) {
+    mp4VideoCodecs.push("av1")
+  }
+
+  if (canPlayType('video/webm; codecs="vp8, vorbis"')) {
+    webmVideoCodecs.push("vp8")
+    webmAudioCodecs.push("vorbis")
+  }
+  if (canPlayType('video/webm; codecs="vp9, opus"')) {
+    if (!webmVideoCodecs.includes("vp9")) {
+      webmVideoCodecs.push("vp9")
+    }
+    webmAudioCodecs.push("opus")
+  }
+  if (canPlayType('video/webm; codecs="av1, opus"')) {
+    if (!webmVideoCodecs.includes("av1")) {
+      webmVideoCodecs.push("av1")
+    }
+    if (!webmAudioCodecs.includes("opus")) {
+      webmAudioCodecs.push("opus")
+    }
+  }
+
+  if (canPlayAudioType('audio/mpeg; codecs="mp3"') && !mp4AudioCodecs.includes("mp3")) {
+    mp4AudioCodecs.push("mp3")
+  }
+  if (canPlayAudioType('audio/mp4; codecs="opus"') && !mp4AudioCodecs.includes("opus")) {
+    mp4AudioCodecs.push("opus")
+  }
+  if (canPlayAudioType('audio/mp4; codecs="ec-3"')) {
+    mp4AudioCodecs.push("eac3")
+  }
+  if (canPlayAudioType('audio/mp4; codecs="ac-3"')) {
+    mp4AudioCodecs.push("ac3")
+  }
+  if (canPlayAudioType('audio/webm; codecs="opus"') && !webmAudioCodecs.includes("opus")) {
+    webmAudioCodecs.push("opus")
+  }
+
+  if (mp4VideoCodecs.length) {
+    profiles.push({
+      Container: "mp4,m4v,mov",
+      Type: "Video",
+      VideoCodec: mp4VideoCodecs.join(","),
+      AudioCodec: Array.from(new Set(mp4AudioCodecs)).join(","),
+    })
+  }
+  if (webmVideoCodecs.length) {
+    profiles.push({
+      Container: "webm",
+      Type: "Video",
+      VideoCodec: Array.from(new Set(webmVideoCodecs)).join(","),
+      AudioCodec: Array.from(new Set(webmAudioCodecs)).join(","),
+    })
+  }
+  return profiles
+}
+
+export function buildDeviceProfile(): DeviceProfile {
+  const profile: DeviceProfile = {
+    Name: detectBrowserName(),
+    DirectPlayProfiles: buildVideoDirectPlayProfiles(),
+    CodecProfiles: [
+      {
+        Type: "Video",
+        Codec: "h264",
+        Conditions: [
+          { Condition: "LessThanEqual", Property: "VideoLevel", Value: "51" },
+        ],
+      },
+      {
+        Type: "Audio",
+        Codec: "aac,mp3,opus,vorbis,ac3,eac3",
+        Conditions: [
+          { Condition: "LessThanEqual", Property: "AudioChannels", Value: "8" },
+        ],
+      },
+    ],
+    MaxStreamingBitrate: 120000000,
+    MaxStaticBitrate: 120000000,
+  }
+  return profile
+}
+
+function normalizeMediaPrefix(mediaPrefix?: string): string {
+  if (!mediaPrefix) {
+    return "/_lzc/media"
+  }
+  return mediaPrefix.endsWith("/") ? mediaPrefix.slice(0, -1) : mediaPrefix
+}
+
+function buildOwnerQueryFromSourceUrl(sourceUrl?: string): string {
+  if (!sourceUrl) {
+    return ""
+  }
+  try {
+    const base =
+      typeof window !== "undefined" ? window.location.origin : "http://localhost"
+    const url = new URL(sourceUrl, base)
+    const owner = url.searchParams.get("X_LZCAPI_UID")
+    if (!owner) {
+      return ""
+    }
+    const params = new URLSearchParams()
+    params.set("X_LZCAPI_UID", owner)
+    return `?${params.toString()}`
+  } catch {
+    return ""
+  }
+}
+
+export async function fetchOriginPlaybackDecision(
+  info: VideoInfo,
+  mediaPrefix?: string,
+): Promise<OriginPlaybackDecision | undefined> {
+  if (!info.fromNetdisk || !info.path) {
+    return undefined
+  }
+  let path = info.path
+  if (path.startsWith("/")) {
+    path = path.slice(1)
+  }
+  const encodedPath = encodeURIComponent(path)
+  const prefix = normalizeMediaPrefix(mediaPrefix)
+  const url = `${prefix}/play/info/${encodedPath}${buildOwnerQueryFromSourceUrl(
+    info.sourceUrl,
+  )}`
+  const resp = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      deviceProfile: buildDeviceProfile(),
+    }),
+  })
+  if (!resp.ok) {
+    throw new Error(`origin playback info failed: ${resp.status}`)
+  }
+  return (await resp.json()) as OriginPlaybackDecision
+}
+
+function parseAttributeList(input: string): Record<string, string> {
+  const attrs: Record<string, string> = {}
+  const pattern = /([A-Z0-9-]+)=("(?:[^"\\]|\\.)*"|[^,]*)/gi
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(input))) {
+    const key = match[1]
+    const rawValue = match[2] || ""
+    attrs[key] =
+      rawValue.startsWith('"') && rawValue.endsWith('"')
+        ? rawValue.slice(1, -1)
+        : rawValue
+  }
+  return attrs
+}
+
+function parseResolutionFromUri(uri: string): { width: number; height: number } {
+  const match = uri.match(
+    /(?:^|[\/_-])(\d{3,4})[xX](\d{3,4})(?:[\/_.-]|$)|(?:quality-|res-|_)(\d{3,4})p?(?:[\/_.-]|$)/i,
+  )
+  if (!match) {
+    return { width: 0, height: 0 }
+  }
+  if (match[1] && match[2]) {
+    return {
+      width: Number(match[1]) || 0,
+      height: Number(match[2]) || 0,
+    }
+  }
+  return {
+    width: 0,
+    height: Number(match[3]) || 0,
+  }
+}
+
+function inferLevelLabel(
+  attrs: Record<string, string>,
+  height: number,
+  bitrate: number,
+): string {
+  const name = (attrs.NAME || attrs["X-STREAM-NAME"] || "").trim()
+  if (/^origin$/i.test(name)) {
+    return "origin"
+  }
+  if (name) {
+    return /p$/i.test(name) ? name : `${name}P`
+  }
+  if (height > 0) {
+    return `${height}P`
+  }
+  if (bitrate > 0) {
+    return `${Math.round(bitrate / 1000)}K`
+  }
+  return ""
+}
+
+export async function fetchOriginHlsLevels(
+  masterUrl: string,
+): Promise<VideoQualityLevel[]> {
+  const resp = await fetch(masterUrl, { method: "GET" })
+  if (!resp.ok) {
+    throw new Error(`origin hls manifest failed: ${resp.status}`)
+  }
+
+  const text = await resp.text()
+  const lines = text
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+
+  const levels: VideoQualityLevel[] = []
+  let pendingAttrs: Record<string, string> | null = null
+
+  for (const line of lines) {
+    if (line.startsWith("#EXT-X-STREAM-INF:")) {
+      pendingAttrs = parseAttributeList(line.slice("#EXT-X-STREAM-INF:".length))
+      continue
+    }
+    if (line.startsWith("#")) {
+      continue
+    }
+    if (!pendingAttrs) {
+      continue
+    }
+
+    const resolution = (pendingAttrs.RESOLUTION || "").match(/^(\d+)x(\d+)$/i)
+    const fallbackResolution = parseResolutionFromUri(line)
+    const width = resolution
+      ? Number(resolution[1]) || 0
+      : fallbackResolution.width
+    const height = resolution
+      ? Number(resolution[2]) || 0
+      : fallbackResolution.height
+    const bitrate =
+      Number(pendingAttrs["AVERAGE-BANDWIDTH"]) ||
+      Number(pendingAttrs.BANDWIDTH) ||
+      0
+    const label = inferLevelLabel(pendingAttrs, height, bitrate)
+
+    levels.push({
+      id: String(levels.length),
+      label,
+      height,
+      width,
+      bitrate,
+      enabled: true,
+    })
+    pendingAttrs = null
+  }
+
+  return levels
+}

package/src/components/Video/getSubtitleInfo.ts

@@ -0,0 +1,42 @@
+import type { Subtitle } from "@/model"
+
+type SubtitleInfoResp = {
+  len: number
+  data: Subtitle[]
+}
+
+function basename(path: string): string {
+  return path.split('/').pop() ?? ''
+}
+
+function transform(data: Subtitle[]) {
+  return data.map(i => {
+    if (i.is_external && i.path) {
+      return { ...i, name: i.name || basename(i.path) }
+    }
+    return i
+  })
+}
+
+export async function getSubtitleInfo(
+  videoPath?: string,
+): Promise<Subtitle[] | undefined> {
+  try {
+    if (!videoPath) {
+      return
+    }
+    const resp = await fetch(videoPath)
+    if (!resp.ok) {
+      throw new Error(`Http Status: ${resp.status}`)
+    }
+    const data: SubtitleInfoResp = await resp.json()
+    if (data.len == 0) {
+      return
+    } else {
+      return transform(data.data)
+    }
+  } catch (error) {
+    console.error(`Failed to get subtitle info: ${error}`)
+    return
+  }
+}

package/src/components/Video/native/EventEmitter.ts

@@ -0,0 +1,62 @@
+/**
+ * 简单事件发射器，用于 NativePlayer 与 useSource 等对接
+ */
+type Listener = (e?: any) => void
+
+export class EventEmitter {
+  private listeners: Record<string, Listener[]> = {}
+  private oneListeners: Record<string, Listener[]> = {}
+
+  on(event: string, fn: Listener) {
+    if (!this.listeners[event]) this.listeners[event] = []
+    this.listeners[event].push(fn)
+  }
+
+  one(event: string, fn: Listener) {
+    if (!this.oneListeners[event]) this.oneListeners[event] = []
+    this.oneListeners[event].push(fn)
+  }
+
+  off(event: string, fn?: Listener) {
+    if (fn) {
+      this.listeners[event] = (this.listeners[event] || []).filter(
+        (f) => f !== fn,
+      )
+      this.oneListeners[event] = (this.oneListeners[event] || []).filter(
+        (f) => f !== fn,
+      )
+    } else {
+      delete this.listeners[event]
+      delete this.oneListeners[event]
+    }
+  }
+
+  /**
+   * 支持两种用法：
+   * - trigger("eventName") 或 trigger("eventName", data)
+   * - trigger({ type: "eventName", ...data }) 与 video.js 兼容
+   */
+  trigger(
+    eventOrName: string | { type: string; [key: string]: unknown },
+    data?: unknown,
+  ) {
+    let eventName: string
+    let payload: unknown
+    if (typeof eventOrName === "string") {
+      eventName = eventOrName
+      payload = data
+    } else {
+      eventName = eventOrName.type
+      payload = eventOrName
+    }
+    const run = (fns: Listener[] = []) => fns.forEach((fn) => fn(payload))
+    run(this.oneListeners[eventName])
+    this.oneListeners[eventName] = []
+    run(this.listeners[eventName])
+  }
+
+  dispose() {
+    this.listeners = {}
+    this.oneListeners = {}
+  }
+}