hls.js 1.5.14-0.canary.10559 → 1.5.15

package/src/demux/audio/adts.ts

@@ -17,7 +17,6 @@ type AudioConfig = {
   samplerate: number;
   channelCount: number;
   codec: string;
-  parsedCodec: string;
   manifestCodec: string;
 };
 
@@ -33,7 +32,6 @@ export function getAudioConfig(
   audioCodec: string,
 ): AudioConfig | void {
   let adtsObjectType: number;
-  let originalAdtsObjectType: number;
   let adtsExtensionSamplingIndex: number;
   let adtsChannelConfig: number;
   let config: number[];
@@ -44,8 +42,7 @@ export function getAudioConfig(
     8000, 7350,
   ];
   // byte 2
-  adtsObjectType = originalAdtsObjectType =
-    ((data[offset + 2] & 0xc0) >>> 6) + 1;
+  adtsObjectType = ((data[offset + 2] & 0xc0) >>> 6) + 1;
   const adtsSamplingIndex = (data[offset + 2] & 0x3c) >>> 2;
   if (adtsSamplingIndex > adtsSamplingRates.length - 1) {
     const error = new Error(`invalid ADTS sampling index:${adtsSamplingIndex}`);
@@ -64,8 +61,8 @@ export function getAudioConfig(
   logger.log(
     `manifest codec:${audioCodec}, ADTS type:${adtsObjectType}, samplingIndex:${adtsSamplingIndex}`,
   );
-  // Firefox and Pale Moon: freq less than 24kHz = AAC SBR (HE-AAC)
-  if (/firefox|palemoon/i.test(userAgent)) {
+  // firefox: freq less than 24kHz = AAC SBR (HE-AAC)
+  if (/firefox/i.test(userAgent)) {
     if (adtsSamplingIndex >= 6) {
       adtsObjectType = 5;
       config = new Array(4);
@@ -170,7 +167,6 @@ export function getAudioConfig(
     samplerate: adtsSamplingRates[adtsSamplingIndex],
     channelCount: adtsChannelConfig,
     codec: 'mp4a.40.' + adtsObjectType,
-    parsedCodec: 'mp4a.40.' + originalAdtsObjectType,
     manifestCodec,
   };
 }
@@ -248,9 +244,8 @@ export function initTrackConfig(
     track.channelCount = config.channelCount;
     track.codec = config.codec;
     track.manifestCodec = config.manifestCodec;
-    track.parsedCodec = config.parsedCodec;
     logger.log(
-      `parsed codec:${track.parsedCodec}, codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`,
+      `parsed codec:${track.codec}, rate:${config.samplerate}, channels:${config.channelCount}`,
     );
   }
 }

package/src/demux/audio/base-audio-demuxer.ts

@@ -1,21 +1,19 @@
+import * as ID3 from '../id3';
 import {
-  type DemuxerResult,
-  type Demuxer,
-  type DemuxedAudioTrack,
-  type AudioFrame,
-  type DemuxedMetadataTrack,
-  type DemuxedVideoTrackBase,
-  type DemuxedUserdataTrack,
-  type KeyData,
+  DemuxerResult,
+  Demuxer,
+  DemuxedAudioTrack,
+  AudioFrame,
+  DemuxedMetadataTrack,
+  DemuxedVideoTrackBase,
+  DemuxedUserdataTrack,
+  KeyData,
   MetadataSchema,
 } from '../../types/demuxer';
 import { dummyTrack } from '../dummy-demuxed-track';
 import { appendUint8Array } from '../../utils/mp4-tools';
 import { sliceUint8 } from '../../utils/typed-array';
 import { RationalTimestamp } from '../../utils/timescale-conversion';
-import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
-import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
-import { canParseId3 } from '@svta/common-media-library/id3/canParseId3';
 
 class BaseAudioDemuxer implements Demuxer {
   protected _audioTrack!: DemuxedAudioTrack;
@@ -71,12 +69,12 @@ class BaseAudioDemuxer implements Demuxer {
       this.cachedData = null;
     }
 
-    let id3Data: Uint8Array | undefined = getId3Data(data, 0);
+    let id3Data: Uint8Array | undefined = ID3.getID3Data(data, 0);
     let offset = id3Data ? id3Data.length : 0;
     let lastDataIndex;
     const track = this._audioTrack;
     const id3Track = this._id3Track;
-    const timestamp = id3Data ? getId3Timestamp(id3Data) : undefined;
+    const timestamp = id3Data ? ID3.getTimeStamp(id3Data) : undefined;
     const length = data.length;
 
     if (
@@ -113,9 +111,9 @@ class BaseAudioDemuxer implements Demuxer {
         } else {
           offset = length;
         }
-      } else if (canParseId3(data, offset)) {
-        // after a canParse, a call to getId3Data *should* always returns some data
-        id3Data = getId3Data(data, offset)!;
+      } else if (ID3.canParse(data, offset)) {
+        // after a ID3.canParse, a call to ID3.getID3Data *should* always returns some data
+        id3Data = ID3.getID3Data(data, offset)!;
         id3Track.samples.push({
           pts: this.lastPTS,
           dts: this.lastPTS,
@@ -174,11 +172,7 @@ class BaseAudioDemuxer implements Demuxer {
     };
   }
 
-  destroy() {
-    this.cachedData = null;
-    // @ts-ignore
-    this._audioTrack = this._id3Track = undefined;
-  }
+  destroy() {}
 }
 
 /**

package/src/demux/audio/mp3demuxer.ts

@@ -2,11 +2,10 @@
  * MP3 demuxer
  */
 import BaseAudioDemuxer from './base-audio-demuxer';
+import { getID3Data, getTimeStamp } from '../id3';
 import { getAudioBSID } from './dolby';
 import { logger } from '../../utils/logger';
 import * as MpegAudio from './mpegaudio';
-import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
-import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
 
 class MP3Demuxer extends BaseAudioDemuxer {
   resetInitSegment(
@@ -40,7 +39,7 @@ class MP3Demuxer extends BaseAudioDemuxer {
     // Look for MPEG header | 1111 1111 | 111X XYZX | where X can be either 0 or 1 and Y or Z should be 1
     // Layer bits (position 14 and 15) in header should be always different from 0 (Layer I or Layer II or Layer III)
     // More info http://www.mp3-tech.org/programmer/frame_header.html
-    const id3Data = getId3Data(data, 0);
+    const id3Data = getID3Data(data, 0);
     let offset = id3Data?.length || 0;
 
     // Check for ac-3|ec-3 sync bytes and return false if present
@@ -48,7 +47,7 @@ class MP3Demuxer extends BaseAudioDemuxer {
       id3Data &&
       data[offset] === 0x0b &&
       data[offset + 1] === 0x77 &&
-      getId3Timestamp(id3Data) !== undefined &&
+      getTimeStamp(id3Data) !== undefined &&
       // check the bsid to confirm ac-3 or ec-3 (not mp3)
       getAudioBSID(data, offset) <= 16
     ) {

package/src/demux/audio/mpegaudio.ts

@@ -1,7 +1,7 @@
 /**
  *  MPEG parser helper
  */
-import type { DemuxedAudioTrack } from '../../types/demuxer';
+import { DemuxedAudioTrack } from '../../types/demuxer';
 
 let chromeVersion: number | null = null;
 

package/src/demux/id3.ts

@@ -0,0 +1,411 @@
+type RawFrame = { type: string; size: number; data: Uint8Array };
+
+// 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>;
+
+/**
+ * Returns true if an ID3 header can be found at offset in data
+ * @param data - The data to search
+ * @param offset - The offset at which to start searching
+ */
+export const isHeader = (data: Uint8Array, offset: number): boolean => {
+  /*
+   * http://id3.org/id3v2.3.0
+   * [0]     = 'I'
+   * [1]     = 'D'
+   * [2]     = '3'
+   * [3,4]   = {Version}
+   * [5]     = {Flags}
+   * [6-9]   = {ID3 Size}
+   *
+   * An ID3v2 tag can be detected with the following pattern:
+   *  $49 44 33 yy yy xx zz zz zz zz
+   * Where yy is less than $FF, xx is the 'flags' byte and zz is less than $80
+   */
+  if (offset + 10 <= data.length) {
+    // look for 'ID3' identifier
+    if (
+      data[offset] === 0x49 &&
+      data[offset + 1] === 0x44 &&
+      data[offset + 2] === 0x33
+    ) {
+      // check version is within range
+      if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
+        // check size is within range
+        if (
+          data[offset + 6] < 0x80 &&
+          data[offset + 7] < 0x80 &&
+          data[offset + 8] < 0x80 &&
+          data[offset + 9] < 0x80
+        ) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Returns true if an ID3 footer can be found at offset in data
+ * @param data - The data to search
+ * @param offset - The offset at which to start searching
+ */
+export const isFooter = (data: Uint8Array, offset: number): boolean => {
+  /*
+   * The footer is a copy of the header, but with a different identifier
+   */
+  if (offset + 10 <= data.length) {
+    // look for '3DI' identifier
+    if (
+      data[offset] === 0x33 &&
+      data[offset + 1] === 0x44 &&
+      data[offset + 2] === 0x49
+    ) {
+      // check version is within range
+      if (data[offset + 3] < 0xff && data[offset + 4] < 0xff) {
+        // check size is within range
+        if (
+          data[offset + 6] < 0x80 &&
+          data[offset + 7] < 0x80 &&
+          data[offset + 8] < 0x80 &&
+          data[offset + 9] < 0x80
+        ) {
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Returns any adjacent ID3 tags found in data starting at offset, as one block of data
+ * @param data - The data to search in
+ * @param offset - The offset at which to start searching
+ * @returns the block of data containing any ID3 tags found
+ * or *undefined* if no header is found at the starting offset
+ */
+export const getID3Data = (
+  data: Uint8Array,
+  offset: number,
+): Uint8Array | undefined => {
+  const front = offset;
+  let length = 0;
+
+  while (isHeader(data, offset)) {
+    // ID3 header is 10 bytes
+    length += 10;
+
+    const size = readSize(data, offset + 6);
+    length += size;
+
+    if (isFooter(data, offset + 10)) {
+      // ID3 footer is 10 bytes
+      length += 10;
+    }
+
+    offset += length;
+  }
+
+  if (length > 0) {
+    return data.subarray(front, front + length);
+  }
+
+  return undefined;
+};
+
+const readSize = (data: Uint8Array, offset: number): number => {
+  let size = 0;
+  size = (data[offset] & 0x7f) << 21;
+  size |= (data[offset + 1] & 0x7f) << 14;
+  size |= (data[offset + 2] & 0x7f) << 7;
+  size |= data[offset + 3] & 0x7f;
+  return size;
+};
+
+export const canParse = (data: Uint8Array, offset: number): boolean => {
+  return (
+    isHeader(data, offset) &&
+    readSize(data, offset + 6) + 10 <= data.length - offset
+  );
+};
+
+/**
+ * Searches for the Elementary Stream timestamp found in the ID3 data chunk
+ * @param data - Block of data containing one or more ID3 tags
+ */
+export const getTimeStamp = (data: Uint8Array): number | undefined => {
+  const frames: Frame[] = getID3Frames(data);
+
+  for (let i = 0; i < frames.length; i++) {
+    const frame = frames[i];
+
+    if (isTimeStampFrame(frame)) {
+      return readTimeStamp(frame as DecodedFrame<ArrayBuffer>);
+    }
+  }
+
+  return undefined;
+};
+
+/**
+ * Returns true if the ID3 frame is an Elementary Stream timestamp frame
+ */
+export const isTimeStampFrame = (frame: Frame): boolean => {
+  return (
+    frame &&
+    frame.key === 'PRIV' &&
+    frame.info === 'com.apple.streaming.transportStreamTimestamp'
+  );
+};
+
+const getFrameData = (data: Uint8Array): RawFrame => {
+  /*
+  Frame ID       $xx xx xx xx (four characters)
+  Size           $xx xx xx xx
+  Flags          $xx xx
+  */
+  const type: string = String.fromCharCode(data[0], data[1], data[2], data[3]);
+  const size: number = readSize(data, 4);
+
+  // skip frame id, size, and flags
+  const offset = 10;
+
+  return { type, size, data: data.subarray(offset, offset + size) };
+};
+
+/**
+ * Returns an array of ID3 frames found in all the ID3 tags in the id3Data
+ * @param id3Data - The ID3 data containing one or more ID3 tags
+ */
+export const getID3Frames = (id3Data: Uint8Array): Frame[] => {
+  let offset = 0;
+  const frames: Frame[] = [];
+
+  while (isHeader(id3Data, offset)) {
+    const size = readSize(id3Data, offset + 6);
+    // skip past ID3 header
+    offset += 10;
+    const end = offset + size;
+    // loop through frames in the ID3 tag
+    while (offset + 8 < end) {
+      const frameData: RawFrame = getFrameData(id3Data.subarray(offset));
+      const frame: Frame | undefined = decodeFrame(frameData);
+      if (frame) {
+        frames.push(frame);
+      }
+
+      // skip frame header and frame data
+      offset += frameData.size + 10;
+    }
+
+    if (isFooter(id3Data, offset)) {
+      offset += 10;
+    }
+  }
+
+  return frames;
+};
+
+export const decodeFrame = (frame: RawFrame): Frame | undefined => {
+  if (frame.type === 'PRIV') {
+    return decodePrivFrame(frame);
+  } else if (frame.type[0] === 'W') {
+    return decodeURLFrame(frame);
+  }
+
+  return decodeTextFrame(frame);
+};
+
+const decodePrivFrame = (
+  frame: RawFrame,
+): DecodedFrame<ArrayBuffer> | undefined => {
+  /*
+  Format: <text string>\0<binary data>
+  */
+  if (frame.size < 2) {
+    return undefined;
+  }
+
+  const owner = utf8ArrayToStr(frame.data, true);
+  const privateData = new Uint8Array(frame.data.subarray(owner.length + 1));
+
+  return { key: frame.type, info: owner, data: privateData.buffer };
+};
+
+const decodeTextFrame = (frame: RawFrame): DecodedFrame<string> | undefined => {
+  if (frame.size < 2) {
+    return undefined;
+  }
+
+  if (frame.type === 'TXXX') {
+    /*
+    Format:
+    [0]   = {Text Encoding}
+    [1-?] = {Description}\0{Value}
+    */
+    let index = 1;
+    const description = utf8ArrayToStr(frame.data.subarray(index), true);
+
+    index += description.length + 1;
+    const value = utf8ArrayToStr(frame.data.subarray(index));
+
+    return { key: frame.type, info: description, data: value };
+  }
+  /*
+  Format:
+  [0]   = {Text Encoding}
+  [1-?] = {Value}
+  */
+  const text = utf8ArrayToStr(frame.data.subarray(1));
+  return { key: frame.type, data: text };
+};
+
+const decodeURLFrame = (frame: RawFrame): DecodedFrame<string> | undefined => {
+  if (frame.type === 'WXXX') {
+    /*
+    Format:
+    [0]   = {Text Encoding}
+    [1-?] = {Description}\0{URL}
+    */
+    if (frame.size < 2) {
+      return undefined;
+    }
+
+    let index = 1;
+    const description: string = utf8ArrayToStr(
+      frame.data.subarray(index),
+      true,
+    );
+
+    index += description.length + 1;
+    const value: string = utf8ArrayToStr(frame.data.subarray(index));
+
+    return { key: frame.type, info: description, data: value };
+  }
+  /*
+  Format:
+  [0-?] = {URL}
+  */
+  const url: string = utf8ArrayToStr(frame.data);
+  return { key: frame.type, data: url };
+};
+
+const readTimeStamp = (
+  timeStampFrame: DecodedFrame<ArrayBuffer>,
+): number | undefined => {
+  if (timeStampFrame.data.byteLength === 8) {
+    const data = new Uint8Array(timeStampFrame.data);
+    // timestamp is 33 bit expressed as a big-endian eight-octet number,
+    // with the upper 31 bits set to zero.
+    const pts33Bit = data[3] & 0x1;
+    let timestamp =
+      (data[4] << 23) + (data[5] << 15) + (data[6] << 7) + data[7];
+    timestamp /= 45;
+
+    if (pts33Bit) {
+      timestamp += 47721858.84;
+    } // 2^32 / 90
+
+    return Math.round(timestamp);
+  }
+
+  return undefined;
+};
+
+// 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 const utf8ArrayToStr = (
+  array: Uint8Array,
+  exitOnNull: boolean = false,
+): string => {
+  const decoder = getTextDecoder();
+  if (decoder) {
+    const decoded = decoder.decode(array);
+
+    if (exitOnNull) {
+      // grab up to the first null
+      const idx = decoded.indexOf('\0');
+      return idx !== -1 ? decoded.substring(0, idx) : decoded;
+    }
+
+    // remove any null characters
+    return decoded.replace(/\0/g, '');
+  }
+
+  const len = array.length;
+  let c;
+  let char2;
+  let char3;
+  let out = '';
+  let i = 0;
+  while (i < len) {
+    c = array[i++];
+    if (c === 0x00 && exitOnNull) {
+      return out;
+    } else if (c === 0x00 || c === 0x03) {
+      // If the character is 3 (END_OF_TEXT) or 0 (NULL) then skip it
+      continue;
+    }
+    switch (c >> 4) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+      case 4:
+      case 5:
+      case 6:
+      case 7:
+        // 0xxxxxxx
+        out += String.fromCharCode(c);
+        break;
+      case 12:
+      case 13:
+        // 110x xxxx   10xx xxxx
+        char2 = array[i++];
+        out += String.fromCharCode(((c & 0x1f) << 6) | (char2 & 0x3f));
+        break;
+      case 14:
+        // 1110 xxxx  10xx xxxx  10xx xxxx
+        char2 = array[i++];
+        char3 = array[i++];
+        out += String.fromCharCode(
+          ((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0),
+        );
+        break;
+      default:
+    }
+  }
+  return out;
+};
+
+export const testables = {
+  decodeTextFrame: decodeTextFrame,
+};
+
+let decoder: TextDecoder;
+
+function getTextDecoder() {
+  // On Play Station 4, TextDecoder is defined but partially implemented.
+  // Manual decoding option is preferable
+  if (navigator.userAgent.includes('PlayStation 4')) {
+    return;
+  }
+
+  if (!decoder && typeof self.TextDecoder !== 'undefined') {
+    decoder = new self.TextDecoder('utf-8');
+  }
+
+  return decoder;
+}

package/src/demux/inject-worker.ts

@@ -1,9 +1,6 @@
 // ensure the worker ends up in the bundle
 // If the worker should not be included this gets aliased to empty.js
 import './transmuxer-worker';
-import { version } from '../version';
-
-const workerStore: Record<string, WorkerContext> = {};
 
 export function hasUMDWorker(): boolean {
   return typeof __HLS_WORKER_BUNDLE__ === 'function';
@@ -13,15 +10,9 @@ export type WorkerContext = {
   worker: Worker;
   objectURL?: string;
   scriptURL?: string;
-  clientCount: number;
 };
 
 export function injectWorker(): WorkerContext {
-  const workerContext = workerStore[version];
-  if (workerContext) {
-    workerContext.clientCount++;
-    return workerContext;
-  }
   const blob = new self.Blob(
     [
       `var exports={};var module={exports:exports};function define(f){f()};define.amd=true;(${__HLS_WORKER_BUNDLE__.toString()})(true);`,
@@ -32,44 +23,19 @@ export function injectWorker(): WorkerContext {
   );
   const objectURL = self.URL.createObjectURL(blob);
   const worker = new self.Worker(objectURL);
-  const result = {
+
+  return {
     worker,
     objectURL,
-    clientCount: 1,
   };
-  workerStore[version] = result;
-  return result;
 }
 
 export function loadWorker(path: string): WorkerContext {
-  const workerContext = workerStore[path];
-  if (workerContext) {
-    workerContext.clientCount++;
-    return workerContext;
-  }
   const scriptURL = new self.URL(path, self.location.href).href;
   const worker = new self.Worker(scriptURL);
-  const result = {
+
+  return {
     worker,
     scriptURL,
-    clientCount: 1,
   };
-  workerStore[path] = result;
-  return result;
-}
-
-export function removeWorkerFromStore(path?: string | null) {
-  const workerContext = workerStore[path || version];
-  if (workerContext) {
-    const clientCount = workerContext.clientCount--;
-    if (clientCount === 1) {
-      const { worker, objectURL } = workerContext;
-      delete workerStore[path || version];
-      if (objectURL) {
-        // revoke the Object URL that was used to create transmuxer worker, so as not to leak it
-        self.URL.revokeObjectURL(objectURL);
-      }
-      worker.terminate();
-    }
-  }
 }

package/src/demux/mp4demuxer.ts

@@ -2,13 +2,13 @@
  * MP4 demuxer
  */
 import {
-  type Demuxer,
-  type DemuxerResult,
-  type PassthroughTrack,
-  type DemuxedAudioTrack,
-  type DemuxedUserdataTrack,
-  type DemuxedMetadataTrack,
-  type KeyData,
+  Demuxer,
+  DemuxerResult,
+  PassthroughTrack,
+  DemuxedAudioTrack,
+  DemuxedUserdataTrack,
+  DemuxedMetadataTrack,
+  KeyData,
   MetadataSchema,
 } from '../types/demuxer';
 import {
@@ -194,16 +194,7 @@ class MP4Demuxer implements Demuxer {
     );
   }
 
-  destroy() {
-    // @ts-ignore
-    this.config = null;
-    this.remainderData = null;
-    this.videoTrack =
-      this.audioTrack =
-      this.id3Track =
-      this.txtTrack =
-        undefined;
-  }
+  destroy() {}
 }
 
 export default MP4Demuxer;

package/src/demux/sample-aes.ts

@@ -4,7 +4,6 @@
 
 import { HlsConfig } from '../config';
 import Decrypter from '../crypt/decrypter';
-import { DecrypterAesMode } from '../crypt/decrypter-aes-mode';
 import { HlsEventEmitter } from '../events';
 import type {
   AudioSample,
@@ -31,7 +30,6 @@ class SampleAesDecrypter {
       encryptedData,
       this.keyData.key.buffer,
       this.keyData.iv.buffer,
-      DecrypterAesMode.cbc,
     );
   }