hls.js 1.5.14-0.canary.10515 → 1.5.14

package/src/controller/subtitle-stream-controller.ts

@@ -9,16 +9,12 @@ import { PlaylistLevelType } from '../types/loader';
 import { Level } from '../types/level';
 import { subtitleOptionsIdentical } from '../utils/media-option-attributes';
 import { ErrorDetails, ErrorTypes } from '../errors';
-import {
-  isFullSegmentEncryption,
-  getAesModeFromFullSegmentMethod,
-} from '../utils/encryption-methods-util';
 import type { NetworkComponentAPI } from '../types/component-api';
 import type Hls from '../hls';
 import type { FragmentTracker } from './fragment-tracker';
 import type KeyLoader from '../loader/key-loader';
 import type { LevelDetails } from '../loader/level-details';
-import type { Fragment, MediaFragment } from '../loader/fragment';
+import type { Fragment } from '../loader/fragment';
 import type {
   ErrorData,
   FragLoadedData,
@@ -55,22 +51,25 @@ export class SubtitleStreamController
       hls,
       fragmentTracker,
       keyLoader,
-      'subtitle-stream-controller',
+      '[subtitle-stream-controller]',
       PlaylistLevelType.SUBTITLE,
     );
-    this.registerListeners();
+    this._registerListeners();
   }
 
   protected onHandlerDestroying() {
-    this.unregisterListeners();
+    this._unregisterListeners();
     super.onHandlerDestroying();
     this.mainDetails = null;
   }
 
-  protected registerListeners() {
-    super.registerListeners();
+  private _registerListeners() {
     const { hls } = this;
+    hls.on(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.on(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.on(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.on(Events.LEVEL_LOADED, this.onLevelLoaded, this);
+    hls.on(Events.ERROR, this.onError, this);
     hls.on(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
     hls.on(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
     hls.on(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
@@ -79,10 +78,13 @@ export class SubtitleStreamController
     hls.on(Events.FRAG_BUFFERED, this.onFragBuffered, this);
   }
 
-  protected unregisterListeners() {
-    super.unregisterListeners();
+  private _unregisterListeners() {
     const { hls } = this;
+    hls.off(Events.MEDIA_ATTACHED, this.onMediaAttached, this);
+    hls.off(Events.MEDIA_DETACHING, this.onMediaDetaching, this);
+    hls.off(Events.MANIFEST_LOADING, this.onManifestLoading, this);
     hls.off(Events.LEVEL_LOADED, this.onLevelLoaded, this);
+    hls.off(Events.ERROR, this.onError, this);
     hls.off(Events.SUBTITLE_TRACKS_UPDATED, this.onSubtitleTracksUpdated, this);
     hls.off(Events.SUBTITLE_TRACK_SWITCH, this.onSubtitleTrackSwitch, this);
     hls.off(Events.SUBTITLE_TRACK_LOADED, this.onSubtitleTrackLoaded, this);
@@ -105,28 +107,26 @@ export class SubtitleStreamController
     this.tick();
   }
 
-  protected onManifestLoading() {
-    super.onManifestLoading();
+  onManifestLoading() {
     this.mainDetails = null;
+    this.fragmentTracker.removeAllFragments();
   }
 
-  protected onMediaDetaching(): void {
+  onMediaDetaching(): void {
     this.tracksBuffered = [];
     super.onMediaDetaching();
   }
 
-  private onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
+  onLevelLoaded(event: Events.LEVEL_LOADED, data: LevelLoadedData) {
     this.mainDetails = data.details;
   }
 
-  private onSubtitleFragProcessed(
+  onSubtitleFragProcessed(
     event: Events.SUBTITLE_FRAG_PROCESSED,
     data: SubtitleFragProcessed,
   ) {
     const { frag, success } = data;
-    if (frag.sn !== 'initSegment') {
-      this.fragPrevious = frag as MediaFragment;
-    }
+    this.fragPrevious = frag;
     this.state = State.IDLE;
     if (!success) {
       return;
@@ -158,14 +158,11 @@ export class SubtitleStreamController
       };
       buffered.push(timeRange);
     }
-    this.fragmentTracker.fragBuffered(frag as MediaFragment);
+    this.fragmentTracker.fragBuffered(frag);
     this.fragBufferedComplete(frag, null);
   }
 
-  private onBufferFlushing(
-    event: Events.BUFFER_FLUSHING,
-    data: BufferFlushingData,
-  ) {
+  onBufferFlushing(event: Events.BUFFER_FLUSHING, data: BufferFlushingData) {
     const { startOffset, endOffset } = data;
     if (startOffset === 0 && endOffset !== Number.POSITIVE_INFINITY) {
       const endOffsetSubtitles = endOffset - 1;
@@ -194,7 +191,7 @@ export class SubtitleStreamController
     }
   }
 
-  private onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
+  onFragBuffered(event: Events.FRAG_BUFFERED, data: FragBufferedData) {
     if (!this.loadedmetadata && data.frag.type === PlaylistLevelType.MAIN) {
       if (this.media?.buffered.length) {
         this.loadedmetadata = true;
@@ -203,12 +200,12 @@ export class SubtitleStreamController
   }
 
   // If something goes wrong, proceed to next frag, if we were processing one.
-  protected onError(event: Events.ERROR, data: ErrorData) {
+  onError(event: Events.ERROR, data: ErrorData) {
     const frag = data.frag;
 
     if (frag?.type === PlaylistLevelType.SUBTITLE) {
       if (data.details === ErrorDetails.FRAG_GAP) {
-        this.fragmentTracker.fragBuffered(frag as MediaFragment, true);
+        this.fragmentTracker.fragBuffered(frag, true);
       }
       if (this.fragCurrent) {
         this.fragCurrent.abortRequests();
@@ -220,7 +217,7 @@ export class SubtitleStreamController
   }
 
   // Got all new subtitle levels.
-  private onSubtitleTracksUpdated(
+  onSubtitleTracksUpdated(
     event: Events.SUBTITLE_TRACKS_UPDATED,
     { subtitleTracks }: SubtitleTracksUpdatedData,
   ) {
@@ -245,7 +242,7 @@ export class SubtitleStreamController
     this.mediaBuffer = null;
   }
 
-  private onSubtitleTrackSwitch(
+  onSubtitleTrackSwitch(
     event: Events.SUBTITLE_TRACK_SWITCH,
     data: TrackSwitchedData,
   ) {
@@ -263,13 +260,13 @@ export class SubtitleStreamController
     } else {
       this.mediaBuffer = null;
     }
-    if (currentTrack && this.state !== State.STOPPED) {
+    if (currentTrack) {
       this.setInterval(TICK_INTERVAL);
     }
   }
 
   // Got a new set of subtitle fragments.
-  private onSubtitleTrackLoaded(
+  onSubtitleTrackLoaded(
     event: Events.SUBTITLE_TRACK_LOADED,
     data: TrackLoadedData,
   ) {
@@ -370,7 +367,7 @@ export class SubtitleStreamController
       payload.byteLength > 0 &&
       decryptData?.key &&
       decryptData.iv &&
-      isFullSegmentEncryption(decryptData.method)
+      decryptData.method === 'AES-128'
     ) {
       const startTime = performance.now();
       // decrypt the subtitles
@@ -379,7 +376,6 @@ export class SubtitleStreamController
           new Uint8Array(payload),
           decryptData.key.buffer,
           decryptData.iv.buffer,
-          getAesModeFromFullSegmentMethod(decryptData.method),
         )
         .catch((err) => {
           hls.trigger(Events.ERROR, {
@@ -430,9 +426,15 @@ export class SubtitleStreamController
         config.maxBufferHole,
       );
       const { end: targetBufferTime, len: bufferLen } = bufferedInfo;
+
+      const mainBufferInfo = this.getFwdBufferInfo(
+        this.media,
+        PlaylistLevelType.MAIN,
+      );
       const trackDetails = track.details as LevelDetails;
       const maxBufLen =
-        this.hls.maxBufferLength + trackDetails.levelTargetDuration;
+        this.getMaxBufferLength(mainBufferInfo?.len) +
+        trackDetails.levelTargetDuration;
 
       if (bufferLen > maxBufLen) {
         return;
@@ -488,14 +490,24 @@ export class SubtitleStreamController
     }
   }
 
+  protected getMaxBufferLength(mainBufferLength?: number): number {
+    const maxConfigBuffer = super.getMaxBufferLength();
+    if (!mainBufferLength) {
+      return maxConfigBuffer;
+    }
+    return Math.max(maxConfigBuffer, mainBufferLength);
+  }
+
   protected loadFragment(
     frag: Fragment,
     level: Level,
     targetBufferTime: number,
   ) {
+    this.fragCurrent = frag;
     if (frag.sn === 'initSegment') {
       this._loadInitSegment(frag, level);
     } else {
+      this.startFragRequested = true;
       super.loadFragment(frag, level, targetBufferTime);
     }
   }

package/src/controller/subtitle-track-controller.ts

@@ -35,14 +35,13 @@ class SubtitleTrackController extends BasePlaylistController {
   private currentTrack: MediaPlaylist | null = null;
   private selectDefaultTrack: boolean = true;
   private queuedDefaultTrack: number = -1;
+  private asyncPollTrackChange: () => void = () => this.pollTrackChange(0);
   private useTextTrackPolling: boolean = false;
   private subtitlePollingInterval: number = -1;
   private _subtitleDisplay: boolean = true;
 
-  private asyncPollTrackChange = () => this.pollTrackChange(0);
-
   constructor(hls: Hls) {
-    super(hls, 'subtitle-track-controller');
+    super(hls, '[subtitle-track-controller]');
     this.registerListeners();
   }
 
@@ -51,8 +50,7 @@ class SubtitleTrackController extends BasePlaylistController {
     this.tracks.length = 0;
     this.tracksInGroup.length = 0;
     this.currentTrack = null;
-    // @ts-ignore
-    this.onTextTracksChanged = this.asyncPollTrackChange = null;
+    this.onTextTracksChanged = this.asyncPollTrackChange = null as any;
     super.destroy();
   }
 

package/src/controller/timeline-controller.ts

@@ -28,6 +28,7 @@ import type {
   BufferFlushingData,
   FragLoadingData,
 } from '../types/events';
+import { logger } from '../utils/logger';
 import type Hls from '../hls';
 import type { ComponentAPI } from '../types/component-api';
 import type { HlsConfig } from '../config';
@@ -130,17 +131,22 @@ export class TimelineController implements ComponentAPI {
     hls.off(Events.SUBTITLE_TRACKS_CLEARED, this.onSubtitleTracksCleared, this);
     hls.off(Events.BUFFER_FLUSHING, this.onBufferFlushing, this);
     // @ts-ignore
-    this.hls = this.config = this.media = null;
+    this.hls = this.config = null;
     this.cea608Parser1 = this.cea608Parser2 = undefined;
   }
 
   private initCea608Parsers() {
-    const channel1 = new OutputFilter(this, 'textTrack1');
-    const channel2 = new OutputFilter(this, 'textTrack2');
-    const channel3 = new OutputFilter(this, 'textTrack3');
-    const channel4 = new OutputFilter(this, 'textTrack4');
-    this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
-    this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
+    if (
+      this.config.enableCEA708Captions &&
+      (!this.cea608Parser1 || !this.cea608Parser2)
+    ) {
+      const channel1 = new OutputFilter(this, 'textTrack1');
+      const channel2 = new OutputFilter(this, 'textTrack2');
+      const channel3 = new OutputFilter(this, 'textTrack3');
+      const channel4 = new OutputFilter(this, 'textTrack4');
+      this.cea608Parser1 = new Cea608Parser(1, channel1, channel2);
+      this.cea608Parser2 = new Cea608Parser(3, channel3, channel4);
+    }
   }
 
   public addCues(
@@ -192,7 +198,7 @@ export class TimelineController implements ComponentAPI {
     { frag, id, initPTS, timescale }: InitPTSFoundData,
   ) {
     const { unparsedVttFrags } = this;
-    if (id === PlaylistLevelType.MAIN) {
+    if (id === 'main') {
       this.initPTS[frag.cc] = { baseTime: initPTS, timescale };
     }
 
@@ -215,8 +221,6 @@ export class TimelineController implements ComponentAPI {
           canReuseVttTextTrack(textTrack, {
             name: label,
             lang: language,
-            characteristics:
-              'transcribes-spoken-dialog,describes-music-and-sound',
             attrs: {} as any,
           })
         ) {
@@ -305,7 +309,6 @@ export class TimelineController implements ComponentAPI {
       delete captionsTracks[trackName];
     });
     this.nonNativeCaptionsTracks = {};
-    this.media = null;
   }
 
   private onManifestLoading() {
@@ -407,7 +410,7 @@ export class TimelineController implements ComponentAPI {
             .filter((t) => t !== null)
             .map((t) => (t as TextTrack).label);
           if (unusedTextTracks.length) {
-            this.hls.logger.warn(
+            logger.warn(
               `Media element contains unused subtitle tracks: ${unusedTextTracks.join(
                 ', ',
               )}. Replace media element for each source to clear TextTracks and captions menu.`,
@@ -542,7 +545,7 @@ export class TimelineController implements ComponentAPI {
         });
       },
       (error) => {
-        hls.logger.log(`Failed to parse IMSC1: ${error}`);
+        logger.log(`Failed to parse IMSC1: ${error}`);
         hls.trigger(Events.SUBTITLE_FRAG_PROCESSED, {
           success: false,
           frag: frag,
@@ -589,7 +592,7 @@ export class TimelineController implements ComponentAPI {
           this._fallbackToIMSC1(frag, payload);
         }
         // Something went wrong while parsing. Trigger event with success false.
-        hls.logger.log(`Failed to parse VTT cue: ${error}`);
+        logger.log(`Failed to parse VTT cue: ${error}`);
         if (missingInitPTS && maxAvCC > frag.cc) {
           return;
         }
@@ -661,7 +664,9 @@ export class TimelineController implements ComponentAPI {
     event: Events.FRAG_PARSING_USERDATA,
     data: FragParsingUserdataData,
   ) {
-    if (!this.enabled || !this.config.enableCEA708Captions) {
+    this.initCea608Parsers();
+    const { cea608Parser1, cea608Parser2 } = this;
+    if (!this.enabled || !cea608Parser1 || !cea608Parser2) {
       return;
     }
     const { frag, samples } = data;
@@ -676,12 +681,9 @@ export class TimelineController implements ComponentAPI {
     for (let i = 0; i < samples.length; i++) {
       const ccBytes = samples[i].bytes;
       if (ccBytes) {
-        if (!this.cea608Parser1) {
-          this.initCea608Parsers();
-        }
         const ccdatas = this.extractCea608Data(ccBytes);
-        this.cea608Parser1!.addData(samples[i].pts, ccdatas[0]);
-        this.cea608Parser2!.addData(samples[i].pts, ccdatas[1]);
+        cea608Parser1.addData(samples[i].pts, ccdatas[0]);
+        cea608Parser2.addData(samples[i].pts, ccdatas[1]);
       }
     }
   }

package/src/crypt/aes-crypto.ts

@@ -1,32 +1,13 @@
-import { DecrypterAesMode } from './decrypter-aes-mode';
-
 export default class AESCrypto {
   private subtle: SubtleCrypto;
   private aesIV: Uint8Array;
-  private aesMode: DecrypterAesMode;
 
-  constructor(subtle: SubtleCrypto, iv: Uint8Array, aesMode: DecrypterAesMode) {
+  constructor(subtle: SubtleCrypto, iv: Uint8Array) {
     this.subtle = subtle;
     this.aesIV = iv;
-    this.aesMode = aesMode;
   }
 
   decrypt(data: ArrayBuffer, key: CryptoKey) {
-    switch (this.aesMode) {
-      case DecrypterAesMode.cbc:
-        return this.subtle.decrypt(
-          { name: 'AES-CBC', iv: this.aesIV },
-          key,
-          data,
-        );
-      case DecrypterAesMode.ctr:
-        return this.subtle.decrypt(
-          { name: 'AES-CTR', counter: this.aesIV, length: 64 }, //64 : NIST SP800-38A standard suggests that the counter should occupy half of the counter block
-          key,
-          data,
-        );
-      default:
-        throw new Error(`[AESCrypto] invalid aes mode ${this.aesMode}`);
-    }
+    return this.subtle.decrypt({ name: 'AES-CBC', iv: this.aesIV }, key, data);
   }
 }

package/src/crypt/decrypter.ts

@@ -4,7 +4,6 @@ import AESDecryptor, { removePadding } from './aes-decryptor';
 import { logger } from '../utils/logger';
 import { appendUint8Array } from '../utils/mp4-tools';
 import { sliceUint8 } from '../utils/typed-array';
-import { DecrypterAesMode } from './decrypter-aes-mode';
 import type { HlsConfig } from '../config';
 
 const CHUNK_SIZE = 16; // 16 bytes, 128 bits
@@ -20,10 +19,9 @@ export default class Decrypter {
   private currentIV: ArrayBuffer | null = null;
   private currentResult: ArrayBuffer | null = null;
   private useSoftware: boolean;
-  private enableSoftwareAES: boolean;
 
   constructor(config: HlsConfig, { removePKCS7Padding = true } = {}) {
-    this.enableSoftwareAES = config.enableSoftwareAES;
+    this.useSoftware = config.enableSoftwareAES;
     this.removePKCS7Padding = removePKCS7Padding;
     // built in decryptor expects PKCS7 padding
     if (removePKCS7Padding) {
@@ -38,6 +36,7 @@ export default class Decrypter {
         /* no-op */
       }
     }
+
     this.useSoftware = !this.subtle;
   }
 
@@ -82,11 +81,10 @@ export default class Decrypter {
     data: Uint8Array | ArrayBuffer,
     key: ArrayBuffer,
     iv: ArrayBuffer,
-    aesMode: DecrypterAesMode,
   ): Promise<ArrayBuffer> {
     if (this.useSoftware) {
       return new Promise((resolve, reject) => {
-        this.softwareDecrypt(new Uint8Array(data), key, iv, aesMode);
+        this.softwareDecrypt(new Uint8Array(data), key, iv);
         const decryptResult = this.flush();
         if (decryptResult) {
           resolve(decryptResult.buffer);
@@ -95,7 +93,7 @@ export default class Decrypter {
         }
       });
     }
-    return this.webCryptoDecrypt(new Uint8Array(data), key, iv, aesMode);
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
   }
 
   // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
@@ -104,13 +102,8 @@ export default class Decrypter {
     data: Uint8Array,
     key: ArrayBuffer,
     iv: ArrayBuffer,
-    aesMode: DecrypterAesMode,
   ): ArrayBuffer | null {
     const { currentIV, currentResult, remainderData } = this;
-    if (aesMode !== DecrypterAesMode.cbc || key.byteLength !== 16) {
-      logger.warn('SoftwareDecrypt: can only handle AES-128-CBC');
-      return null;
-    }
     this.logOnce('JS AES decrypt');
     // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
     // This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
@@ -153,24 +146,23 @@ export default class Decrypter {
     data: Uint8Array,
     key: ArrayBuffer,
     iv: ArrayBuffer,
-    aesMode: DecrypterAesMode,
   ): Promise<ArrayBuffer> {
     if (this.key !== key || !this.fastAesKey) {
       if (!this.subtle) {
-        return Promise.resolve(this.onWebCryptoError(data, key, iv, aesMode));
+        return Promise.resolve(this.onWebCryptoError(data, key, iv));
       }
       this.key = key;
-      this.fastAesKey = new FastAESKey(this.subtle, key, aesMode);
+      this.fastAesKey = new FastAESKey(this.subtle, key);
     }
     return this.fastAesKey
       .expandKey()
-      .then((aesKey: CryptoKey) => {
+      .then((aesKey) => {
         // decrypt using web crypto
         if (!this.subtle) {
           return Promise.reject(new Error('web crypto not initialized'));
         }
         this.logOnce('WebCrypto AES decrypt');
-        const crypto = new AESCrypto(this.subtle, new Uint8Array(iv), aesMode);
+        const crypto = new AESCrypto(this.subtle, new Uint8Array(iv));
         return crypto.decrypt(data.buffer, aesKey);
       })
       .catch((err) => {
@@ -178,7 +170,7 @@ export default class Decrypter {
           `[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`,
         );
 
-        return this.onWebCryptoError(data, key, iv, aesMode);
+        return this.onWebCryptoError(data, key, iv);
       });
   }
 
@@ -186,23 +178,15 @@ export default class Decrypter {
     data: Uint8Array,
     key: ArrayBuffer,
     iv: ArrayBuffer,
-    aesMode: DecrypterAesMode,
   ): ArrayBuffer | never {
-    const enableSoftwareAES = this.enableSoftwareAES;
-    if (enableSoftwareAES) {
-      this.useSoftware = true;
-      this.logEnabled = true;
-      this.softwareDecrypt(data, key, iv, aesMode);
-      const decryptResult = this.flush();
-      if (decryptResult) {
-        return decryptResult.buffer;
-      }
+    this.useSoftware = true;
+    this.logEnabled = true;
+    this.softwareDecrypt(data, key, iv);
+    const decryptResult = this.flush();
+    if (decryptResult) {
+      return decryptResult.buffer;
     }
-    throw new Error(
-      'WebCrypto' +
-        (enableSoftwareAES ? ' and softwareDecrypt' : '') +
-        ': failed to decrypt data',
-    );
+    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
   }
 
   private getValidChunk(data: Uint8Array): Uint8Array {

package/src/crypt/fast-aes-key.ts

@@ -1,39 +1,16 @@
-import { DecrypterAesMode } from './decrypter-aes-mode';
-
 export default class FastAESKey {
   private subtle: SubtleCrypto;
   private key: ArrayBuffer;
-  private aesMode: DecrypterAesMode;
 
-  constructor(
-    subtle: SubtleCrypto,
-    key: ArrayBuffer,
-    aesMode: DecrypterAesMode,
-  ) {
+  constructor(subtle: SubtleCrypto, key: ArrayBuffer) {
     this.subtle = subtle;
     this.key = key;
-    this.aesMode = aesMode;
   }
 
   expandKey() {
-    const subtleAlgoName = getSubtleAlgoName(this.aesMode);
-    return this.subtle.importKey(
-      'raw',
-      this.key,
-      { name: subtleAlgoName },
-      false,
-      ['encrypt', 'decrypt'],
-    );
-  }
-}
-
-function getSubtleAlgoName(aesMode: DecrypterAesMode) {
-  switch (aesMode) {
-    case DecrypterAesMode.cbc:
-      return 'AES-CBC';
-    case DecrypterAesMode.ctr:
-      return 'AES-CTR';
-    default:
-      throw new Error(`[FastAESKey] invalid aes mode ${aesMode}`);
+    return this.subtle.importKey('raw', this.key, { name: 'AES-CBC' }, false, [
+      'encrypt',
+      'decrypt',
+    ]);
   }
 }

package/src/demux/audio/aacdemuxer.ts

@@ -4,16 +4,16 @@
 import BaseAudioDemuxer from './base-audio-demuxer';
 import * as ADTS from './adts';
 import * as MpegAudio from './mpegaudio';
-import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
+import { logger } from '../../utils/logger';
+import * as ID3 from '../id3';
 import type { HlsEventEmitter } from '../../events';
 import type { HlsConfig } from '../../config';
-import type { ILogger } from '../../utils/logger';
 
 class AACDemuxer extends BaseAudioDemuxer {
   private readonly observer: HlsEventEmitter;
   private readonly config: HlsConfig;
 
-  constructor(observer: HlsEventEmitter, config) {
+  constructor(observer, config) {
     super();
     this.observer = observer;
     this.config = config;
@@ -42,7 +42,7 @@ class AACDemuxer extends BaseAudioDemuxer {
   }
 
   // Source for probe info - https://wiki.multimedia.cx/index.php?title=ADTS
-  static probe(data: Uint8Array | undefined, logger: ILogger): boolean {
+  static probe(data: Uint8Array | undefined): boolean {
     if (!data) {
       return false;
     }
@@ -51,7 +51,7 @@ class AACDemuxer extends BaseAudioDemuxer {
     // Look for ADTS header | 1111 1111 | 1111 X00X | where X can be either 0 or 1
     // Layer bits (position 14 and 15) in header should be always 0 for ADTS
     // More info https://wiki.multimedia.cx/index.php?title=ADTS
-    const id3Data = getId3Data(data, 0);
+    const id3Data = ID3.getID3Data(data, 0);
     let offset = id3Data?.length || 0;
 
     if (MpegAudio.probe(data, offset)) {

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

@@ -1,6 +1,5 @@
 import BaseAudioDemuxer from './base-audio-demuxer';
-import { getId3Data } from '@svta/common-media-library/id3/getId3Data';
-import { getId3Timestamp } from '@svta/common-media-library/id3/getId3Timestamp';
+import { getID3Data, getTimeStamp } from '../id3';
 import { getAudioBSID } from './dolby';
 import type { HlsEventEmitter } from '../../events';
 import type { AudioFrame, DemuxedAudioTrack } from '../../types/demuxer';
@@ -8,7 +7,7 @@ import type { AudioFrame, DemuxedAudioTrack } from '../../types/demuxer';
 export class AC3Demuxer extends BaseAudioDemuxer {
   private readonly observer: HlsEventEmitter;
 
-  constructor(observer: HlsEventEmitter) {
+  constructor(observer) {
     super();
     this.observer = observer;
   }
@@ -62,7 +61,7 @@ export class AC3Demuxer extends BaseAudioDemuxer {
       return false;
     }
 
-    const id3Data = getId3Data(data, 0);
+    const id3Data = getID3Data(data, 0);
     if (!id3Data) {
       return false;
     }
@@ -72,7 +71,7 @@ export class AC3Demuxer extends BaseAudioDemuxer {
     if (
       data[offset] === 0x0b &&
       data[offset + 1] === 0x77 &&
-      getId3Timestamp(id3Data) !== undefined &&
+      getTimeStamp(id3Data) !== undefined &&
       // check the bsid to confirm ac-3
       getAudioBSID(data, offset) < 16
     ) {