@zenvor/hls.js 1.0.0

package/src/utils/chunker.ts

@@ -0,0 +1,41 @@
+import { appendUint8Array } from './mp4-tools';
+
+export default class Chunker {
+  private chunkSize: number;
+  public cache: Uint8Array | null = null;
+  constructor(chunkSize = Math.pow(2, 19)) {
+    this.chunkSize = chunkSize;
+  }
+
+  public push(data: Uint8Array): Array<Uint8Array> {
+    const { cache, chunkSize } = this;
+    const result: Array<Uint8Array> = [];
+
+    let temp: Uint8Array | null = null;
+    if (cache?.length) {
+      temp = appendUint8Array(cache, data);
+      this.cache = null;
+    } else {
+      temp = data;
+    }
+
+    if (temp.length < chunkSize) {
+      this.cache = temp;
+      return result;
+    }
+
+    if (temp.length > chunkSize) {
+      let offset = 0;
+      const len = temp.length;
+      while (offset < len - chunkSize) {
+        result.push(temp.slice(offset, offset + chunkSize));
+        offset += chunkSize;
+      }
+      this.cache = temp.slice(offset);
+    } else {
+      result.push(temp);
+    }
+
+    return result;
+  }
+}

package/src/utils/codecs.ts

@@ -0,0 +1,314 @@
+import { getMediaSource } from './mediasource-helper';
+import { isHEVC } from './mp4-tools';
+
+export const userAgentHevcSupportIsInaccurate = () => {
+  return /\(Windows.+Firefox\//i.test(navigator.userAgent);
+};
+
+// from http://mp4ra.org/codecs.html
+// values indicate codec selection preference (lower is higher priority)
+export const sampleEntryCodesISO = {
+  audio: {
+    a3ds: 1,
+    'ac-3': 0.95,
+    'ac-4': 1,
+    alac: 0.9,
+    alaw: 1,
+    dra1: 1,
+    'dts+': 1,
+    'dts-': 1,
+    dtsc: 1,
+    dtse: 1,
+    dtsh: 1,
+    'ec-3': 0.9,
+    enca: 1,
+    fLaC: 0.9, // MP4-RA listed codec entry for FLAC
+    flac: 0.9, // legacy browser codec name for FLAC
+    FLAC: 0.9, // some manifests may list "FLAC" with Apple's tools
+    g719: 1,
+    g726: 1,
+    m4ae: 1,
+    mha1: 1,
+    mha2: 1,
+    mhm1: 1,
+    mhm2: 1,
+    mlpa: 1,
+    mp4a: 1,
+    'raw ': 1,
+    Opus: 1,
+    opus: 1, // browsers expect this to be lowercase despite MP4RA says 'Opus'
+    samr: 1,
+    sawb: 1,
+    sawp: 1,
+    sevc: 1,
+    sqcp: 1,
+    ssmv: 1,
+    twos: 1,
+    ulaw: 1,
+  },
+  video: {
+    avc1: 1,
+    avc2: 1,
+    avc3: 1,
+    avc4: 1,
+    avcp: 1,
+    av01: 0.8,
+    dav1: 0.8,
+    drac: 1,
+    dva1: 1,
+    dvav: 1,
+    dvh1: 0.7,
+    dvhe: 0.7,
+    encv: 1,
+    hev1: 0.75,
+    hvc1: 0.75,
+    mjp2: 1,
+    mp4v: 1,
+    mvc1: 1,
+    mvc2: 1,
+    mvc3: 1,
+    mvc4: 1,
+    resv: 1,
+    rv60: 1,
+    s263: 1,
+    svc1: 1,
+    svc2: 1,
+    'vc-1': 1,
+    vp08: 1,
+    vp09: 0.9,
+  },
+  text: {
+    stpp: 1,
+    wvtt: 1,
+  },
+} as const;
+
+export type CodecType = 'audio' | 'video';
+
+export function isCodecType(codec: string, type: CodecType): boolean {
+  const typeCodes = sampleEntryCodesISO[type];
+  return !!typeCodes && !!typeCodes[codec.slice(0, 4)];
+}
+
+export function areCodecsMediaSourceSupported(
+  codecs: string,
+  type: CodecType,
+  preferManagedMediaSource = true,
+): boolean {
+  return !codecs
+    .split(',')
+    .some(
+      (codec) =>
+        !isCodecMediaSourceSupported(codec, type, preferManagedMediaSource),
+    );
+}
+
+function isCodecMediaSourceSupported(
+  codec: string,
+  type: CodecType,
+  preferManagedMediaSource = true,
+): boolean {
+  const MediaSource = getMediaSource(preferManagedMediaSource);
+  return MediaSource?.isTypeSupported(mimeTypeForCodec(codec, type)) ?? false;
+}
+
+export function mimeTypeForCodec(codec: string, type: CodecType): string {
+  return `${type}/mp4;codecs=${codec}`;
+}
+
+export function videoCodecPreferenceValue(
+  videoCodec: string | undefined,
+): number {
+  if (videoCodec) {
+    const fourCC = videoCodec.substring(0, 4);
+    return sampleEntryCodesISO.video[fourCC];
+  }
+  return 2;
+}
+
+export function codecsSetSelectionPreferenceValue(codecSet: string): number {
+  const limitedHevcSupport = userAgentHevcSupportIsInaccurate();
+  return codecSet.split(',').reduce((num, fourCC) => {
+    const lowerPriority = limitedHevcSupport && isHEVC(fourCC);
+    const preferenceValue = lowerPriority
+      ? 9
+      : sampleEntryCodesISO.video[fourCC];
+    if (preferenceValue) {
+      return (preferenceValue * 2 + num) / (num ? 3 : 2);
+    }
+    return (sampleEntryCodesISO.audio[fourCC] + num) / (num ? 2 : 1);
+  }, 0);
+}
+
+interface CodecNameCache {
+  flac?: string;
+  opus?: string;
+}
+
+const CODEC_COMPATIBLE_NAMES: CodecNameCache = {};
+
+type LowerCaseCodecType = 'flac' | 'opus';
+
+function getCodecCompatibleNameLower(
+  lowerCaseCodec: LowerCaseCodecType,
+  preferManagedMediaSource = true,
+): string {
+  if (CODEC_COMPATIBLE_NAMES[lowerCaseCodec]) {
+    return CODEC_COMPATIBLE_NAMES[lowerCaseCodec]!;
+  }
+
+  const codecsToCheck = {
+    // Idealy fLaC and Opus would be first (spec-compliant) but
+    // some browsers will report that fLaC is supported then fail.
+    // see: https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
+    flac: ['flac', 'fLaC', 'FLAC'],
+    opus: ['opus', 'Opus'],
+    // Replace audio codec info if browser does not support mp4a.40.34,
+    // and demuxer can fallback to 'audio/mpeg' or 'audio/mp4;codecs="mp3"'
+    'mp4a.40.34': ['mp3'],
+  }[lowerCaseCodec];
+
+  for (let i = 0; i < codecsToCheck.length; i++) {
+    if (
+      isCodecMediaSourceSupported(
+        codecsToCheck[i],
+        'audio',
+        preferManagedMediaSource,
+      )
+    ) {
+      CODEC_COMPATIBLE_NAMES[lowerCaseCodec] = codecsToCheck[i];
+      return codecsToCheck[i];
+    } else if (
+      codecsToCheck[i] === 'mp3' &&
+      getMediaSource(preferManagedMediaSource)?.isTypeSupported('audio/mpeg')
+    ) {
+      return '';
+    }
+  }
+
+  return lowerCaseCodec;
+}
+
+const AUDIO_CODEC_REGEXP = /flac|opus|mp4a\.40\.34/i;
+export function getCodecCompatibleName(
+  codec: string,
+  preferManagedMediaSource = true,
+): string {
+  return codec.replace(AUDIO_CODEC_REGEXP, (m) =>
+    getCodecCompatibleNameLower(
+      m.toLowerCase() as LowerCaseCodecType,
+      preferManagedMediaSource,
+    ),
+  );
+}
+
+export function replaceVideoCodec(
+  originalCodecs: string | undefined,
+  newVideoCodec: string | undefined,
+): string | undefined {
+  const codecs: string[] = [];
+  if (originalCodecs) {
+    const allCodecs = originalCodecs.split(',');
+    for (let i = 0; i < allCodecs.length; i++) {
+      if (!isCodecType(allCodecs[i], 'video')) {
+        codecs.push(allCodecs[i]);
+      }
+    }
+  }
+  if (newVideoCodec) {
+    codecs.push(newVideoCodec);
+  }
+  return codecs.join(',');
+}
+
+export function pickMostCompleteCodecName(
+  parsedCodec: string | undefined,
+  levelCodec: string | undefined,
+): string | undefined {
+  // Parsing of mp4a codecs strings in mp4-tools from media is incomplete as of d8c6c7a
+  // so use level codec is parsed codec is unavailable or incomplete
+  if (
+    parsedCodec &&
+    (parsedCodec.length > 4 ||
+      ['ac-3', 'ec-3', 'alac', 'fLaC', 'Opus'].indexOf(parsedCodec) !== -1)
+  ) {
+    if (
+      isCodecSupportedAsType(parsedCodec, 'audio') ||
+      isCodecSupportedAsType(parsedCodec, 'video')
+    ) {
+      return parsedCodec;
+    }
+  }
+  if (levelCodec) {
+    const levelCodecs = levelCodec.split(',');
+    if (levelCodecs.length > 1) {
+      if (parsedCodec) {
+        for (let i = levelCodecs.length; i--; ) {
+          if (levelCodecs[i].substring(0, 4) === parsedCodec.substring(0, 4)) {
+            return levelCodecs[i];
+          }
+        }
+      }
+      return levelCodecs[0];
+    }
+  }
+  return levelCodec || parsedCodec;
+}
+
+function isCodecSupportedAsType(codec: string, type: CodecType): boolean {
+  return isCodecType(codec, type) && isCodecMediaSourceSupported(codec, type);
+}
+
+export function convertAVC1ToAVCOTI(videoCodecs: string): string {
+  // Convert avc1 codec string from RFC-4281 to RFC-6381 for MediaSource.isTypeSupported
+  // Examples: avc1.66.30 to avc1.42001e and avc1.77.30,avc1.66.30 to avc1.4d001e,avc1.42001e.
+  const codecs = videoCodecs.split(',');
+  for (let i = 0; i < codecs.length; i++) {
+    const avcdata = codecs[i].split('.');
+    // only convert codec strings starting with avc1 (Examples: avc1.64001f,dvh1.05.07)
+    if (avcdata.length > 2 && avcdata[0] === 'avc1') {
+      codecs[i] = `avc1.${parseInt(avcdata[1]).toString(16)}${(
+        '000' + parseInt(avcdata[2]).toString(16)
+      ).slice(-4)}`;
+    }
+  }
+  return codecs.join(',');
+}
+
+export function fillInMissingAV01Params(videoCodec: string): string {
+  // Used to fill in incomplete AV1 playlist CODECS strings for mediaCapabilities.decodingInfo queries
+  if (videoCodec.startsWith('av01.')) {
+    const av1params = videoCodec.split('.');
+    const placeholders = ['0', '111', '01', '01', '01', '0'];
+    for (let i = av1params.length; i > 4 && i < 10; i++) {
+      av1params[i] = placeholders[i - 4];
+    }
+    return av1params.join('.');
+  }
+  return videoCodec;
+}
+
+export interface TypeSupported {
+  mpeg: boolean;
+  mp3: boolean;
+  ac3: boolean;
+}
+
+export function getM2TSSupportedAudioTypes(
+  preferManagedMediaSource: boolean,
+): TypeSupported {
+  const MediaSource = getMediaSource(preferManagedMediaSource) || {
+    isTypeSupported: () => false,
+  };
+  return {
+    mpeg: MediaSource.isTypeSupported('audio/mpeg'),
+    mp3: MediaSource.isTypeSupported('audio/mp4; codecs="mp3"'),
+    ac3: __USE_M2TS_ADVANCED_CODECS__
+      ? MediaSource.isTypeSupported('audio/mp4; codecs="ac-3"')
+      : false,
+  };
+}
+
+export function getCodecsForMimeType(mimeType: string): string {
+  return mimeType.replace(/^.+codecs=["']?([^"']+).*$/, '$1');
+}

package/src/utils/cues.ts

@@ -0,0 +1,96 @@
+import { addCueToTrack } from './texttrack-utils';
+import { fixLineBreaks } from './vttparser';
+import { generateCueId } from './webvtt-parser';
+import type { CaptionScreen, Row } from './cea-608-parser';
+
+const WHITESPACE_CHAR = /\s/;
+
+export interface CuesInterface {
+  newCue(
+    track: TextTrack | null,
+    startTime: number,
+    endTime: number,
+    captionScreen: CaptionScreen,
+  ): VTTCue[];
+}
+
+const Cues: CuesInterface = {
+  newCue(
+    track: TextTrack | null,
+    startTime: number,
+    endTime: number,
+    captionScreen: CaptionScreen,
+  ): VTTCue[] {
+    const result: VTTCue[] = [];
+    let row: Row;
+    // the type data states this is VTTCue, but it can potentially be a TextTrackCue on old browsers
+    let cue: VTTCue;
+    let indenting: boolean;
+    let indent: number;
+    let text: string;
+    const Cue = (self.VTTCue || self.TextTrackCue) as any;
+
+    for (let r = 0; r < captionScreen.rows.length; r++) {
+      row = captionScreen.rows[r];
+      indenting = true;
+      indent = 0;
+      text = '';
+
+      if (!row.isEmpty()) {
+        for (let c = 0; c < row.chars.length; c++) {
+          if (WHITESPACE_CHAR.test(row.chars[c].uchar) && indenting) {
+            indent++;
+          } else {
+            text += row.chars[c].uchar;
+            indenting = false;
+          }
+        }
+        // To be used for cleaning-up orphaned roll-up captions
+        row.cueStartTime = startTime;
+
+        // Give a slight bump to the endTime if it's equal to startTime to avoid a SyntaxError in IE
+        if (startTime === endTime) {
+          endTime += 0.0001;
+        }
+
+        if (indent >= 16) {
+          indent--;
+        } else {
+          indent++;
+        }
+
+        const cueText = fixLineBreaks(text.trim());
+        const id = generateCueId(startTime, endTime, cueText);
+
+        // If this cue already exists in the track do not push it
+        if (!track?.cues?.getCueById(id)) {
+          cue = new Cue(startTime, endTime, cueText);
+          cue.id = id;
+          cue.line = r + 1;
+          cue.align = 'left';
+          // Clamp the position between 10 and 80 percent (CEA-608 PAC indent code)
+          // https://dvcs.w3.org/hg/text-tracks/raw-file/default/608toVTT/608toVTT.html#positioning-in-cea-608
+          // Firefox throws an exception and captions break with out of bounds 0-100 values
+          cue.position = 10 + Math.min(80, Math.floor((indent * 8) / 32) * 10);
+          result.push(cue);
+        }
+      }
+    }
+    if (track && result.length) {
+      // Sort bottom cues in reverse order so that they render in line order when overlapping in Chrome
+      result.sort((cueA, cueB) => {
+        if (cueA.line === 'auto' || cueB.line === 'auto') {
+          return 0;
+        }
+        if (cueA.line > 8 && cueB.line > 8) {
+          return cueB.line - cueA.line;
+        }
+        return cueA.line - cueB.line;
+      });
+      result.forEach((cue) => addCueToTrack(track, cue));
+    }
+    return result;
+  },
+};
+
+export default Cues;

package/src/utils/discontinuities.ts

@@ -0,0 +1,174 @@
+import { adjustSliding } from './level-helper';
+import type { ILogger } from './logger';
+import type { Fragment } from '../loader/fragment';
+import type { LevelDetails } from '../loader/level-details';
+
+export function findFirstFragWithCC(
+  fragments: Fragment[],
+  cc: number,
+): Fragment | null {
+  for (let i = 0, len = fragments.length; i < len; i++) {
+    if (fragments[i]?.cc === cc) {
+      return fragments[i];
+    }
+  }
+  return null;
+}
+
+export function shouldAlignOnDiscontinuities(
+  refDetails: LevelDetails | undefined,
+  details: LevelDetails,
+): refDetails is LevelDetails & boolean {
+  if (refDetails) {
+    if (
+      details.startCC < refDetails.endCC &&
+      details.endCC > refDetails.startCC
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function adjustFragmentStart(frag: Fragment, sliding: number) {
+  const start = frag.start + sliding;
+  frag.startPTS = start;
+  frag.setStart(start);
+  frag.endPTS = start + frag.duration;
+}
+
+export function adjustSlidingStart(sliding: number, details: LevelDetails) {
+  // Update segments
+  const fragments = details.fragments;
+  for (let i = 0, len = fragments.length; i < len; i++) {
+    adjustFragmentStart(fragments[i], sliding);
+  }
+  // Update LL-HLS parts at the end of the playlist
+  if (details.fragmentHint) {
+    adjustFragmentStart(details.fragmentHint, sliding);
+  }
+  details.alignedSliding = true;
+}
+
+/**
+ * Using the parameters of the last level, this function computes PTS' of the new fragments so that they form a
+ * contiguous stream with the last fragments.
+ * The PTS of a fragment lets Hls.js know where it fits into a stream - by knowing every PTS, we know which fragment to
+ * download at any given time. PTS is normally computed when the fragment is demuxed, so taking this step saves us time
+ * and an extra download.
+ * @param lastLevel
+ * @param details
+ */
+export function alignStream(
+  switchDetails: LevelDetails | undefined,
+  details: LevelDetails,
+  logger: ILogger,
+) {
+  if (!switchDetails) {
+    return;
+  }
+  alignDiscontinuities(details, switchDetails, logger);
+  if (!details.alignedSliding) {
+    // If the PTS wasn't figured out via discontinuity sequence that means there was no CC increase within the level.
+    // Aligning via Program Date Time should therefore be reliable, since PDT should be the same within the same
+    // discontinuity sequence.
+    alignMediaPlaylistByPDT(details, switchDetails, logger);
+  }
+  if (!details.alignedSliding && !details.skippedSegments) {
+    // Try to align on sn so that we pick a better start fragment.
+    // Do not perform this on playlists with delta updates as this is only to align levels on switch
+    // and adjustSliding only adjusts fragments after skippedSegments.
+    adjustSliding(switchDetails, details, false, logger);
+  }
+}
+
+/**
+ * Ajust the start of fragments in `details` by the difference in time between fragments of the latest
+ * shared discontinuity sequence change.
+ * @param lastLevel - The details of the last loaded level
+ * @param details - The details of the new level
+ */
+export function alignDiscontinuities(
+  details: LevelDetails,
+  refDetails: LevelDetails | undefined,
+  logger: ILogger,
+) {
+  if (!shouldAlignOnDiscontinuities(refDetails, details)) {
+    return;
+  }
+  const targetCC = Math.min(refDetails.endCC, details.endCC);
+  const refFrag = findFirstFragWithCC(refDetails.fragments, targetCC);
+  const frag = findFirstFragWithCC(details.fragments, targetCC);
+  if (!refFrag || !frag) {
+    return;
+  }
+  const delta = refFrag.start - frag.start;
+  logger.log(
+    `Aligning playlists using dicontinuity sequence ${targetCC} (diff: ${delta})`,
+  );
+  adjustSlidingStart(delta, details);
+}
+
+/**
+ * Ensures appropriate time-alignment between renditions based on PDT.
+ * This function assumes the timelines represented in `refDetails` are accurate, including the PDTs
+ * for the last discontinuity sequence number shared by both playlists when present,
+ * and uses the "wallclock"/PDT timeline as a cross-reference to `details`, adjusting the presentation
+ * times/timelines of `details` accordingly.
+ * Given the asynchronous nature of fetches and initial loads of live `main` and audio/subtitle tracks,
+ * the primary purpose of this function is to ensure the "local timelines" of audio/subtitle tracks
+ * are aligned to the main/video timeline, using PDT as the cross-reference/"anchor" that should
+ * be consistent across playlists, per the HLS spec.
+ * @param details - The details of the rendition you'd like to time-align (e.g. an audio rendition).
+ * @param refDetails - The details of the reference rendition with start and PDT times for alignment.
+ */
+export function alignMediaPlaylistByPDT(
+  details: LevelDetails,
+  refDetails: LevelDetails,
+  logger: ILogger,
+) {
+  if (!details.hasProgramDateTime || !refDetails.hasProgramDateTime) {
+    return;
+  }
+
+  const fragments = details.fragments;
+  const refFragments = refDetails.fragments;
+  if (!fragments.length || !refFragments.length) {
+    return;
+  }
+
+  // Calculate a delta to apply to all fragments according to the delta in PDT times and start times
+  // of a fragment in the reference details, and a fragment in the target details of the same discontinuity.
+  // If a fragment of the same discontinuity was not found use the middle fragment of both.
+  let refFrag: Fragment | null | undefined;
+  let frag: Fragment | null | undefined;
+  const targetCC = Math.min(refDetails.endCC, details.endCC);
+  if (refDetails.startCC < targetCC && details.startCC < targetCC) {
+    refFrag = findFirstFragWithCC(refFragments, targetCC);
+    frag = findFirstFragWithCC(fragments, targetCC);
+  }
+  if (!refFrag || !frag) {
+    refFrag = refFragments[Math.floor(refFragments.length / 2)];
+    frag =
+      findFirstFragWithCC(fragments, refFrag.cc) ||
+      fragments[Math.floor(fragments.length / 2)];
+  }
+  const refPDT = refFrag.programDateTime;
+  const targetPDT = frag.programDateTime;
+  if (!refPDT || !targetPDT) {
+    return;
+  }
+
+  const dateDifference = (targetPDT - refPDT) / 1000;
+  if (Math.abs(dateDifference) > Math.max(60, details.totalduration)) {
+    // Do not align on PDT if ranges differ significantly
+    logger.log(
+      `Cannot align playlists using PDT without overlap (${Math.abs(dateDifference)} > ${details.totalduration})`,
+    );
+    return;
+  }
+
+  const delta = dateDifference - (frag.start - refFrag.start);
+  logger.log(`Aligning playlists using PDT (diff: ${delta})`);
+  adjustSlidingStart(delta, details);
+}

package/src/utils/encryption-methods-util.ts

@@ -0,0 +1,21 @@
+import { DecrypterAesMode } from '../crypt/decrypter-aes-mode';
+
+export function isFullSegmentEncryption(method: string): boolean {
+  return (
+    method === 'AES-128' || method === 'AES-256' || method === 'AES-256-CTR'
+  );
+}
+
+export function getAesModeFromFullSegmentMethod(
+  method: string,
+): DecrypterAesMode {
+  switch (method) {
+    case 'AES-128':
+    case 'AES-256':
+      return DecrypterAesMode.cbc;
+    case 'AES-256-CTR':
+      return DecrypterAesMode.ctr;
+    default:
+      throw new Error(`invalid full segment method ${method}`);
+  }
+}