@zenvor/hls.js 1.0.0

package/src/is-supported.ts

@@ -0,0 +1,54 @@
+import { mimeTypeForCodec } from './utils/codecs';
+import { getMediaSource } from './utils/mediasource-helper';
+import type { ExtendedSourceBuffer } from './types/buffer';
+
+function getSourceBuffer(): typeof self.SourceBuffer {
+  return self.SourceBuffer || (self as any).WebKitSourceBuffer;
+}
+
+export function isMSESupported(): boolean {
+  const mediaSource = getMediaSource();
+  if (!mediaSource) {
+    return false;
+  }
+
+  // if SourceBuffer is exposed ensure its API is valid
+  // Older browsers do not expose SourceBuffer globally so checking SourceBuffer.prototype is impossible
+  const sourceBuffer = getSourceBuffer();
+  return (
+    !sourceBuffer ||
+    (sourceBuffer.prototype &&
+      typeof sourceBuffer.prototype.appendBuffer === 'function' &&
+      typeof sourceBuffer.prototype.remove === 'function')
+  );
+}
+
+export function isSupported(): boolean {
+  if (!isMSESupported()) {
+    return false;
+  }
+
+  const mediaSource = getMediaSource();
+  return (
+    typeof mediaSource?.isTypeSupported === 'function' &&
+    (['avc1.42E01E,mp4a.40.2', 'av01.0.01M.08', 'vp09.00.50.08'].some(
+      (codecsForVideoContainer) =>
+        mediaSource.isTypeSupported(
+          mimeTypeForCodec(codecsForVideoContainer, 'video'),
+        ),
+    ) ||
+      ['mp4a.40.2', 'fLaC'].some((codecForAudioContainer) =>
+        mediaSource.isTypeSupported(
+          mimeTypeForCodec(codecForAudioContainer, 'audio'),
+        ),
+      ))
+  );
+}
+
+export function changeTypeSupported(): boolean {
+  const sourceBuffer = getSourceBuffer();
+  return (
+    typeof (sourceBuffer?.prototype as ExtendedSourceBuffer)?.changeType ===
+    'function'
+  );
+}

package/src/loader/date-range.ts

@@ -0,0 +1,207 @@
+import { AttrList } from '../utils/attr-list';
+import { logger } from '../utils/logger';
+import type { MediaFragmentRef } from './fragment';
+
+// Avoid exporting const enum so that these values can be inlined
+const enum DateRangeAttribute {
+  ID = 'ID',
+  CLASS = 'CLASS',
+  CUE = 'CUE',
+  START_DATE = 'START-DATE',
+  DURATION = 'DURATION',
+  END_DATE = 'END-DATE',
+  END_ON_NEXT = 'END-ON-NEXT',
+  PLANNED_DURATION = 'PLANNED-DURATION',
+  SCTE35_OUT = 'SCTE35-OUT',
+  SCTE35_IN = 'SCTE35-IN',
+  SCTE35_CMD = 'SCTE35-CMD',
+}
+
+export type DateRangeCue = {
+  pre: boolean;
+  post: boolean;
+  once: boolean;
+};
+
+const CLASS_INTERSTITIAL = 'com.apple.hls.interstitial';
+
+export function isDateRangeCueAttribute(attrName: string): boolean {
+  return (
+    attrName !== DateRangeAttribute.ID &&
+    attrName !== DateRangeAttribute.CLASS &&
+    attrName !== DateRangeAttribute.CUE &&
+    attrName !== DateRangeAttribute.START_DATE &&
+    attrName !== DateRangeAttribute.DURATION &&
+    attrName !== DateRangeAttribute.END_DATE &&
+    attrName !== DateRangeAttribute.END_ON_NEXT
+  );
+}
+
+export function isSCTE35Attribute(attrName: string): boolean {
+  return (
+    attrName === DateRangeAttribute.SCTE35_OUT ||
+    attrName === DateRangeAttribute.SCTE35_IN ||
+    attrName === DateRangeAttribute.SCTE35_CMD
+  );
+}
+
+export class DateRange {
+  public attr: AttrList;
+  public tagAnchor: MediaFragmentRef | null;
+  public tagOrder: number;
+  private _startDate: Date;
+  private _endDate?: Date;
+  private _dateAtEnd?: Date;
+  private _cue?: DateRangeCue;
+  private _badValueForSameId?: string;
+
+  constructor(
+    dateRangeAttr: AttrList,
+    dateRangeWithSameId?: DateRange | undefined,
+    tagCount: number = 0,
+  ) {
+    this.tagAnchor = dateRangeWithSameId?.tagAnchor || null;
+    this.tagOrder = dateRangeWithSameId?.tagOrder ?? tagCount;
+    if (dateRangeWithSameId) {
+      const previousAttr = dateRangeWithSameId.attr;
+      for (const key in previousAttr) {
+        if (
+          Object.prototype.hasOwnProperty.call(dateRangeAttr, key) &&
+          dateRangeAttr[key] !== previousAttr[key]
+        ) {
+          logger.warn(
+            `DATERANGE tag attribute: "${key}" does not match for tags with ID: "${dateRangeAttr.ID}"`,
+          );
+          this._badValueForSameId = key;
+          break;
+        }
+      }
+      // Merge DateRange tags with the same ID
+      dateRangeAttr = Object.assign(
+        new AttrList({}),
+        previousAttr,
+        dateRangeAttr,
+      );
+    }
+    this.attr = dateRangeAttr;
+    if (dateRangeWithSameId) {
+      this._startDate = dateRangeWithSameId._startDate;
+      this._cue = dateRangeWithSameId._cue;
+      this._endDate = dateRangeWithSameId._endDate;
+      this._dateAtEnd = dateRangeWithSameId._dateAtEnd;
+    } else {
+      this._startDate = new Date(dateRangeAttr[DateRangeAttribute.START_DATE]);
+    }
+    if (DateRangeAttribute.END_DATE in this.attr) {
+      const endDate =
+        dateRangeWithSameId?.endDate ||
+        new Date(this.attr[DateRangeAttribute.END_DATE]);
+      if (Number.isFinite(endDate.getTime())) {
+        this._endDate = endDate;
+      }
+    }
+  }
+
+  get id(): string {
+    return this.attr.ID;
+  }
+
+  get class(): string {
+    return this.attr.CLASS;
+  }
+
+  get cue(): DateRangeCue {
+    const _cue = this._cue;
+    if (_cue === undefined) {
+      return (this._cue = this.attr.enumeratedStringList(
+        this.attr.CUE ? 'CUE' : 'X-CUE',
+        {
+          pre: false,
+          post: false,
+          once: false,
+        },
+      ));
+    }
+    return _cue;
+  }
+
+  get startTime(): number {
+    const { tagAnchor } = this;
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    if (tagAnchor === null || tagAnchor.programDateTime === null) {
+      logger.warn(
+        `Expected tagAnchor Fragment with PDT set for DateRange "${this.id}": ${tagAnchor}`,
+      );
+      return NaN;
+    }
+    return (
+      tagAnchor.start +
+      (this.startDate.getTime() - tagAnchor.programDateTime) / 1000
+    );
+  }
+
+  get startDate(): Date {
+    return this._startDate;
+  }
+
+  get endDate(): Date | null {
+    const dateAtEnd = this._endDate || this._dateAtEnd;
+    if (dateAtEnd) {
+      return dateAtEnd;
+    }
+    const duration = this.duration;
+    if (duration !== null) {
+      return (this._dateAtEnd = new Date(
+        this._startDate.getTime() + duration * 1000,
+      ));
+    }
+    return null;
+  }
+
+  get duration(): number | null {
+    if (DateRangeAttribute.DURATION in this.attr) {
+      const duration = this.attr.decimalFloatingPoint(
+        DateRangeAttribute.DURATION,
+      );
+      if (Number.isFinite(duration)) {
+        return duration;
+      }
+    } else if (this._endDate) {
+      return (this._endDate.getTime() - this._startDate.getTime()) / 1000;
+    }
+    return null;
+  }
+
+  get plannedDuration(): number | null {
+    if (DateRangeAttribute.PLANNED_DURATION in this.attr) {
+      return this.attr.decimalFloatingPoint(
+        DateRangeAttribute.PLANNED_DURATION,
+      );
+    }
+    return null;
+  }
+
+  get endOnNext(): boolean {
+    return this.attr.bool(DateRangeAttribute.END_ON_NEXT);
+  }
+
+  get isInterstitial(): boolean {
+    return this.class === CLASS_INTERSTITIAL;
+  }
+
+  get isValid(): boolean {
+    return (
+      !!this.id &&
+      !this._badValueForSameId &&
+      Number.isFinite(this.startDate.getTime()) &&
+      (this.duration === null || this.duration >= 0) &&
+      (!this.endOnNext || !!this.class) &&
+      (!this.attr.CUE ||
+        (!this.cue.pre && !this.cue.post) ||
+        this.cue.pre !== this.cue.post) &&
+      (!this.isInterstitial ||
+        'X-ASSET-URI' in this.attr ||
+        'X-ASSET-LIST' in this.attr)
+    );
+  }
+}

package/src/loader/fragment-loader.ts

@@ -0,0 +1,403 @@
+import { ErrorDetails, ErrorTypes } from '../errors';
+import { getLoaderConfigWithoutReties } from '../utils/error-helper';
+import type { BaseSegment, Fragment, Part } from './fragment';
+import type { HlsConfig } from '../config';
+import type {
+  ErrorData,
+  FragLoadedData,
+  PartsLoadedData,
+} from '../types/events';
+import type {
+  FragmentLoaderContext,
+  Loader,
+  LoaderCallbacks,
+  LoaderConfiguration,
+} from '../types/loader';
+import type { NullableNetworkDetails } from '../types/network-details';
+
+const MIN_CHUNK_SIZE = Math.pow(2, 17); // 128kb
+
+export default class FragmentLoader {
+  private readonly config: HlsConfig;
+  private loader: Loader<FragmentLoaderContext> | null = null;
+  private partLoadTimeout: number = -1;
+
+  constructor(config: HlsConfig) {
+    this.config = config;
+  }
+
+  destroy() {
+    if (this.loader) {
+      this.loader.destroy();
+      this.loader = null;
+    }
+  }
+
+  abort() {
+    if (this.loader) {
+      // Abort the loader for current fragment. Only one may load at any given time
+      this.loader.abort();
+    }
+  }
+
+  load(
+    frag: Fragment,
+    onProgress?: FragmentLoadProgressCallback,
+  ): Promise<FragLoadedData> {
+    const url = frag.url;
+    if (!url) {
+      return Promise.reject(
+        new LoadError({
+          type: ErrorTypes.NETWORK_ERROR,
+          details: ErrorDetails.FRAG_LOAD_ERROR,
+          fatal: false,
+          frag,
+          error: new Error(
+            `Fragment does not have a ${url ? 'part list' : 'url'}`,
+          ),
+          networkDetails: null,
+        }),
+      );
+    }
+    this.abort();
+
+    const config = this.config;
+    const FragmentILoader = config.fLoader;
+    const DefaultILoader = config.loader;
+
+    return new Promise((resolve, reject) => {
+      if (this.loader) {
+        this.loader.destroy();
+      }
+      if (frag.gap) {
+        if (frag.tagList.some((tags) => tags[0] === 'GAP')) {
+          reject(createGapLoadError(frag));
+          return;
+        } else {
+          // Reset temporary treatment as GAP tag
+          frag.gap = false;
+        }
+      }
+      const loader = (this.loader = FragmentILoader
+        ? new FragmentILoader(config)
+        : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
+      const loaderContext = createLoaderContext(frag);
+      frag.loader = loader;
+      const loadPolicy = getLoaderConfigWithoutReties(
+        config.fragLoadPolicy.default,
+      );
+      const loaderConfig: LoaderConfiguration = {
+        loadPolicy,
+        timeout: loadPolicy.maxLoadTimeMs,
+        maxRetry: 0,
+        retryDelay: 0,
+        maxRetryDelay: 0,
+        highWaterMark: frag.sn === 'initSegment' ? Infinity : MIN_CHUNK_SIZE,
+      };
+      // Assign frag stats to the loader's stats reference
+      frag.stats = loader.stats;
+      const callbacks: LoaderCallbacks<FragmentLoaderContext> = {
+        onSuccess: (response, stats, context, networkDetails) => {
+          this.resetLoader(frag, loader);
+          let payload = response.data as ArrayBuffer;
+          if (context.resetIV && frag.decryptdata) {
+            frag.decryptdata.iv = new Uint8Array(payload.slice(0, 16));
+            payload = payload.slice(16);
+          }
+          resolve({
+            frag,
+            part: null,
+            payload,
+            networkDetails,
+          });
+        },
+        onError: (response, context, networkDetails, stats) => {
+          this.resetLoader(frag, loader);
+          reject(
+            new LoadError({
+              type: ErrorTypes.NETWORK_ERROR,
+              details: ErrorDetails.FRAG_LOAD_ERROR,
+              fatal: false,
+              frag,
+              response: { url, data: undefined, ...response },
+              error: new Error(`HTTP Error ${response.code} ${response.text}`),
+              networkDetails,
+              stats,
+            }),
+          );
+        },
+        onAbort: (stats, context, networkDetails) => {
+          this.resetLoader(frag, loader);
+          reject(
+            new LoadError({
+              type: ErrorTypes.NETWORK_ERROR,
+              details: ErrorDetails.INTERNAL_ABORTED,
+              fatal: false,
+              frag,
+              error: new Error('Aborted'),
+              networkDetails,
+              stats,
+            }),
+          );
+        },
+        onTimeout: (stats, context, networkDetails) => {
+          this.resetLoader(frag, loader);
+          reject(
+            new LoadError({
+              type: ErrorTypes.NETWORK_ERROR,
+              details: ErrorDetails.FRAG_LOAD_TIMEOUT,
+              fatal: false,
+              frag,
+              error: new Error(`Timeout after ${loaderConfig.timeout}ms`),
+              networkDetails,
+              stats,
+            }),
+          );
+        },
+      };
+      if (onProgress) {
+        callbacks.onProgress = (stats, context, data, networkDetails) =>
+          onProgress({
+            frag,
+            part: null,
+            payload: data as ArrayBuffer,
+            networkDetails,
+          });
+      }
+      loader.load(loaderContext, loaderConfig, callbacks);
+    });
+  }
+
+  public loadPart(
+    frag: Fragment,
+    part: Part,
+    onProgress: FragmentLoadProgressCallback,
+  ): Promise<FragLoadedData> {
+    this.abort();
+
+    const config = this.config;
+    const FragmentILoader = config.fLoader;
+    const DefaultILoader = config.loader;
+
+    return new Promise((resolve, reject) => {
+      if (this.loader) {
+        this.loader.destroy();
+      }
+      if (frag.gap || part.gap) {
+        reject(createGapLoadError(frag, part));
+        return;
+      }
+      const loader = (this.loader = FragmentILoader
+        ? new FragmentILoader(config)
+        : (new DefaultILoader(config) as Loader<FragmentLoaderContext>));
+      const loaderContext = createLoaderContext(frag, part);
+      frag.loader = loader;
+      // Should we define another load policy for parts?
+      const loadPolicy = getLoaderConfigWithoutReties(
+        config.fragLoadPolicy.default,
+      );
+      const loaderConfig: LoaderConfiguration = {
+        loadPolicy,
+        timeout: loadPolicy.maxLoadTimeMs,
+        maxRetry: 0,
+        retryDelay: 0,
+        maxRetryDelay: 0,
+        highWaterMark: MIN_CHUNK_SIZE,
+      };
+      // Assign part stats to the loader's stats reference
+      part.stats = loader.stats;
+      loader.load(loaderContext, loaderConfig, {
+        onSuccess: (response, stats, context, networkDetails) => {
+          this.resetLoader(frag, loader);
+          this.updateStatsFromPart(frag, part);
+          const partLoadedData: FragLoadedData = {
+            frag,
+            part,
+            payload: response.data as ArrayBuffer,
+            networkDetails,
+          };
+          onProgress(partLoadedData);
+          resolve(partLoadedData);
+        },
+        onError: (response, context, networkDetails, stats) => {
+          this.resetLoader(frag, loader);
+          reject(
+            new LoadError({
+              type: ErrorTypes.NETWORK_ERROR,
+              details: ErrorDetails.FRAG_LOAD_ERROR,
+              fatal: false,
+              frag,
+              part,
+              response: {
+                url: loaderContext.url,
+                data: undefined,
+                ...response,
+              },
+              error: new Error(`HTTP Error ${response.code} ${response.text}`),
+              networkDetails,
+              stats,
+            }),
+          );
+        },
+        onAbort: (stats, context, networkDetails) => {
+          frag.stats.aborted = part.stats.aborted;
+          this.resetLoader(frag, loader);
+          reject(
+            new LoadError({
+              type: ErrorTypes.NETWORK_ERROR,
+              details: ErrorDetails.INTERNAL_ABORTED,
+              fatal: false,
+              frag,
+              part,
+              error: new Error('Aborted'),
+              networkDetails,
+              stats,
+            }),
+          );
+        },
+        onTimeout: (stats, context, networkDetails) => {
+          this.resetLoader(frag, loader);
+          reject(
+            new LoadError({
+              type: ErrorTypes.NETWORK_ERROR,
+              details: ErrorDetails.FRAG_LOAD_TIMEOUT,
+              fatal: false,
+              frag,
+              part,
+              error: new Error(`Timeout after ${loaderConfig.timeout}ms`),
+              networkDetails,
+              stats,
+            }),
+          );
+        },
+      });
+    });
+  }
+
+  private updateStatsFromPart(frag: Fragment, part: Part) {
+    const fragStats = frag.stats;
+    const partStats = part.stats;
+    const partTotal = partStats.total;
+    fragStats.loaded += partStats.loaded;
+    if (partTotal) {
+      const estTotalParts = Math.round(frag.duration / part.duration);
+      const estLoadedParts = Math.min(
+        Math.round(fragStats.loaded / partTotal),
+        estTotalParts,
+      );
+      const estRemainingParts = estTotalParts - estLoadedParts;
+      const estRemainingBytes =
+        estRemainingParts * Math.round(fragStats.loaded / estLoadedParts);
+      fragStats.total = fragStats.loaded + estRemainingBytes;
+    } else {
+      fragStats.total = Math.max(fragStats.loaded, fragStats.total);
+    }
+    const fragLoading = fragStats.loading;
+    const partLoading = partStats.loading;
+    if (fragLoading.start) {
+      // add to fragment loader latency
+      fragLoading.first += partLoading.first - partLoading.start;
+    } else {
+      fragLoading.start = partLoading.start;
+      fragLoading.first = partLoading.first;
+    }
+    fragLoading.end = partLoading.end;
+  }
+
+  private resetLoader(frag: Fragment, loader: Loader<FragmentLoaderContext>) {
+    frag.loader = null;
+    if (this.loader === loader) {
+      self.clearTimeout(this.partLoadTimeout);
+      this.loader = null;
+    }
+    loader.destroy();
+  }
+}
+
+function createLoaderContext(
+  frag: Fragment,
+  part: Part | null = null,
+): FragmentLoaderContext {
+  const segment: BaseSegment = part || frag;
+  const loaderContext: FragmentLoaderContext = {
+    frag,
+    part,
+    responseType: 'arraybuffer',
+    url: segment.url,
+    headers: {},
+    rangeStart: 0,
+    rangeEnd: 0,
+  };
+  const start = segment.byteRangeStartOffset as number;
+  const end = segment.byteRangeEndOffset as number;
+  if (Number.isFinite(start) && Number.isFinite(end)) {
+    let byteRangeStart = start;
+    let byteRangeEnd = end;
+    if (
+      frag.sn === 'initSegment' &&
+      isMethodFullSegmentAesCbc(frag.decryptdata?.method)
+    ) {
+      // MAP segment encrypted with method 'AES-128' or 'AES-256' (cbc), when served with HTTP Range,
+      // has the unencrypted size specified in the range.
+      // Ref: https://tools.ietf.org/html/draft-pantos-hls-rfc8216bis-08#section-6.3.6
+      const fragmentLen = end - start;
+      if (fragmentLen % 16) {
+        byteRangeEnd = end + (16 - (fragmentLen % 16));
+      }
+      if (start !== 0) {
+        loaderContext.resetIV = true;
+        byteRangeStart = start - 16;
+      }
+    }
+    loaderContext.rangeStart = byteRangeStart;
+    loaderContext.rangeEnd = byteRangeEnd;
+  }
+  return loaderContext;
+}
+
+function createGapLoadError(frag: Fragment, part?: Part): LoadError {
+  const error = new Error(`GAP ${frag.gap ? 'tag' : 'attribute'} found`);
+  const errorData: FragLoadFailResult = {
+    type: ErrorTypes.MEDIA_ERROR,
+    details: ErrorDetails.FRAG_GAP,
+    fatal: false,
+    frag,
+    error,
+    networkDetails: null,
+  };
+  if (part) {
+    errorData.part = part;
+  }
+  (part ? part : frag).stats.aborted = true;
+  return new LoadError(errorData);
+}
+
+function isMethodFullSegmentAesCbc(method) {
+  return method === 'AES-128' || method === 'AES-256';
+}
+
+export class LoadError extends Error {
+  public readonly data: FragLoadFailResult;
+  constructor(data: FragLoadFailResult) {
+    super(data.error.message);
+    this.data = data;
+  }
+}
+
+export interface FragLoadFailResult extends ErrorData {
+  frag: Fragment;
+  part?: Part;
+  response?: {
+    data: any;
+    // error status code
+    code: number;
+    // error description
+    text: string;
+    url: string;
+  };
+  networkDetails: NullableNetworkDetails;
+}
+
+export type FragmentLoadProgressCallback = (
+  result: FragLoadedData | PartsLoadedData,
+) => void;