@zenvor/hls.js 1.0.0

package/src/types/transmuxer.ts

@@ -0,0 +1,46 @@
+import type { SourceBufferName } from './buffer';
+import type { HlsChunkPerformanceTiming } from './loader';
+import type { RemuxerResult } from './remuxer';
+
+export interface TransmuxerResult {
+  remuxResult: RemuxerResult;
+  chunkMeta: ChunkMetadata;
+}
+
+export class ChunkMetadata {
+  public readonly level: number;
+  public readonly sn: number;
+  public readonly part: number;
+  public readonly id: number;
+  public readonly size: number;
+  public readonly partial: boolean;
+  public readonly transmuxing: HlsChunkPerformanceTiming =
+    getNewPerformanceTiming();
+  public readonly buffering: {
+    [key in SourceBufferName]: HlsChunkPerformanceTiming;
+  } = {
+    audio: getNewPerformanceTiming(),
+    video: getNewPerformanceTiming(),
+    audiovideo: getNewPerformanceTiming(),
+  };
+
+  constructor(
+    level: number,
+    sn: number,
+    id: number,
+    size = 0,
+    part = -1,
+    partial = false,
+  ) {
+    this.level = level;
+    this.sn = sn;
+    this.id = id;
+    this.size = size;
+    this.part = part;
+    this.partial = partial;
+  }
+}
+
+function getNewPerformanceTiming(): HlsChunkPerformanceTiming {
+  return { start: 0, executeStart: 0, executeEnd: 0, end: 0 };
+}

package/src/types/tuples.ts

@@ -0,0 +1,6 @@
+export type Tail<T extends any[]> = ((...t: T) => any) extends (
+  _: any,
+  ...tail: infer U
+) => any
+  ? U
+  : [];

package/src/types/vtt.ts

@@ -0,0 +1,11 @@
+export type VTTCCs = {
+  ccOffset: number;
+  presentationOffset: number;
+  [key: number]:
+    | {
+        start: number;
+        prevCC: number;
+        new: boolean;
+      }
+    | undefined;
+};

package/src/utils/arrays.ts

@@ -0,0 +1,22 @@
+export function arrayValuesMatch(
+  a: (string | number)[] | Uint8Array,
+  b: (string | number)[] | Uint8Array,
+): boolean {
+  if (a.length === b.length) {
+    return !a.some((value: string | number, i: number) => value !== b[i]);
+  }
+  return false;
+}
+
+export function optionalArrayValuesMatch(
+  a: (string | number)[] | Uint8Array | null | undefined,
+  b: (string | number)[] | Uint8Array | null | undefined,
+): boolean {
+  if (!a && !b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return arrayValuesMatch(a, b);
+}

package/src/utils/attr-list.ts

@@ -0,0 +1,192 @@
+import { logger } from './logger';
+import { substituteVariables } from './variable-substitution';
+import type { LevelDetails } from '../loader/level-details';
+import type { ParsedMultivariantPlaylist } from '../loader/m3u8-parser';
+
+const DECIMAL_RESOLUTION_REGEX = /^(\d+)x(\d+)$/;
+const ATTR_LIST_REGEX = /(.+?)=(".*?"|.*?)(?:,|$)/g;
+
+// adapted from https://github.com/kanongil/node-m3u8parse/blob/master/attrlist.js
+export class AttrList {
+  [key: string]: any;
+
+  constructor(
+    attrs: string | Record<string, any>,
+    parsed?: Pick<
+      ParsedMultivariantPlaylist | LevelDetails,
+      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+    >,
+  ) {
+    if (typeof attrs === 'string') {
+      attrs = AttrList.parseAttrList(attrs, parsed);
+    }
+    Object.assign(this, attrs);
+  }
+
+  get clientAttrs(): string[] {
+    return Object.keys(this).filter((attr) => attr.substring(0, 2) === 'X-');
+  }
+
+  decimalInteger(attrName: string): number {
+    const intValue = parseInt(this[attrName], 10);
+    if (intValue > Number.MAX_SAFE_INTEGER) {
+      return Infinity;
+    }
+
+    return intValue;
+  }
+
+  hexadecimalInteger(attrName: string) {
+    if (this[attrName]) {
+      let stringValue = (this[attrName] || '0x').slice(2);
+      stringValue = (stringValue.length & 1 ? '0' : '') + stringValue;
+
+      const value = new Uint8Array(stringValue.length / 2);
+      for (let i = 0; i < stringValue.length / 2; i++) {
+        value[i] = parseInt(stringValue.slice(i * 2, i * 2 + 2), 16);
+      }
+
+      return value;
+    }
+    return null;
+  }
+
+  hexadecimalIntegerAsNumber(attrName: string): number {
+    const intValue = parseInt(this[attrName], 16);
+    if (intValue > Number.MAX_SAFE_INTEGER) {
+      return Infinity;
+    }
+
+    return intValue;
+  }
+
+  decimalFloatingPoint(attrName: string): number {
+    return parseFloat(this[attrName]);
+  }
+
+  optionalFloat(attrName: string, defaultValue: number): number {
+    const value = this[attrName];
+    return value ? parseFloat(value) : defaultValue;
+  }
+
+  enumeratedString(attrName: string): string | undefined {
+    return this[attrName];
+  }
+
+  enumeratedStringList<T extends { [key: string]: boolean }>(
+    attrName: string,
+    dict: T,
+  ): { [key in keyof T]: boolean } {
+    const attrValue = this[attrName];
+    return (attrValue ? attrValue.split(/[ ,]+/) : []).reduce(
+      (result: { [key in keyof T]: boolean }, identifier: string) => {
+        result[identifier.toLowerCase() as keyof T] = true;
+        return result;
+      },
+      dict,
+    );
+  }
+
+  bool(attrName: string): boolean {
+    return this[attrName] === 'YES';
+  }
+
+  decimalResolution(attrName: string):
+    | {
+        width: number;
+        height: number;
+      }
+    | undefined {
+    const res = DECIMAL_RESOLUTION_REGEX.exec(this[attrName]);
+    if (res === null) {
+      return undefined;
+    }
+
+    return {
+      width: parseInt(res[1], 10),
+      height: parseInt(res[2], 10),
+    };
+  }
+
+  static parseAttrList(
+    input: string,
+    parsed?: Pick<
+      ParsedMultivariantPlaylist | LevelDetails,
+      'variableList' | 'hasVariableRefs' | 'playlistParsingError'
+    >,
+  ): Record<string, string> {
+    let match: RegExpExecArray | null;
+    const attrs = {};
+    const quote = '"';
+    ATTR_LIST_REGEX.lastIndex = 0;
+    while ((match = ATTR_LIST_REGEX.exec(input)) !== null) {
+      const name = match[1].trim();
+      let value = match[2];
+      const quotedString =
+        value.indexOf(quote) === 0 &&
+        value.lastIndexOf(quote) === value.length - 1;
+      let hexadecimalSequence = false;
+      if (quotedString) {
+        value = value.slice(1, -1);
+      } else {
+        switch (name) {
+          case 'IV':
+          case 'SCTE35-CMD':
+          case 'SCTE35-IN':
+          case 'SCTE35-OUT':
+            hexadecimalSequence = true;
+        }
+      }
+      if (parsed && (quotedString || hexadecimalSequence)) {
+        if (__USE_VARIABLE_SUBSTITUTION__) {
+          value = substituteVariables(parsed, value);
+        }
+      } else if (!hexadecimalSequence && !quotedString) {
+        switch (name) {
+          case 'CLOSED-CAPTIONS':
+            if (value === 'NONE') {
+              break;
+            }
+          // falls through
+          case 'ALLOWED-CPC':
+          case 'CLASS':
+          case 'ASSOC-LANGUAGE':
+          case 'AUDIO':
+          case 'BYTERANGE':
+          case 'CHANNELS':
+          case 'CHARACTERISTICS':
+          case 'CODECS':
+          case 'DATA-ID':
+          case 'END-DATE':
+          case 'GROUP-ID':
+          case 'ID':
+          case 'IMPORT':
+          case 'INSTREAM-ID':
+          case 'KEYFORMAT':
+          case 'KEYFORMATVERSIONS':
+          case 'LANGUAGE':
+          case 'NAME':
+          case 'PATHWAY-ID':
+          case 'QUERYPARAM':
+          case 'RECENTLY-REMOVED-DATERANGES':
+          case 'SERVER-URI':
+          case 'STABLE-RENDITION-ID':
+          case 'STABLE-VARIANT-ID':
+          case 'START-DATE':
+          case 'SUBTITLES':
+          case 'SUPPLEMENTAL-CODECS':
+          case 'URI':
+          case 'VALUE':
+          case 'VIDEO':
+          case 'X-ASSET-LIST':
+          case 'X-ASSET-URI':
+            // Since we are not checking tag:attribute combination, just warn rather than ignoring attribute
+            logger.warn(`${input}: attribute ${name} is missing quotes`);
+          // continue;
+        }
+      }
+      attrs[name] = value;
+    }
+    return attrs;
+  }
+}

package/src/utils/binary-search.ts

@@ -0,0 +1,46 @@
+type BinarySearchComparison<T> = (candidate: T) => -1 | 0 | 1;
+
+const BinarySearch = {
+  /**
+   * Searches for an item in an array which matches a certain condition.
+   * This requires the condition to only match one item in the array,
+   * and for the array to be ordered.
+   *
+   * @param list The array to search.
+   * @param comparisonFn
+   *      Called and provided a candidate item as the first argument.
+   *      Should return:
+   *          > -1 if the item should be located at a lower index than the provided item.
+   *          > 1 if the item should be located at a higher index than the provided item.
+   *          > 0 if the item is the item you're looking for.
+   *
+   * @returns the object if found, otherwise returns null
+   */
+  search: function <T>(
+    list: T[],
+    comparisonFn: BinarySearchComparison<T>,
+  ): T | null {
+    let minIndex: number = 0;
+    let maxIndex: number = list.length - 1;
+    let currentIndex: number | null = null;
+    let currentElement: T | null = null;
+
+    while (minIndex <= maxIndex) {
+      currentIndex = ((minIndex + maxIndex) / 2) | 0;
+      currentElement = list[currentIndex];
+
+      const comparisonResult = comparisonFn(currentElement);
+      if (comparisonResult > 0) {
+        minIndex = currentIndex + 1;
+      } else if (comparisonResult < 0) {
+        maxIndex = currentIndex - 1;
+      } else {
+        return currentElement;
+      }
+    }
+
+    return null;
+  },
+};
+
+export default BinarySearch;

package/src/utils/buffer-helper.ts

@@ -0,0 +1,173 @@
+/**
+ * Provides methods dealing with buffer length retrieval for example.
+ *
+ * In general, a helper around HTML5 MediaElement TimeRanges gathered from `buffered` property.
+ *
+ * Also @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/buffered
+ */
+
+import { logger } from './logger';
+
+export type BufferTimeRange = {
+  start: number;
+  end: number;
+};
+
+export type Bufferable = {
+  buffered: TimeRanges;
+};
+
+export type BufferInfo = {
+  len: number;
+  start: number;
+  end: number;
+  nextStart?: number;
+  buffered?: BufferTimeRange[];
+  bufferedIndex: number;
+};
+
+const noopBuffered: TimeRanges = {
+  length: 0,
+  start: () => 0,
+  end: () => 0,
+};
+
+export class BufferHelper {
+  /**
+   * Return true if `media`'s buffered include `position`
+   */
+  static isBuffered(media: Bufferable | null, position: number): boolean {
+    if (media) {
+      const buffered = BufferHelper.getBuffered(media);
+      for (let i = buffered.length; i--; ) {
+        if (position >= buffered.start(i) && position <= buffered.end(i)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  static bufferedRanges(media: Bufferable | null): BufferTimeRange[] {
+    if (media) {
+      const timeRanges = BufferHelper.getBuffered(media);
+      return BufferHelper.timeRangesToArray(timeRanges);
+    }
+    return [];
+  }
+
+  static timeRangesToArray(timeRanges: TimeRanges): BufferTimeRange[] {
+    const buffered: BufferTimeRange[] = [];
+    for (let i = 0; i < timeRanges.length; i++) {
+      buffered.push({ start: timeRanges.start(i), end: timeRanges.end(i) });
+    }
+    return buffered;
+  }
+
+  static bufferInfo(
+    media: Bufferable | null,
+    pos: number,
+    maxHoleDuration: number,
+  ): BufferInfo {
+    if (media) {
+      const buffered = BufferHelper.bufferedRanges(media);
+      if (buffered.length) {
+        return BufferHelper.bufferedInfo(buffered, pos, maxHoleDuration);
+      }
+    }
+    return { len: 0, start: pos, end: pos, bufferedIndex: -1 };
+  }
+
+  static bufferedInfo(
+    buffered: BufferTimeRange[],
+    pos: number,
+    maxHoleDuration: number,
+  ): BufferInfo {
+    pos = Math.max(0, pos);
+    // sort on buffer.start/smaller end (IE does not always return sorted buffered range)
+    if (buffered.length > 1) {
+      buffered.sort((a, b) => a.start - b.start || b.end - a.end);
+    }
+
+    let bufferedIndex: number = -1;
+    let buffered2: BufferTimeRange[] = [];
+    if (maxHoleDuration) {
+      // there might be some small holes between buffer time range
+      // consider that holes smaller than maxHoleDuration are irrelevant and build another
+      // buffer time range representations that discards those holes
+      for (let i = 0; i < buffered.length; i++) {
+        if (pos >= buffered[i].start && pos <= buffered[i].end) {
+          bufferedIndex = i;
+        }
+        const buf2len = buffered2.length;
+        if (buf2len) {
+          const buf2end = buffered2[buf2len - 1].end;
+          // if small hole (value between 0 or maxHoleDuration ) or overlapping (negative)
+          if (buffered[i].start - buf2end < maxHoleDuration) {
+            // merge overlapping time ranges
+            // update lastRange.end only if smaller than item.end
+            // e.g.  [ 1, 15] with  [ 2,8] => [ 1,15] (no need to modify lastRange.end)
+            // whereas [ 1, 8] with  [ 2,15] => [ 1,15] ( lastRange should switch from [1,8] to [1,15])
+            if (buffered[i].end > buf2end) {
+              buffered2[buf2len - 1].end = buffered[i].end;
+            }
+          } else {
+            // big hole
+            buffered2.push(buffered[i]);
+          }
+        } else {
+          // first value
+          buffered2.push(buffered[i]);
+        }
+      }
+    } else {
+      buffered2 = buffered;
+    }
+
+    let bufferLen = 0;
+
+    let nextStart: number | undefined;
+
+    // bufferStart and bufferEnd are buffer boundaries around current playback position (pos)
+    let bufferStart: number = pos;
+    let bufferEnd: number = pos;
+    for (let i = 0; i < buffered2.length; i++) {
+      const start = buffered2[i].start;
+      const end = buffered2[i].end;
+      // logger.log('buf start/end:' + buffered.start(i) + '/' + buffered.end(i));
+      if (bufferedIndex === -1 && pos >= start && pos <= end) {
+        bufferedIndex = i;
+      }
+      if (pos + maxHoleDuration >= start && pos < end) {
+        // play position is inside this buffer TimeRange, retrieve end of buffer position and buffer length
+        bufferStart = start;
+        bufferEnd = end;
+        bufferLen = bufferEnd - pos;
+      } else if (pos + maxHoleDuration < start) {
+        nextStart = start;
+        break;
+      }
+    }
+    return {
+      len: bufferLen,
+      start: bufferStart || 0,
+      end: bufferEnd || 0,
+      nextStart,
+      buffered,
+      bufferedIndex,
+    };
+  }
+
+  /**
+   * Safe method to get buffered property.
+   * SourceBuffer.buffered may throw if SourceBuffer is removed from it's MediaSource
+   */
+  static getBuffered(media: Bufferable): TimeRanges {
+    try {
+      return media.buffered || noopBuffered;
+    } catch (e) {
+      logger.log('failed to get media.buffered', e);
+      return noopBuffered;
+    }
+  }
+}