@zenvor/hls.js 1.0.0

package/src/utils/texttrack-utils.ts

@@ -0,0 +1,164 @@
+import { logger } from './logger';
+import type { MediaPlaylist } from '../hls';
+
+// This is a replacement of the native addTextTrack method.
+// TextTracks created by the native method are unremovable since their livecycles
+// are neither associated with the current media nor managed by user code.
+export function createTrackNode(
+  videoEl: HTMLMediaElement,
+  kind: TextTrackKind | 'forced',
+  label: string,
+  lang: string = '',
+  mode: TextTrackMode = 'disabled',
+): HTMLTrackElement {
+  const el = videoEl.ownerDocument.createElement('track');
+  el.kind = kind;
+  el.label = label;
+  if (lang) {
+    el.srclang = lang;
+  }
+  // To avoid an issue of the built-in captions menu in Chrome
+  // https://github.com/video-dev/hls.js/issues/2198#issuecomment-761614248
+  // It also prevents Safari from removing cues after setting track.mode to `hidden` or `disabled`
+  // https://github.com/video-dev/hls.js/pull/7515#issuecomment-3251091932
+  el.src = 'data:,WEBVTT';
+  el.track.mode = mode;
+  videoEl.appendChild(el);
+  return el;
+}
+
+export function getTrackKind(track: MediaPlaylist): TextTrackKind | 'forced' {
+  if (
+    track.forced &&
+    (navigator.vendor.includes('Apple') ||
+      /iPhone|iPad|iPod/.test(navigator.userAgent))
+  ) {
+    return 'forced';
+  } else if (
+    track.characteristics &&
+    /transcribes-spoken-dialog/gi.test(track.characteristics) &&
+    /describes-music-and-sound/gi.test(track.characteristics)
+  ) {
+    return 'captions';
+  }
+
+  return 'subtitles';
+}
+
+export function addCueToTrack(track: TextTrack, cue: VTTCue) {
+  // Sometimes there are cue overlaps on segmented vtts so the same
+  // cue can appear more than once in different vtt files.
+  // This avoid showing duplicated cues with same timecode and text.
+  const mode = track.mode;
+  if (mode === 'disabled') {
+    track.mode = 'hidden';
+  }
+  if (track.cues && !track.cues.getCueById(cue.id)) {
+    try {
+      track.addCue(cue);
+      if (!track.cues.getCueById(cue.id)) {
+        throw new Error(`addCue is failed for: ${cue}`);
+      }
+    } catch (err) {
+      logger.debug(`[texttrack-utils]: ${err}`);
+      try {
+        const textTrackCue = new (self.TextTrackCue as any)(
+          cue.startTime,
+          cue.endTime,
+          cue.text,
+        );
+        textTrackCue.id = cue.id;
+        track.addCue(textTrackCue);
+      } catch (err2) {
+        logger.debug(
+          `[texttrack-utils]: Legacy TextTrackCue fallback failed: ${err2}`,
+        );
+      }
+    }
+  }
+  if (mode === 'disabled') {
+    track.mode = mode;
+  }
+}
+
+export function removeCuesInRange(
+  track: TextTrack,
+  start: number,
+  end: number,
+  predicate?: (cue: TextTrackCue) => boolean,
+) {
+  const mode = track.mode;
+  if (mode === 'disabled') {
+    track.mode = 'hidden';
+  }
+
+  if (track.cues && track.cues.length > 0) {
+    const cues = getCuesInRange(track.cues, start, end);
+    for (let i = 0; i < cues.length; i++) {
+      if (!predicate || predicate(cues[i])) {
+        track.removeCue(cues[i]);
+      }
+    }
+  }
+  if (mode === 'disabled') {
+    track.mode = mode;
+  }
+}
+
+// Find first cue starting at or after given time.
+// Modified version of binary search O(log(n)).
+function getFirstCueIndexFromTime(
+  cues: TextTrackCueList | TextTrackCue[],
+  time: number,
+): number {
+  // If first cue starts at or after time, start there
+  if (time <= cues[0].startTime) {
+    return 0;
+  }
+  // If the last cue ends before time there is no overlap
+  const len = cues.length - 1;
+  if (time > cues[len].endTime) {
+    return -1;
+  }
+
+  let left = 0;
+  let right = len;
+  let mid;
+  while (left <= right) {
+    mid = Math.floor((right + left) / 2);
+
+    if (time < cues[mid].startTime) {
+      right = mid - 1;
+    } else if (time > cues[mid].startTime && left < len) {
+      left = mid + 1;
+    } else {
+      // If it's not lower or higher, it must be equal.
+      return mid;
+    }
+  }
+  // At this point, left and right have swapped.
+  // No direct match was found, left or right element must be the closest. Check which one has the smallest diff.
+  return cues[left].startTime - time < time - cues[right].startTime
+    ? left
+    : right;
+}
+
+export function getCuesInRange(
+  cues: TextTrackCueList | TextTrackCue[],
+  start: number,
+  end: number,
+): TextTrackCue[] {
+  const cuesFound: TextTrackCue[] = [];
+  const firstCueInRange = getFirstCueIndexFromTime(cues, start);
+  if (firstCueInRange > -1) {
+    for (let i = firstCueInRange, len = cues.length; i < len; i++) {
+      const cue = cues[i];
+      if (cue.startTime >= start && cue.endTime <= end) {
+        cuesFound.push(cue);
+      } else if (cue.startTime > end) {
+        return cuesFound;
+      }
+    }
+  }
+  return cuesFound;
+}

package/src/utils/time-ranges.ts

@@ -0,0 +1,17 @@
+/**
+ *  TimeRanges to string helper
+ */
+
+const TimeRanges = {
+  toString: function (r: TimeRanges) {
+    let log = '';
+    const len = r.length;
+    for (let i = 0; i < len; i++) {
+      log += `[${r.start(i).toFixed(3)}-${r.end(i).toFixed(3)}]`;
+    }
+
+    return log;
+  },
+};
+
+export default TimeRanges;

package/src/utils/timescale-conversion.ts

@@ -0,0 +1,46 @@
+const MPEG_TS_CLOCK_FREQ_HZ = 90000;
+
+export type RationalTimestamp = {
+  baseTime: number; // ticks
+  timescale: number; // ticks per second
+};
+
+export type TimestampOffset = RationalTimestamp & { trackId: number };
+
+export function toTimescaleFromBase(
+  baseTime: number,
+  destScale: number,
+  srcBase: number = 1,
+  round: boolean = false,
+): number {
+  const result = baseTime * destScale * srcBase; // equivalent to `(value * scale) / (1 / base)`
+  return round ? Math.round(result) : result;
+}
+
+export function toTimescaleFromScale(
+  baseTime: number,
+  destScale: number,
+  srcScale: number = 1,
+  round: boolean = false,
+): number {
+  return toTimescaleFromBase(baseTime, destScale, 1 / srcScale, round);
+}
+
+export function toMsFromMpegTsClock(
+  baseTime: number,
+  round: boolean = false,
+): number {
+  return toTimescaleFromBase(baseTime, 1000, 1 / MPEG_TS_CLOCK_FREQ_HZ, round);
+}
+
+export function toMpegTsClockFromTimescale(
+  baseTime: number,
+  srcScale: number = 1,
+): number {
+  return toTimescaleFromBase(baseTime, MPEG_TS_CLOCK_FREQ_HZ, 1 / srcScale);
+}
+
+export function timestampToString(timestamp: TimestampOffset): string {
+  const { baseTime, timescale, trackId } = timestamp;
+  return `${baseTime / timescale} (${baseTime}/${timescale}) trackId: ${trackId}`;
+}

package/src/utils/utf8-utils.ts

@@ -0,0 +1,18 @@
+// breaking up those two types in order to clarify what is happening in the decoding path.
+type DecodedFrame<T> = { key: string; data: T; info?: any };
+export type Frame = DecodedFrame<ArrayBuffer | string>;
+// http://stackoverflow.com/questions/8936984/uint8array-to-string-in-javascript/22373197
+// http://www.onicos.com/staff/iz/amuse/javascript/expert/utf.txt
+/* utf.js - UTF-8 <=> UTF-16 convertion
+ *
+ * Copyright (C) 1999 Masanao Izumo <iz@onicos.co.jp>
+ * Version: 1.0
+ * LastModified: Dec 25 1999
+ * This library is free.  You can redistribute it and/or modify it.
+ */
+
+export function strToUtf8array(str: string) {
+  return Uint8Array.from(unescape(encodeURIComponent(str)), (c) =>
+    c.charCodeAt(0),
+  );
+}

package/src/utils/variable-substitution.ts

@@ -0,0 +1,105 @@
+import type { AttrList } from './attr-list';
+import type { LevelDetails } from '../loader/level-details';
+import type { ParsedMultivariantPlaylist } from '../loader/m3u8-parser';
+import type { VariableMap } from '../types/level';
+
+const VARIABLE_REPLACEMENT_REGEX = /\{\$([a-zA-Z0-9-_]+)\}/g;
+
+export function hasVariableReferences(str: string): boolean {
+  return VARIABLE_REPLACEMENT_REGEX.test(str);
+}
+
+export function substituteVariables(
+  parsed: Pick<
+    ParsedMultivariantPlaylist | LevelDetails,
+    'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+  >,
+  value: string,
+): string {
+  if (parsed.variableList !== null || parsed.hasVariableRefs) {
+    const variableList = parsed.variableList;
+    return value.replace(
+      VARIABLE_REPLACEMENT_REGEX,
+      (variableReference: string) => {
+        const variableName = variableReference.substring(
+          2,
+          variableReference.length - 1,
+        );
+        const variableValue = variableList?.[variableName];
+        if (variableValue === undefined) {
+          parsed.playlistParsingError ||= new Error(
+            `Missing preceding EXT-X-DEFINE tag for Variable Reference: "${variableName}"`,
+          );
+          return variableReference;
+        }
+        return variableValue;
+      },
+    );
+  }
+  return value;
+}
+
+export function addVariableDefinition(
+  parsed: Pick<
+    ParsedMultivariantPlaylist | LevelDetails,
+    'variableList' | 'playlistParsingError'
+  >,
+  attr: AttrList,
+  parentUrl: string,
+) {
+  let variableList = parsed.variableList;
+  if (!variableList) {
+    parsed.variableList = variableList = {};
+  }
+  let NAME: string;
+  let VALUE;
+  if ('QUERYPARAM' in attr) {
+    NAME = attr.QUERYPARAM;
+    try {
+      const searchParams = new self.URL(parentUrl).searchParams;
+      if (searchParams.has(NAME)) {
+        VALUE = searchParams.get(NAME);
+      } else {
+        throw new Error(
+          `"${NAME}" does not match any query parameter in URI: "${parentUrl}"`,
+        );
+      }
+    } catch (error) {
+      parsed.playlistParsingError ||= new Error(
+        `EXT-X-DEFINE QUERYPARAM: ${error.message}`,
+      );
+    }
+  } else {
+    NAME = attr.NAME;
+    VALUE = attr.VALUE;
+  }
+  if (NAME in variableList) {
+    parsed.playlistParsingError ||= new Error(
+      `EXT-X-DEFINE duplicate Variable Name declarations: "${NAME}"`,
+    );
+  } else {
+    variableList[NAME] = VALUE || '';
+  }
+}
+
+export function importVariableDefinition(
+  parsed: Pick<
+    ParsedMultivariantPlaylist | LevelDetails,
+    'variableList' | 'playlistParsingError'
+  >,
+  attr: AttrList,
+  sourceVariableList: VariableMap | null,
+) {
+  const IMPORT = attr.IMPORT;
+  if (sourceVariableList && IMPORT in sourceVariableList) {
+    let variableList = parsed.variableList;
+    if (!variableList) {
+      parsed.variableList = variableList = {};
+    }
+    variableList[IMPORT] = sourceVariableList[IMPORT];
+  } else {
+    parsed.playlistParsingError ||= new Error(
+      `EXT-X-DEFINE IMPORT attribute not found in Multivariant Playlist: "${IMPORT}"`,
+    );
+  }
+}